Suponha que tenhamos o seguinte código (sem sentido):

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

A variável 'a' é igual a zero; portanto, o compilador pode deduzir no tempo de compilação que a instrução 'if (a) c ++;' nunca será executado e o otimizará.

Minha pergunta:O mesmo acontece com os fechamentos lambda?

Confira outro trecho 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;
}

O compilador saberá que 'a' é 0 e otimizará o lambda?

Exemplo ainda mais 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);

O compilador será inteligente o suficiente para otimizar o primeiro lambda quando souber que 'a' é 0 no momento da geração?

O gcc ou llvm tem esse tipo de otimização?

Estou perguntando, porque me pergunto se devo fazer essas otimizações manualmente quando sei que certas suposições são satisfeitas no tempo de geração lambda ou o compilador fará isso por mim.