Неопределенное поведение с замыканием C++0x: II

Я надеюсь выяснить, почему в коде есть неопределенное поведение

Каждый раз, когда я имею дело со сложными и запутанными лямбда-выражениями, мне кажется, что проще сначала выполнить перевод в форму объекта-функции. Потому что лямбды - это просто синтаксический сахар для объекта-функции, и для каждой лямбды существует однозначное сопоставление с соответствующим объектом-функцией. В этой статье очень хорошо объясняется, как сделать перевод: http://blogs.msdn.com/b/vcblog/archive/2008/10/28/lambdas-auto-and-static-assert-c-0x-features-in-vc10-part-1.aspx

Так, например, ваша программа № 2:

#include <iostream>
int main(){
    auto accumulator = [](int x) {
        return [&](int y) -> int { 
            return x+=y;
        }; 
    };
    auto ac=accumulator(1);
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
}

будет приблизительно переведено компилятором в это:

#include <iostream>

struct InnerAccumulator
{
    int& x;
    InnerAccumulator(int& x):x(x)
    {
    }
    int operator()(int y) const
    {
        return x+=y;
    }
};

struct Accumulator
{
    InnerAccumulator operator()(int x) const
    {
        return InnerAccumulator(x); // constructor
    }
};


int main()
{
    Accumulator accumulator;
    InnerAccumulator ac = accumulator(1);
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
}

И теперь проблема стала совершенно очевидной:

InnerAccumulator operator()(int x) const
{
   return InnerAccumulator(x); // constructor
}

Здесь конструктор InnerAccumulator возьмет ссылку на x, локальную переменную, которая исчезнет, ​​как только вы выйдете из области действия operator(). Так что да, вы просто получаете простое старое доброе неопределенное поведение, как вы и подозревали.

Давайте попробуем что-нибудь совершенно невинное:

#include <iostream>
int main(){
    auto accumulator = [](int x) {
        return [&](int y) -> int { 
            return x+=y;
        }; 
    };
    auto ac=accumulator(1);

    //// Surely this should be a no-op? 
    accumulator(666);
    //// There are no side effects and we throw the result away!

    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
    std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl; 
}

Тада:

669 668 667 
672 671 670 
675 674 673 

Конечно, это тоже не гарантированное поведение. Действительно, с включенной оптимизацией gcc устранит вызов accumulator(666), определяющий его мертвый код, и мы снова получим исходные результаты. И это полностью в его праве сделать это; в соответствующей программе удаление вызова действительно не повлияет на семантику. Но в области неопределенного поведения может произойти все.

РЕДАКТИРОВАТЬ

auto ac=accumulator(1);

std::cout << pow(2,2) << std::endl;

std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl;
std::cout << ac(1) << " " << ac(1) << " " << ac(1) << " " << std::endl; 

Без включенных оптимизаций я получаю следующее:

4
1074790403 1074790402 1074790401 
1074790406 1074790405 1074790404 
1074790409 1074790408 1074790407 

С включенными оптимизациями,

4
4 3 2 
7 6 5 
10 9 8

Опять же, C++ не обеспечивает и не может обеспечить истинные лексические замыкания, в которых время жизни локальных переменных выходит за пределы их исходной области видимости. Это повлечет за собой внедрение в язык сборки мусора и локальных переменных из кучи.

Однако все это довольно академично, поскольку захват x путем копирования делает программу четко определенной и работает так, как ожидалось:

auto accumulator = [](int x) {
    return [x](int y) mutable -> int { 
        return x += y;
    }; 
};

Ну, ссылки становятся висящими, когда референт уходит. У вас очень хрупкий дизайн, если объект A имеет ссылку на какую-то часть объекта B, если только объект A каким-то образом не может гарантировать время жизни объекта B (например, когда A все равно содержит shared_ptr для B, или оба находятся в тот же объем).

Ссылки в лямбда-выражениях не являются волшебным исключением. Если вы планируете вернуть ссылку на x+=y, вам лучше убедиться, что x живет достаточно долго. Здесь аргумент int x инициализируется как часть вызова accumulator(1). Время жизни аргумента функции заканчивается, когда функция возвращается.