Question

我正在构建一个机器学习库，试图从C ++的内置功能中获得最大的收益，特别是C ++ 11。我有各种类来执行输入的修改，称为Transformations。现在我想构建一个它们的管道，一个接一个地链接它们（最终在链的末尾有一个机器学习算法，如分类器或回归器）。

我认为具有可变参数模板参数的类是此用例的完美匹配。问题是我想在构造函数中同时接受rvalues和lvalues。

在rvalue的情况下我想移动它，并且在左值的情况下我想保留它的引用（虽然我仍然不是100％肯定这个，因为它可能是一个绑定到某个范围的引用，并且作为函数的结果返回管道会爆炸;但是对于这个库的purporses，这可能只是记录在案。）

这将是班级：

template <class... Ts>
class Pipeline {
};

template <class T, class... Ts>
class Pipeline<T, Ts...> {
public:
    Pipeline(T?? transformation, Ts ??... following) : Pipeline<Ts...>(following...), _transformation(???) {}
...
}

我不知道_transformation是否应该作为参考，是否在初始化列表中std::move以及类型T和{{1}应该是什么在构造函数中。

编辑：对于左值，它应该是非常量的，因为管道可以修改变换。

Answer 1

以下是您可以执行的操作的示例（请注意，下面的代码中T是转换，S管道）：

#include<tuple>
#include<iostream>

struct T {
    T(int i): v{i} { }
    T(const T &t) { v = t.v; std::cout << "cpy ctor" <<std::endl; }
    T(T &&t) { v = t.v; std::cout << "move ctor" <<std::endl; }
    void operator()(int i) { std::cout << "operator(): " << (v+i) << std::endl; }
    int v;
};

template<typename... T>
struct S {
    static constexpr std::size_t N = sizeof...(T);

    template<typename... U>
    S(U&&... args): tup{std::forward<U>(args)...} { }

    void operator()(int i) {
        unpack(i, std::make_index_sequence<N>{});
    }

private:
    template<std::size_t... I>
    void unpack(int i, std::index_sequence<I...>) {
        exec(i, std::get<I>(tup)...);
    }

    template<typename U, typename... O>
    void exec(int i, U &&u, O&&... o) {
        u(i);
        exec(i, o...);
    }

    void exec(int) { }

    std::tuple<T...> tup;
};

int main() {
    T t{40};
    S<T, T> s{t, T{0}};
    s(2);
}

基本思想是使用转发引用，这只能通过向构造函数提供自己的参数包来实现。

在上面的示例中，移动了右值引用并复制了左值引用。否则调用者将负责所引用对象的生命周期，并且它非常容易出错。如评论中所述，如果需要，可以提交std::ref 无论如何，你可以在构造函数中更改策略，因为你有实际的类型及其值。

为避免继承，我使用tuple打包转换以供以后使用。因此，只要调用operator()，它们的引用就会被删除我用一些sfinae来扩展S的构造函数，以检查参数pack（T和U）是否相同。为此，您可以使用std::is_same的通用版本（如果需要，请参阅here以获取可能的实施方案。）
显然这个例子是最小的。您可以在实际代码中使用多个转换，只需从类型S<T, T>切换到类型S<T1, T2, TAndSoOn>。

正如您通过执行上面的示例所看到的，在构造S时，可以正确调用复制和移动构造函数。 operator()解压缩元组并使用引用，因此在这种情况下您无需额外的副本。

Answer 2

我不确定这是否符合您的要求

#include "iostream"
#include "string"

template <class... Ts>
class Pipeline {
};

template <class T, class... Ts>
class Pipeline<T&&, Ts...>: Pipeline<Ts...> {
    T _transformation;
public:
    Pipeline(T&& transformation, Ts... following) : Pipeline<Ts...>(std::forward<Ts>(following)...), _transformation(std::move(transformation)) {
        std::cout << "rvalue " << _transformation << " " << transformation << std::endl;
    }
};

template <class T, class... Ts>
class Pipeline<T&, Ts...>: Pipeline<Ts...> {
    T& _transformation;
public:
    Pipeline(T& transformation, Ts... following) : Pipeline<Ts...>(std::forward<Ts>(following)...), _transformation(transformation) {
        std::cout << "lvalue " << _transformation << " " << transformation << std::endl;
    }
};

int main() {
    std::string param1 = "param1";
    std::string param2 = "param2";
    std::string param3 = "param3";
    Pipeline<std::string&, std::string&&> p(param1, param2 + param3);
}

输出：

rvalue param2param3 
lvalue param1 param1

Live Demo

Answer 3

你可以做一些事情：

template <class... Ts>
class Pipeline {
};

template <class T, class... Ts>
class Pipeline<T, Ts...> {
public:
    template<class U, class... Us>
    Pipeline(U&& transformation, Us&&... following) : Pipeline<Ts...>(std::forward<Us>(following)...), _transformation(std::forward<U>(transformation)) {}
private:
    TransformationWrapper<T> _transformation;
}

template<class T>
class TransformationWrapper {
public:
    TransformationWrapper(T& t) : _reference(t) {}
    TransformationWrapper(T&& t) : _ptr(new T(std::move(t))) {}
    ~TransformationWrapper() { delete _ptr; }

    T& get() { if (_ptr==nullptr) return _reference.get() else return *_ptr; }

private:
    std::reference_wrapper<T> _reference;
    T* _ptr=nullptr;
}

但是转换时每个get()会花费你一个分支。

带有左值和右值

3 个答案: