C++ 嵌套 Lambda

Question

我正在使用嵌套的 lambda 表达式实现数据聚合器。我对 lambda 函数还不是很熟悉，我也不能 100% 确定我的实现想法是否可以实现。

问题：我有一个 Multivalue 类，它有一个向量作为私有成员。这个私有向量的数据类型可以通过 Multivalue 类的模板参数来定义。我想为向量中的数据提供不同的聚合函数（总和、调和平均值、平均值……）。但是：如果向量数据类型是元组，则聚合函数也应该可用于元组的组件。以下链接显示了我的第一次尝试，但还没有工作。我希望有人可以向我解释问题所在。我认为嵌套的 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);
}

函数initSubAggregators中的lamdba捕获函数参数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。 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; }) { }