Is it valid to use break in repetitive control structures?

It is perfectly valid; that's your mission, to get out of the current code block; more specifically, its use is limited to blocks:

• switch
• do
• while
• for

It is not valid to exit blocks if(that are not contained in any of the previous blocks):

if( x ) {
  if( x == 5 ) break; // INCORRECTO.

Nor for anonymous scopes (equally not contained in any of the valid blocks) :

{
  int z = 2;
  break; // INCORRECTO.

It also does n't allow exiting nested blocks :

while( x ) {
  while( y ) {
    if( y == 5 )
      break;
  }
  // el break nos manda aquí; solo el bloque interior.
}

In that example, break exit the innermost block ; i.e. it only works for the block it is included in .

From what I've read, breakthere's nothing wrong with using for some.

Using breakis just as bad as using any other C++ utility: nothing bad. The evil is not in the utility used but in the use that is given to it. As you have pointed out, it is often used to alter the natural flow of a loop, for example by iterating through a collection until a specific element is found:

int indice = 0;
for (const int final = principes.size(); indice != final; ++indice)
{
    // Eres tu mi principe azul que yo sonye?
    if (es_azul(principes[indice])
        break;
}

There is nothing wrong with the previous code: it goes through a collection of objects ( principes) to which it performs a test ( es_azul) and at the end of the loop the variable indicecontains the index of the first object that meets said condition or principes.size()if there is none; the above code is almost equivalent to this:

int indice = 0;
bool encontrado = false;
for (const int final = principes.size(); !encontrado && (indice != final); ++indice)
{
    // Eres tu mi principe azul que yo sonye?
    encontrado = es_azul(principes[indice]);
}

There can be heated debates about which of the two versions is better, but in general, these discussions will not focus on the use of breakbut on number of instructions (the loop Ejemplo2takes one more turn) or clarity ( Ejemplo1it can be more difficult to understand). .

Whatever the case, you will hardly see Ejemplo1it Ejemplo2in modern C++, since it is usual to delegate this type of operations to the header <algorithm>:

auto azul = std::find_if(principes.begin(), principes.end(),
            [](const auto &principe){ return es_azul(principe); });
bool encontrado = (azul != principes.end());

Each compiler will implement it std::find_ifin <algorithm>its own way but in general the implementation might look like:

template<class InputIt, class UnaryPredicate>
InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (p(*first)) {
            return first;
        }
    }
    return last;
}

The instruction return first;inside the loop works in a similar way to the breakones you put in your example: they alter the natural flow of the loop and as you can see it is used in standard library code, nothing to object to, right?

I'm going to be the dissonant voice: although break(and continue, another operation that often falls into the same bag as break) is technically valid and can be used to break out of conditional/iterative structures, if it can be avoided, it shouldn't be used for that in programming high level (with some exceptions). Key part: " if it can be avoided ".

It's not as bad (or should I say harmful ?) as gotobecause you know exactly where you're going to go when you do a break(at the end of the block that contains it), but with it you're breaking the normal flow of the structure which isn't either. is ideal, makes the code less readable (although this is debatable), and can lead to unexpected results.

For example, if you are reviewing the following code and you get to the header of for, you would expect that when the loop ends, the value of xis greater than or equal to 100. Which is not going to happen because N lines below there is a break:

for (x = 0; x < 100; x++) {
  ...
  i = funcion1(x);
  j = funcion2();
  k = i + j + x;
  ...
  if (k >= 25) break;
}

The real problem comes because people do not use them well and abuse them. For example, in the case above where there is a breakinside a loop for, what really happens is that the correct structure has not been selected: breakrefactoring the code to a loop whileor a could be avoided do...while:

do {
  ...
  i = funcion1(x);
  j = funcion2();
  k = i + j + x;
  ...
  x++;
} while (x < 100 && k < 25);

Another problem with break, as Trauma indicates , arises if you have two nested iterative structures where only the inner one is to be exited, but what if we wanted to exit both? Shall we do a second break? Shall we check again? In that case, perhaps it would be better to use a sentinel variable, eg.

In short: as long breakas they continueare technically valid (and in some cases even necessary) and can work perfectly well in clean and tidy code... but that is not always the case, and their use (or abuse) can lead to problems and bad practices.