C ++嵌套Lambda

Question

我正在使用嵌套lambda表達式進行數據聚合器實現。 我對lambda函數的經驗還不是很豐富，並且我不確定100％是否可以實現我的實現想法。

問題：我有一個多值類，其中有一個向量作為私有成員。 可以通過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中的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值。 然后， std::function通過引用返回該臨時對象（返回值），從而創建一個懸空的引用。 如果返回向量項，則與lambda表達式的返回類型是什么相同？ 可以通過手動定義返回類型來解決：

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