Supongamos que tenemos el siguiente código (sin sentido):

const int a = 0;
int c = 0;
for(int b = 0; b < 10000000; b++)
{
    if(a) c++;
    c += 7;
}

La variable 'a' es igual a cero, por lo que el compilador puede deducir en tiempo de compilación que la instrucción 'if (a) c ++;' nunca se ejecutará y lo optimizará.

Mi pregunta:¿Sucede lo mismo con los cierres lambda?

Mira otra pieza de código:

const int a = 0;
function<int()> lambda = [a]()
{
    int c = 0;
    for(int b = 0; b < 10000000; b++)
    {
        if(a) c++;
        c += 7;
    }
    return c;
}

¿Sabrá el compilador que 'a' es 0 y optimizará la lambda?

Ejemplo aún más sofisticado:

function<int()> generate_lambda(const int a)
{
    return [a]()
    {
        int c = 0;
        for(int b = 0; b < 10000000; b++)
        {
            if(a) c++;
            c += 7;
        }
        return c;
    };
}

function<int()> a_is_zero = generate_lambda(0);
function<int()> a_is_one = generate_lambda(1);

¿El compilador será lo suficientemente inteligente como para optimizar la primera lambda cuando sepa que 'a' es 0 en el momento de la generación?

¿Tiene gcc o llvm este tipo de optimizaciones?

Lo pregunto porque me pregunto si debería hacer tales optimizaciones manualmente cuando sé que ciertas suposiciones se cumplen en el tiempo de generación lambda o el compilador lo hará por mí.