C++ 我可以避免3级以上的缩进吗？

在工作中，我最近为一个根据已发布规范实现的类编写了一个小于运算符，该类具有许多属性，其中六个属性用于唯一标识该类的实例。（为了这个问题，我们将这些属性称为a-f。）此外，这六个属性有六种不同的类型。我将操作员定义为：

bool operator<(const Class& lhs, const Class& rhs)
{
    bool retval = (&lhs != &rhs);
    if (retval == true)
    {
        if (lhs.a == rhs.a)
        {
            if (lhs.b == rhs.b)
            {
                if (lhs.c == rhs.c)
                {
                    if (lhs.d == rhs.d)
                    {
                        if (lhs.e == rhs.e)
                        {
                            retval = (lhs.f < rhs.f);
                        } else {
                            retval = (lhs.e < rhs.e);
                        }
                    } else {
                        retval = (lhs.d < rhs.d);
                    }
                } else {
                    retval = (lhs.c < rhs.c);
                }
            } else {
                retval = (lhs.b < rhs.b);
            }
        } else {
            retval = (lhs.a < rhs.a);
        }
    }
    return retval;
}

---

bool操作符您可以这样编写这种词典比较：

if (lhs.a != rhs.a) return lhs.a < rhs.a;
if (lhs.b != rhs.b) return lhs.b < rhs.b;
if (lhs.c != rhs.c) return lhs.c < rhs.c;
if (lhs.d != rhs.d) return lhs.d < rhs.d;
if (lhs.e != rhs.e) return lhs.e < rhs.e;
return lhs.f < rhs.f;

bool result;
if (lhs.a != rhs.a) result = lhs.a < rhs.a;
else if (lhs.b != rhs.b) result = lhs.b < rhs.b;
else if (lhs.c != rhs.c) result = lhs.c < rhs.c;
else if (lhs.d != rhs.d) result = lhs.d < rhs.d;
else if (lhs.e != rhs.e) result = lhs.e < rhs.e;
else result = lhs.f < rhs.f;
return result;

if（lhs.a！=rhs.a）返回lhs.a

您可以使用以下方式的单个返回重新写入此内容：

if (lhs.a != rhs.a) return lhs.a < rhs.a;
if (lhs.b != rhs.b) return lhs.b < rhs.b;
if (lhs.c != rhs.c) return lhs.c < rhs.c;
if (lhs.d != rhs.d) return lhs.d < rhs.d;
if (lhs.e != rhs.e) return lhs.e < rhs.e;
return lhs.f < rhs.f;

bool result;
if (lhs.a != rhs.a) result = lhs.a < rhs.a;
else if (lhs.b != rhs.b) result = lhs.b < rhs.b;
else if (lhs.c != rhs.c) result = lhs.c < rhs.c;
else if (lhs.d != rhs.d) result = lhs.d < rhs.d;
else if (lhs.e != rhs.e) result = lhs.e < rhs.e;
else result = lhs.f < rhs.f;
return result;

bool结果；
如果（lhs.a！=rhs.a）结果=lhs.a
由于您只设置了
retval
一次，并在设置后返回它，因此您可以完全删除它并使用
return
。除了重新排序逻辑外，还可以如下所示：

bool operator<(const Class& lhs, const Class& rhs)
{
    if(&lhs == &rhs)
        return false;

    if (lhs.a != rhs.a)
        return (lhs.a < rhs.a);

    if (lhs.b != rhs.b)
        return (lhs.b < rhs.b);

    // And so on...
}

bool操作符您可以使用
std:：tie
进行词典比较：

bool operator<(const Class& lhs, const Class& r) {
  return std::tie(lhs.a, lhs.b, lhs.c, lhs.d, lhs.e) < std::tie(rhs.a, rhs.b, rhs.c, rhs.d, rhs.e);
} 

bool操作符
if（lhs.a！=rhs.a）retval=lhs.a
这是一个格式正确的嵌套三元语句。这也是执行语句的一行

bool operator<( const Class& lhs, const Class& rhs ) const {
    return   lhs.a != rhs.a ? lhs.a < rhs.a
           : lhs.b != rhs.b ? lhs.b < rhs.b
           : lhs.c != rhs.c ? lhs.c < rhs.c
           : lhs.d != rhs.d ? lhs.d < rhs.d
           : lhs.e != rhs.e ? lhs.e < rhs.e
           : lhs.f < rhs.f;
}

// The Above Is The Same As:
bool operator<( const class& lhs, const Class&rhs ) const {
    bool result;
    if (lhs.a != rhs.a) result = lhs.a < rhs.a;
    else if (lhs.b != rhs.b) result = lhs.b < rhs.b;
    else if (lhs.c != rhs.c) result = lhs.c < rhs.c;
    else if (lhs.d != rhs.d) result = lhs.d < rhs.d;
    else if (lhs.e != rhs.e) result = lhs.e < rhs.e;
    else result = lhs.f < rhs.f;
    return result;
}
// The Main Difference Is You Are Not Declaring A Stack Variable To The Compiler
// Nor Are You Using If Else Statements, This Is Handled Automatically By The Compiler
// And This Is Usually Done Within The Registers.

bool运算符当有如此多的属性并且它们属于这样一种模式时，它们很可能被实现为一个数组。那么嵌套的
if
s将是一个循环。我也不认为编码准则真的适用于这样的简单模式。它旨在避免循环和条件的复杂嵌套。不要考虑规则，想想规则的原因。@Barmar关于数组，好主意，但不幸的是属性都是不同类型的。我编辑了这个问题来说明这一点。该死，老兄！你的目标是什么？@DavidHeffernan嗯，我不同意。将添加的内容清楚地标记为编辑可以让读者知道它们是在原始帖子之后添加的。如果不是在编辑前发布的答案，我可能从未想过要包含这些信息。有时候，能够提出一个好问题是一个过程。这并不意味着这些答案是错误的或者看起来很愚蠢。例如，我认为Chris关于
std:：tie
的回答很棒。另一方面，如上所述，删除编辑也会删除关键的上下文信息，如果没有这些信息，读者可能会对选择特定答案的原因感到困惑。不幸的是，我还必须遵守只使用一条返回语句的编码标准。您需要更好的编码标准。只有一份回报声明是一个愚蠢的规则。@DavidHeffernan我同意，但工作支付账单，所以我遵循他们的规则。@Brian我希望你不介意我添加了一个变体，以满足帖子要求有一份回报声明的要求。“我同意，但工作支付账单，所以我遵循他们的规则。”那么，如果他们不执行3级缩进规则，就让代码保持原样吧。我以前从未使用过std:：tie，所以+1指出了它在这种情况下的用处。不幸的是，我只能使用C++98。@Lowtecheek我希望你可以使用boost。如果你不能使用boost，你的编译器可能会提供
std:：tr1:：tie
。你可以用C++98手工实现
std:：tie
。
goto
很奇怪。只要使用else if。OP的方法还检查lhs和rhs是否是不同的引用。此外，代码没有声明任何变量并不一定意味着它没有在堆栈上使用任何变量。编译器可能会分配一些内存位置供内部使用。这是真的，特别是在许多微控制器上，那里只有一个寄存器。@LưuVĩnhPhúc是的，我确实明白你的意思，我已经有一段时间没有搞乱asm了；但是，您并不是直接为返回值创建堆栈变量，而是使用寄存器返回lhs和rhs之间的比较；这只是在幕后完成的！我只是不要求编译器说，嘿，这是一个名为retval的bool类型变量，请在堆栈上为这种类型留出足够的内存！（…）（…继续）如果您理解三元运算符，并且能够识别它与If-else If-else子句之间的模式相似性，并且知道如何格式化它，那么我认为这是一个看起来更干净的代码。@Francis说局部变量将存在于堆栈上。一个好的编译器会放入寄存器。您的代码不可读。它仍然是堆栈变量，因为未使用堆。它是非常可读的返回类型是bool。当调用方调用函数时，它将测试每个条件，直到达到最终的true或false，然后返回结果bool状态。