Angenommen, wir haben den folgenden (unsinnigen) Code:

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

Variable 'a' ist gleich Null, so dass der Compiler auf die Kompilierzeit schließen kann, dass die Anweisung 'if (a) c ++;' wird nie ausgeführt und wird es weg optimieren.

Meine Frage: Passiert das auch mit Lambda-Verschlüssen?

Check out ein anderes Stück Code:

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;
}

Weiß der Compiler, dass 'a' 0 ist und optimiert es das Lambda?

Sogar anspruchsvolleres Beispiel:

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);

Wird der Compiler klug genug sein, um das erste Lambda zu optimieren, wenn er weiß, dass 'a' zum Zeitpunkt der Generierung 0 ist?

Hat gcc oder llvm diese Art von Optimierungen?

Ich frage, weil ich mich frage, ob ich solche Optimierungen manuell vornehmen soll, wenn ich weiß, dass bestimmte Annahmen zur Lambda-Generierungszeit erfüllt sind, oder der Compiler dies für mich tun wird.