Para bucle dentro de sus propias llaves

Me he encontrado con este diseño de bucle for:

#include <iostream>
int main()
{
    {
        for (int i = 0; i != 10; ++i)
        {
            std::cout << "delete i->second;" << std::endl;
        }
    }

    {
        for (size_t i = 0; i < 20; ++i)
        {
            std::cout << "delete m_indices[i];" << std::endl;
        }
    }
    return 0;
}

Me preguntaba para qué es esta capa adicional de aparatos ortopédicos. Esto aparece varias veces en nuestra base de código.

Érase una vez, hace muchas lunas, VS6 existía y era popular. Sin embargo, falló en ajustarse a varios estándares de C ++; lo cual era razonable en ese momento, ya que fue lanzado justo antes (el mismo año) que el estándar fue lanzado oficialmente; sin embargo, se adhirió al borrador de la norma que yo sepa.

Uno de los estándares que cambió entre el borrador y el estándar oficial fue la vida útil de las variables del ciclo for creadas en la primera sección; lo que provoca que el siguiente código no se compile

{
    for (int i=0; i<1; ++i){}
    for (int i=0; i<2; ++i){}
}

porque ifue redefinido por el segundo bucle for.

Mientras que otros compiladores también sufrieron este error; Destaco el VS6 porque siguió siendo la única versión de Visual Studio durante varios años después del lanzamiento del estándar, pero nunca lanzó una actualización para este problema en particular; lo que significa que tuvo un impacto más significativo.

Una solución a esto es forzar todo el bucle for a su propio alcance, como ha mostrado.

{y }creará un alcance y si define algunas variables en el alcance, no podrá acceder a ellas desde fuera. Pero forya crea ese alcance. Entonces

{for(int i = 0; i < count; ++i){}} 

es lo mismo que

for(int i = 0; i < count; ++i){}

pero si defines algo entre ellos, hay una diferencia

{int a = 0; for(int i = 0; i < count; ++i){}}

En este ejemplo, ano será accesible desde fuera del alcance.

En su ejemplo particular, no hay razón para ellos.

A veces, es posible que desee crear un alcance para una variable:

float average;
// ...

{
int sum = 0;
for (int i = 0; i < count; ++i)
{
   sum += v[i];
}
average = (float)sum / count;
}

// use average
// sum not in scope here

Sin embargo, veo esto como un anti-patrón. Por lo general, si necesita hacer esto, lo más probable es forque sea su propia función.

Es un alcance de bloque marcado por {}llaves. Suele utilizarse para marcar la zona de almacenamiento automático . En su caso, no parece hacer nada, ya que el bucle for tiene su propio alcance en C ++ estándar.