Question

Python有一个有趣的for语句，允许您指定else子句。

在像这样的结构中：

for i in foo:
  if bar(i):
    break
else:
  baz()

else子句在for之后执行，但前提是for正常终止（而不是break）。

我想知道C ++中是否有相同的内容？我可以使用for ... else吗？

Answer 1

表达实际逻辑的一种更简单的方法是使用std::none_of：

if (std::none_of(std::begin(foo), std::end(foo), bar))
    baz();

如果接受C ++ 17的范围提议，希望这将简化为：

if (std::none_of(foo, bar)) baz();

Answer 2

如果不介意使用goto也可以通过以下方式完成。这可以节省额外的if检查和更高范围的变量声明。

for(int i = 0; i < foo; i++)
     if(bar(i))
         goto m_label;
baz();

m_label:
...

Answer 3

是的，你可以通过以下方式达到同样的效果：

auto it = std::begin(foo);
for (; it != std::end(foo); ++it)
     if(bar(*it))
         break;
if(it == std::end(foo))
    baz();

Answer 4

这是我在C ++中的粗略实现：

bool other = true;
for (int i = 0; i > foo; i++) {
     if (bar[i] == 7) {
          other = false;
          break;
     }
} if(other)
     baz();

Answer 5

您可以使用lambda函数：

[&](){
  for (auto i : foo) {
    if (bar(i)) {
      // early return, to skip the "else:" section.
      return;
    }
  }
  // foo is exhausted, with no item satisfying bar(). i.e., "else:"
  baz();
}();

这应该与Python的“for..else”完全相同，并且与其他解决方案相比具有一些优势：

它是“for..else”的真正替代品：“for”部分可能有副作用（与none_of不同，其谓词不得修改其参数），并且它可以访问外部作用域。 / LI>
它比定义特殊宏更具可读性。
它不需要任何特殊的标志变量。

但是......我会使用clunky flag变量，我自己。

Answer 6

我不知道在C / C ++中实现这一点的优雅方法（不涉及标志变量）。建议的其他选择比那更可怕......

要回答@Kerrek SB关于现实生活中的用法，我在代码中找到了一些（简化片段）

示例1：典型的查找/失败

for item in elements:
    if condition(item):
        do_stuff(item)
        break
else: #for else
    raise Exception("No valid item in elements")

示例2：尝试次数有限

for retrynum in range(max_retries):
    try:
        attempt_operation()
    except SomeException:
        continue
    else:
        break
else: #for else
    raise Exception("Operation failed {} times".format(max_retries))

Answer 7

类似的东西：

auto it = foo.begin(), end = foo.end();
while ( it != end && ! bar( *it ) ) {
    ++ it;
}
if ( it != foo.end() ) {
    baz();
}

应该做的伎俩，它避免了非结构化break。

Answer 8

它不仅可以在C ++中实现，而且在C语言中是可能的。我会坚持使用C ++来使代码易于理解：

for (i=foo.first(); i != NULL || (baz(),0); i = i.next())
{
    if bar(i):
        break;
}

我怀疑我是否通过代码审查来实现这一点，但它有效并且效率很高。在我看来，它比其他一些建议更清晰。

Answer 9

在C ++中没有这样的语言构造，但是，由于预处理器的“魔力”，你可以为自己制作一个。例如，像这样的东西（C ++ 11）：

#include <vector>
#include <iostream>
using namespace std;

#define FOR_EACH(e, c, b) auto e = c.begin(); for (; e != c.end(); ++e) {b} if (e == c.end()) {}

int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);

    FOR_EACH(x, v, {
        if (*x == 2) {
            break;
        }        
        cout << "x = " << *x << " ";
    })
    else {
        cout << "else";
    }

    return 0;
}

这应输出x = 1 else。

如果您将if (*x == 2) {更改为if (*x == 3) {，则输出应为x = 1 x = 2。

如果您不喜欢在当前范围中添加变量这一事实，您可以稍微更改一下：

#define FOR_EACH(e, c, b, otherwise) {auto e = c.begin(); for (; e != c.end(); ++e) {b} if (e == c.end()) {} otherwise }

然后使用将是：

FOR_EACH(x, v, {
    if (*x == 2) {
        break;
    }        
    cout << "x = " << *x << " ";
},
else {
    cout << "else";
})

当然，这并不完美，但是，如果小心使用，将节省一些打字量，如果大量使用，将成为项目“词汇”的一部分。

Answer 10

可能没有一种解决方案可以满足所有问题。在我的例子中，一个标志变量和一个带有for说明符的基于范围的auto循环效果最好。这是相关代码的等效内容：

bool none = true;
for (auto i : foo) {
  if (bar(i)) {
    none = false;
    break;
  }
}
if (none) baz();

输入的次数少于using iterators。特别是，如果使用for循环初始化变量，则可以使用它而不是布尔标志。

感谢auto输入，如果您想内联条件而不是调用bar()（如果您不使用C ++ 14），则优于std::none_of。< / p>

我遇到两种情况都发生的情况，代码看起来像这样：

for (auto l1 : leaves) {
  for (auto x : vertices) {
    int l2 = -1, y;
    for (auto e : support_edges[x]) {
      if (e.first != l1 && e.second != l1 && e.second != x) {
        std::tie(l2, y) = e;
        break;
      }
    }
    if (l2 == -1) continue;

    // Do stuff using vertices l1, l2, x and y
  }
}

此处不需要迭代器，因为v表示是否发生break。

使用std::none_of需要在lambda表达式的参数中明确指定support_edges[x]元素的类型。

Answer 11

直接回答：不，你可能不能，或者它基于编译器，充其量。但是，这是一个宏的黑客行为！

一些注意事项：

我通常使用Qt编程，所以我习惯使用foreach循环，而不必直接处理迭代器。

我用Qt的编译器（v 5.4.2）对此进行了测试，但它应该可行。这有几个原因，但通常做你想要的。我不宽恕这样的编码，但只要你小心语法，它就没有理由不起作用。

#include <iostream>
#include <vector>

#define for_else(x, y) __broke__ = false; for(x){y} if (__broke__) {}
#define __break__ __broke__ = true; break

bool __broke__;  // A global... wah wah.

class Bacon {
  public:
    Bacon(bool eggs);

    inline bool Eggs() {return eggs_;}

  private:
    bool eggs_;
};

Bacon::Bacon(bool eggs) {
  eggs_ = eggs;
}

bool bar(Bacon *bacon) {
  return bacon->Eggs();
}

void baz() {
  std::cout << "called baz\n";
}

int main()
{
  std::vector<Bacon *>bacons;

  bacons.push_back(new Bacon(false));
  bacons.push_back(new Bacon(false));
  bacons.push_back(new Bacon(false));

  for_else (uint i = 0; i < bacons.size(); i++,
      std::cout << bacons.at(i)->Eggs();
      if (bar(bacons.at(i))) {
        __break__;
      }
  ) else {
    baz();
  }

  bacons.push_back(new Bacon(true));
  bacons.push_back(new Bacon(false));

  for_else (uint i = 0; i < bacons.size(); i++,
      std::cout << bacons.at(i)->Eggs();
      if (bar(bacons.at(i))) {
        __break__;
      }
  ) else {
    baz();
  }

  return EXIT_SUCCESS;
}

Answer 12

通过定义两个宏，你可以在Python中使用for-else：

#define BREAK {CONTINUETOELSE = false; break;}
#define FORWITHELSE(x, y) {bool CONTINUETOELSE = true; x if(!CONTINUETOELSE){} y}

现在，您将for和else内的FORWITHELSE宏放在逗号之间，并使用BREAK代替break。这是一个例子：

FORWITHELSE(
    for(int i = 0; i < foo; i++){
        if(bar(i)){
            BREAK;
        }
    },
    else{
        baz();
    }
)

您需要记住两件事：在else之前加上逗号并使用BREAK代替break。

Answer 13

我来到这里是因为我在C语言中也有同样的问题。我想到的最好的东西是

bool notTerminated = true;
for (int i = 0; i < 50 || (notTerminated = false); i++)
    if (bar(i))
        break;
if (! notTerminated)
    baz();

说明：(notTerminated = false)是一个始终返回假值的赋值，它将永远不会影响条件，并且如果条件为true，则将对其进行评估。

Answer 14

我将使用一个简单的辅助变量来完成此操作：

sed -n '3,$p' test_all.csv

通过这种方式，您只需要在一个地方实现条件（在上面的示例#include <stdio.h> #include <stdbool.h> int main() { bool b; printf("Numbers which are multiples of 7:\n"); for (int i=8; b=(i<12); i++) { if (i%7==0) { printf("%d", i); break; } } if (!b) { printf("no numbers found\n"); } return 0; }中）。

有没有等同于＆＃34; for ... else＆＃34; C ++中的Python循环？

14 个答案: