C++0x 闭包的未定义行为：II

2024-01-23

我发现 C++0x 闭包的使用令人困惑。我的初始report https://stackoverflow.com/questions/5543169/how-to-make-a-vector-of-functors-lambdas-or-closures-in-cox/5556376#5556376，以及后续一个 https://stackoverflow.com/questions/5556183/make-c-crash-without-casting/5557843#5557843，产生的混乱多于解释。下面我将向您展示麻烦的示例，希望找出代码中存在未定义行为的原因。所有代码片段都通过了 gcc 4.6.0 编译器，没有任何警告。

方案 1：有效

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

输出结果满足预期：

2 2 2

2. 方案 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;
}

输出是：

4 3 2

7 6 5

10 9 8

程序 3：带有 std::function 的程序 1，工作正常

#include <iostream>
#include <functional>     // std::function

int main(){

    typedef std::function<int(int)> fint2int_type;
    typedef std::function<fint2int_type(int)> parent_lambda_type;

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

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

输出是：

2 2 2

程序 4：带有 std::function 的程序 2，未定义行为

#include <iostream>
#include <functional>     // std::function

int main(){

    typedef std::function<int(int)> fint2int_type;
    typedef std::function<fint2int_type(int)> parent_lambda_type;

    parent_lambda_type accumulator = [](int x) -> fint2int_type{
        return [&](int y) -> int { 
            return x+=y;
        }; 
    };

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

程序的第一次运行给出：

4 3 2

12364812 12364811 12364810

第二次运行同一程序：

4 3 2

1666060 1666059 1666058

第三个：

4 3 2

2182156 2182155 2182154

我对 std::function 的使用如何破坏代码？为什么程序 1 - 3 运行良好，而程序 4 在调用 ac(1) 三次（！）时正确？为什么程序 4 在接下来的三种情况下陷入困境，就好像变量 x 是通过值而不是引用捕获的一样。 ac(1) 的最后三个调用是完全不可预测的，就好像对 x 的任何引用都会丢失一样。

我希望找出为什么有代码中未定义的行为

每次处理复杂的 lambda 时，我都觉得首先将其转换为函数对象形式会更容易。因为 lambda 只是函数对象的语法糖，并且对于每个 lambda 都存在与相应函数对象的一对一映射。这篇文章很好地解释了如何进行翻译：http://blogs.msdn.com/b/vcblog/archive/2008/10/28/lambdas-auto-and-static-assert-c-0x-features-in-vc10-part-1.aspx 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() 作用域，它就会消失。所以是的，正如您所怀疑的那样，您只会得到一个简单的、良好的、未定义的行为。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)