是否存在非短路逻辑“与”？在 C++ 中？

Question

tl;dr: C++中有非短路逻辑AND（类似于&&）吗？

我有两个要调用的函数，并使用返回值来计算出第三个复合函数的返回值。问题是我总是希望两个函数都进行评估（因为它们输出有关系统状态的日志信息）

IE：

bool Func1(int x, int y){
  if( x > y){
    cout << "ERROR- X > Y" << endl;
  }
}
bool Func2(int z, int q){
  if( q * 3 < z){
    cout << "ERROR- Q < Z/3" << endl;
  }
}
bool Func3(int x, int y, int z, int q){
  return ( Func1(x, y) && Func2(z, q) );
}

当然，函数中的条件并不那么简单，是的，我意识到我可以使用临时变量来存储两个函数的返回，然后对临时变量执行“短路”逻辑，但我想知道是否有一种“优雅”的语言解决方案可以在 Func3 中保留单行返回，同时仍然得到来自两个函数的日志消息。

---

回复摘要：

“按位”运算符 |和&可以用来获得效果，但前提是返回类型为 bool。我发现 ANSI C++ 规范中没有提及这一点。据我所知，这是有效的，因为“bool”被转换为 int (true = 1, false = 0)，然后使用按位运算符，然后它被转换回 bool。

还可以使用运算符“+”和“*”。 ANSI C++ 规范中没有提到这一点，但可能由于与上述相同的原因而起作用。 “+”给出“或”，因为 true 被转换为 1，然后除 0 之外的任何值都被转换回 true。 “*”适用于“and”，因为 1 (true) * 0 (false) == 0(false) 和 1(true) * 1(true) == 1(true)

这两者似乎依赖于隐式类型转换为整数，然后再转换回布尔值。这两种情况都可能会让试图维护代码的人陷入困境。

其他回答归结为“仅使用临时文件”或“实现您自己的”，这不是问题所在。目标是查看 C++ 标准中是否已经实现了一个运算符来执行此操作。

Answer 1

& 运算符对 bool 操作数执行逻辑“与”运算，并且不短路。

这不是一个序列点。您不能依赖操作数的求值顺序。但是，可以保证两个操作数都被求值。

我不建议这样做。使用临时变量是更好的解决方案。不要为了“聪明的代码”而牺牲可读性。

Answer 2

是的，我意识到我可以使用临时变量来存储两个函数的返回，然后对临时变量执行“短路”逻辑，但我想知道是否有一个“优雅”的语言解决方案在 Func3 中保留单行返回，同时仍然从两个函数获取日志消息。

这将是“优雅”的解决方案:)。对于下一个进入您的项目的开发人员来说，依赖评估顺序的副作用远非优雅，容易出错，而且难以理解。当然，依赖副作用与以下代码片段形成对比，这是仅依赖评估顺序的完全逻辑且有效的用例：

if ( obj != NULL && obj->foo == blah ) { /* do stuff */ }

Answer 3

是的，有内置的运算符可以执行此操作。
+ 执行非短路 OR，* 执行 AND。

☺

#include <iostream>
using namespace std;

void print(bool b)
{
    cout << boolalpha << b << endl;
}

int main() 
{
    print(true + false);
    print(true * false);
}

输出：

正确

假

Answer 4

您可以简单地编写自己的。

bool LongCircuitAnd( bool term1, bool term2 ) { return term1 && term2; }

bool Func3(int x, int y, int z, int q){
  return LongCircuitAnd( Func1(x,y), Func2(z,q) ); 

如果你想要非常奇特，你甚至可以内联它！

好吧，好吧，如果你真的不想要调用函数的可怕开销。

bool Func3(int x, int y, int z, int q){
  return ((int)Func1(x,y)) * ((int)Func2(z,q)); 

但我不认为那么优雅。可以想象，一个过于聪明的编译器可能会短路这个......

Answer 5

如果要使用临时变量，但将返回保留为单个语句，则可以使用逗号运算符：

return (b1=Func1()), (b2=Func2()), (b1&&b2);

逗号运算符强制序列点，因此每个点都会评估其左操作数，丢弃结果，然后评估其右操作数。

另一种可能性（但我倾向于建议反对）是两个函数返回一个重载“&&”的类型。操作员。由于重载运算符调用函数，因此它总是对两个操作数求值，即使在内置运算符不求值的情况下（如 &&）——通常这会产生问题，但在这种情况正是你想要的：

class mybool { 
    bool value;
public:
    bool operator&&(mybool const &other) const { 
        return value && other.value;
    }
};

mybool Func1(int, int);
mybool Func2(int, int);

bool Func3(int x, int y, int z, int q) { 
    return Func1(x, y) && Func2(z,q);
}

虽然这有效，但在我看来，它有点太“聪明”了——这对大多数读者来说根本不明显。为 mybool 起一个不同的名称可能会有所帮助，但我想不出一个可以很好地反映意图而又不会变得如此冗长以至于造成净损失的名称。

Answer 6

是的。 operator&& 和 operator|| 的重载版本不会短路 - 即使左侧操作数“确定”结果，它们也会评估两个操作数。 （来源）

话虽这么说，不要重载 operator&& 或 operator||。善待维护程序员，他们会查看 && 或 || 并假设它们发生了短路。

Answer 7

正是为了这个目的，引入了一种近乎通用但通常没有记录的非标准运算符，它是由 GCC 与 x ?: y 一起开创的（x if 非零，否则 y），现在遗憾地删除了 >? 和 min/max 运算符及其复合赋值形式（请参阅 http://gcc.gnu.org/onlinedocs/gcc/Deprecated-Features.html）。可悲的是，随着 & 和 && 已经在使用，他们似乎一直在刮擦桶的底部来寻找合适的字符序列，但这只是我的意见 - 欢迎任何历史解释来解释为什么会选择这个。

因此，虽然它目前不像许多其他运算符那样广为人知，但 >! 运算符（正确但无聊地称为“长电路与”，但通俗地说是“更大的结”大多数 C 和 C++ 编译器（包括 GCC 甚至 MSVC++）都添加了“由知情人士提供”来满足此要求：

bool f1() { ... }
bool f2() { ... }

...
bool f3() { return f1() >! f2(); }

请尝试一下；-)。