C++ 嵌套 Lambda

Question

我正在研究一个带有嵌套 lambda 表达式的数据聚合器实现。我对 lambda 函数还不是很熟悉，我不能 100% 确定我的实现想法是否可实现。

问题:我有一个多值 类，它有一个 vector 作为私有(private)成员。这个私有(private) vector 的数据类型可以通过 Multivalue 类的模板参数来定义。我想为 vector 中的数据提供不同的聚合函数(总和、调和平均值、平均值……)。但是:如果 vector 数据类型是元组，则聚合函数也应该可用于元组的组件。以下链接显示了我的第一次尝试，但还没有成功。我希望有人可以向我解释问题是什么。我认为嵌套的 lambda 表达式有问题，我使用:

http://goo.gl/w7MUAi

#include <iostream>
#include <vector>
#include <functional>
#include <tuple>

using namespace std;

template<typename ... TTypes>
std::ostream& operator<<(std::ostream& out, const std::tuple<TTypes...>& value) { return out; }

/** our general abstract aggregation object */
template<typename T, typename C>
class AbstractAggregator {
public: 
    AbstractAggregator() { }
    AbstractAggregator(const std::vector<C> *data, std::function<const T&(const C&)> access) :
    data(data), access(access) { }

    T sum() const {
        T sum;
        for (auto &i : *data)
            sum += access(i);
        return sum;
    }
protected:
    const std::vector<C> *data;
    std::function<const T&(const C&)> access;
};

/** concrete aggregation implementation for types like int, float, double .. */
template<typename T, typename C>
class Aggregator : public AbstractAggregator<T, C> {
public:
    Aggregator() { }
    Aggregator(const std::vector<C> *data, std::function<const T&(const C&)> access) : AbstractAggregator<T, C>(data, access) { }    
};

/** aggregator implementation for tuple (with subaggregators for each component */
template<typename ... TTypes, typename C>
class Aggregator<std::tuple<TTypes...>, C> : public AbstractAggregator<std::tuple<TTypes...>, C> {
public:
    Aggregator() { }
    Aggregator(const std::vector<C> *data, std::function<const std::tuple<TTypes...>&(const C&)> access) : AbstractAggregator<std::tuple<TTypes...>, C>(data, access) { 
    initSubAggregators<sizeof...(TTypes), TTypes...>(access); 
}

    std::tuple<Aggregator<TTypes, C>...> subaggregators;
private:
    template<int N>
    void initSubAggregators(std::function<const std::tuple<TTypes...>&(const C&)> access) { }
    template<int N, typename THead, typename... TTail>
    void initSubAggregators(std::function<const std::tuple<TTypes...>&(const C&)> access) { 
        constexpr int I = N - sizeof...(TTail) - 1;
        std::get<I>(subaggregators) = Aggregator<THead, C>(AbstractAggregator<std::tuple<TTypes...>, C>::data, [&](const C &value) { return std::get<I>(access(value)); });        
        initSubAggregators<N, TTail...>(access);
    }
};

namespace std {
    template<size_t I, typename ... TTypes, typename C>
    auto get(Aggregator<std::tuple<TTypes...>, C>& k) -> decltype(std::get<I>(k.subaggregators)) {
        return std::get<I>(k.subaggregators);
    }

    template<size_t I, typename ... TTypes, typename C>
    auto get(const Aggregator<std::tuple<TTypes...>, C>& k) -> decltype(std::get<I>(k.subaggregators)) {
        return std::get<I>(k.subaggregators);
    }
}

/** multivalue attribute implementation (inherits corresponding aggregation object) */
template<typename T>
class Multivalue : public Aggregator<T, T> {
public:
    Multivalue() : Aggregator<T, T>(&data, [](const T &value) { return value; }) { }
    void append(const T& item) { data.push_back(item); }
private:
    std::vector<T> data;
};

int main() {
    Multivalue<std::tuple<std::tuple<uint32_t, uint32_t>, float, double>> mv;
    mv.append(std::make_tuple(std::make_tuple(13, 12), 2.5, 3.5));
    mv.append(std::make_tuple(std::make_tuple(1, 7), 2.55123, 1.5));
    mv.append(std::make_tuple(std::make_tuple(5, 3), 2.312, 1.8));

    auto &a1 = std::get<2>(mv);
    auto &a2 = std::get<1>(mv);
    auto &a3 = std::get<0>(std::get<0>(mv));
    auto &a4 = std::get<1>(std::get<0>(mv));

    std::cout << "Sum 1: " << a1.sum() << std::endl;
    std::cout << "Sum 2: " << a2.sum() << std::endl;
    std::cout << "Sum 3: " << a3.sum() << std::endl;
    std::cout << "Sum 4: " << a4.sum() << std::endl;

    return 0;
}

哞哞

Answer 1

您的代码中至少存在三个问题。

---

第一个已被vsoftco指出，在现已删除的答案中:

在求和函数中，您正在读取未初始化的变量。

T sum() const {
    T sum; // uninitialized
    for (auto &i : *data)
    {
        std::cout << "summing from: " << i << "\n";
        sum += access(i);
    }
    return sum;
}

更准确地说，变量 sum默认初始化，但对于非类类型，这意味着根本没有初始化。

一个简单的解决方案是值初始化 sum :

T sum{}; // value-initialized

---

第二个问题是捕获实体的生命周期问题:

template<int N, typename THead, typename... TTail>
void initSubAggregators(std::function<const std::tuple<TTypes...>&(const C&)> access) { 
    constexpr int I = N - sizeof...(TTail) - 1;
    std::get<I>(subaggregators) = Aggregator<THead, C>(AbstractAggregator<std::tuple<TTypes...>, C>::data, [&](const C &value) { return std::get<I>(access(value)); });        
    initSubAggregators<N, TTail...>(access);
}

因为我觉得这很难读，让我们介绍一些 typedef 和其他简化:

using R = std::tuple<TTypes...> const&;
using P = C const&;
using F = std::function<R(P)>;

template<int N, typename THead, typename... TTail>
void initSubAggregators(F access) {
    constexpr int I = N - sizeof...(TTail) - 1;
    auto l = [&](C const& value) { return std::get<I>(access(value)); };
    std::get<I>(subaggregators) = Aggregator<THead, C>(this->data, l);
    initSubAggregators<N, TTail...>(access);
}

函数中的lamdba initSubAggregators捕获函数参数 access 引用。函数参数是一个在函数结束时超出范围并随后被销毁的对象。然而，lambda 存储在 std::function 中。在子聚合器内部并且超出了 initSubAggregators 的范围.因为它捕获了access通过引用，它将在 initSubAggregators 之后存储一个悬挂引用返回。一种可能的解决方案是存储 access按值(为每个子聚合器创建一个拷贝)。另一种解决方案是存储 access在元组聚合器中作为数据成员，并在每个 lambda 中存储对该数据成员的引用。

---

第三个问题也与对象的生命周期有关。

在 Multivalue 的构造函数中创建的 lambda并传递给聚合器按值返回由于正常的返回类型推导:

Multivalue() : Aggregator<T, T>(&data, [](const T &value) { return value; }) { }

Aggregator<T, T> 的构造函数但是需要一个通过 const-reference 返回的函数对象:

Aggregator(const std::vector<C> *data, std::function<const T&(const C&)> access)

当 std::function对象被调用时，它调用 lambda 对象。 lambda 返回 T按值(value)。 std::function然后通过引用返回该临时对象(返回值)，创建一个悬空引用。这与 What is the return type of a lambda expression if an item of a vector is returned? 中的问题相同可以通过手动定义返回类型来解决:

Multivalue() : Aggregator<T, T>(&data, [](const T &value) -> const T & { return value; }) { }