具有左值和右值的变分模板类构造函数

Variadic template class constructor with lvalues and rvalues

本文关键字：构造函数      更新时间：2023-10-16

我正在构建一个机器学习库，试图充分利用C++的内置功能，尤其是C++11。我有各种各样的类来执行输入的修改，称为Transformations。现在我想建立一个它们的管道，将它们一个接一个地链接起来（最终在链的末端有一个机器学习算法，比如分类器或回归器）。

我认为具有可变模板参数的类是这个用例的完美匹配。问题是，我想在构造函数中同时接受右值和左值。

对于右值，我想移动它，对于左值，我希望保留对它的引用（尽管我仍然不能100%确定这一点，因为它可能是绑定到某个范围的引用，并且作为函数的结果返回管道会爆炸；但对于这个库的目的，这可以记录下来）。

这将是类：

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和Ts。

编辑：在左值的情况下，它应该是非常数，因为管道可以修改转换。

以下是您可以执行的操作的示例（请注意，在下面的代码中，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的构造函数，以检查参数包（T和U）是否相同。要做到这一点，您可以使用std::is_same的通用版本（如果需要，请参阅此处了解可能的实现）
显然，这个例子是一个极小的例子。在实际代码中可以使用多个变换，这是从类型S<T, T>切换到类型S<T1, T2, TAndSoOn>的问题。

通过执行上面的示例可以看到，在构造S时，复制和移动构造函数会被正确调用。operator()对元组进行解包并使用引用，因此在这种情况下没有额外的副本。

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

#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

实时演示

您可以按照以下方式进行操作：

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()，就需要花费一个分支。

相关文章：