C++ 如何简化或提高复杂逻辑语句的可读性？

所以我有一个逻辑陈述的怪物：

(((ncode[i]+key[ikey])>90 && (ncode[i]+key[ikey])<97) || (ncode[i] + key[ikey])>122)

（（ncode[i]+key[ikey]）>90&（ncode[i]+key[ikey]）122）

---

我总是被告知，如果你有需要换行的逻辑语句，你可能做错了什么。我知道我可能会把它重构成一个新的方法，但对于我正在做的事情来说，这样做不一定有意义。我该怎么做才能使它更具可读性呢？

我只需要使用一个临时变量来清除t提示：

auto code = ncode[i] + key[ikey];
if ( (code > 90 && code < 97) || (code > 122) )

auto code=ncode[i]+键[ikey]；
如果（（代码>90&&code<97）| |（代码>122））

---

大多数编译器无论如何都会优化临时变量。

我只需使用临时变量来清理：

auto code = ncode[i] + key[ikey];
if ( (code > 90 && code < 97) || (code > 122) )

auto code=ncode[i]+键[ikey]；
如果（（代码>90&&code<97）| |（代码>122））

---

大多数编译器无论如何都会优化临时值。

假设

ncode

和

key

中的值都是整数（或浮点数），您不能将它们的求和值分配给新变量吗？将行转换为：

int result = ncode[i] + key[iKey];
if( (result > 90 && result < 97) || result > 122)
    //Logic

int result=ncode[i]+键[iKey]；
如果（（结果>90&&result<97）| |结果>122）
//逻辑

---

它变成了两行，但在我看来确实增加了可读性。

假设

ncode

和

key

中的值都是整数（或浮点数），您能不能将它们的求和值分配给一个新变量？将该行转换为：

int result = ncode[i] + key[iKey];
if( (result > 90 && result < 97) || result > 122)
    //Logic

int result=ncode[i]+键[iKey]；
如果（（结果>90&&result<97）| |结果>122）
//逻辑

---

它变成了两行，但在我看来确实增加了可读性。

为了性能和可读性，我会使用一个const temp变量来替换三个重复的

（ncode[I]+key[ikey]）

。不要重复你自己

const auto temp = ncode[i] + key[ikey];
if ( ((90<temp) && (temp<97)) || (122<temp) )

const auto temp=ncode[i]+键[ikey]；
如果（（90I将使用const temp变量替换三个重复的
（ncode[I]+key[ikey]）
，以提高性能和可读性。不要重复

const auto temp = ncode[i] + key[ikey];
if ( ((90<temp) && (temp<97)) || (122<temp) )

const auto temp=ncode[i]+键[ikey]；
如果（（90
如果我们将谓词定义为一个返回
bool
的函数对象，该函数对象支持
&&
和
|
和
~
重载，并使用上面的toys返回谓词，我们得到：

if (( between(90,97) || is_gt(122))(ncode[i]+key[ikey])) {

消除
前缀噪声

要在非
int
情况下提高效率，请通过移动捕获边界

template<class F>
struct predicate_t:F{
  predicate_t(F const& f):F(f){}
  template<class F2>
  friend auto operator&&(predicate const& f1,predicate<F2> const& f2){
    auto r=[=](auto&&...args){
      return f1(args...)&&f2(args...);
    };
    return predicate_t<decltype(r)>(r);
  }
  template<class F2>
  friend auto operator||(predicate const& f1,predicate<F2> const& f2){
    auto r=[=](auto&&...args){
      return f1(args...)||f2(args...);
    };
    return predicate_t<decltype(r)>(r);
  }

  template<class F2>
  friend auto operator!(predicate const& f1){
    auto r=[=](auto&&...args){
      return !f1(args...);
    };
    return predicate_t<decltype(r)>(r);
  }
};
template<class F>
predicate_t<std::decay_t<F>>
predicate(F&&f){
  return std::forward<F>(f);
}

模板
结构谓词\u t:F{
谓词_t（F const&F）：F（F）{}
模板
友元自动运算符&（谓词常量&f1，谓词常量&f2）{
自动r=[=]（自动和…参数）{
返回f1（参数…）和f2（参数…）；
};
返回谓词_t（r）；
}
模板
友元自动运算符| |（谓词常量&f1，谓词常量&f2）{
自动r=[=]（自动和…参数）{
返回f1（args…）| f2（args；
};
返回谓词_t（r）；
}
模板
友元自动运算符！（谓词常量和f1）{
自动r=[=]（自动和…参数）{
return！f1（args…）；
};
返回谓词_t（r）；
}
};
模板
谓词
谓词（F&&F）{
返回std：：向前（f）；
}

使用上述每个
toy
函数返回
返回谓词（lambda）；
而不是lambda

此代码在使用时更简单、更简短，应该具有零运行时间开销，但与传统C++相比，代码风格不同。
如果我们将谓词定义为一个返回
bool
的函数对象，该函数对象支持
&&
和
|
和
~
重载，并使用上面的toys返回谓词，我们得到：

if (( between(90,97) || is_gt(122))(ncode[i]+key[ikey])) {

消除
前缀噪声

要在非
int
情况下提高效率，请通过移动捕获边界

template<class F>
struct predicate_t:F{
  predicate_t(F const& f):F(f){}
  template<class F2>
  friend auto operator&&(predicate const& f1,predicate<F2> const& f2){
    auto r=[=](auto&&...args){
      return f1(args...)&&f2(args...);
    };
    return predicate_t<decltype(r)>(r);
  }
  template<class F2>
  friend auto operator||(predicate const& f1,predicate<F2> const& f2){
    auto r=[=](auto&&...args){
      return f1(args...)||f2(args...);
    };
    return predicate_t<decltype(r)>(r);
  }

  template<class F2>
  friend auto operator!(predicate const& f1){
    auto r=[=](auto&&...args){
      return !f1(args...);
    };
    return predicate_t<decltype(r)>(r);
  }
};
template<class F>
predicate_t<std::decay_t<F>>
predicate(F&&f){
  return std::forward<F>(f);
}

模板
结构谓词\u t:F{
谓词_t（F const&F）：F（F）{}
模板
友元自动运算符&（谓词常量&f1，谓词常量&f2）{
自动r=[=]（自动和…参数）{
返回f1（参数…）和f2（参数…）；
};
返回谓词_t（r）；
}
模板
友元自动运算符| |（谓词常量&f1，谓词常量&f2）{
自动r=[=]（自动和…参数）{
返回f1（args…）| f2（args；
};
返回谓词_t（r）；
}
模板
友元自动运算符！（谓词常量和f1）{
自动r=[=]（自动和…参数）{
return！f1（args…）；
};
返回谓词_t（r）；
}
};
模板
谓词
谓词（F&&F）{
返回std：：向前（f）；
}

使用上述每个
toy
函数返回
返回谓词（lambda）；
而不是lambda

此代码在使用时更简单、更简短，应该具有零运行时开销，但与传统C++相比，代码风格不同。
可读谁？你？我？教皇？一行，两行，三行，无聊？你喜欢80列，我喜欢100列。你喜欢短名字，我喜欢描述性名称。你更喜欢QuiChe和我会拿走自动售货机里的任何东西。总是写代码，好像维护者是一个知道你住在哪里的精神病患者：-为谁准备的？你？我？教皇？一行，两行，三行，无聊？你喜欢80列，我喜欢100列。你喜欢很短的名字我喜欢描述性的名字。你喜欢蛋饼，我会拿走里面的任何东西e自动售货机。总是像维护者是一个知道你住在哪里的精神病患者一样编写代码：-PYeah，现在你刚刚污染了范围和一个不必要的变量。这与其他良好做法相矛盾。这是好是坏？这有关系吗？为什么不干脆用Gump和我们ea
for
语句。
（for（auto code=1；code>90&&code<97 | | code>122；）{}
为什么不
{…code…}
？我不认为创建不必要的变量是一件坏事，如果它使代码更易于阅读/维护。污染可以通过
{}/code>块来处理，如果