时间戳

首页 > 解决方案 > 可变参数模板类的初始化没有匹配的构造函数

c++ - 可变参数模板类的初始化没有匹配的构造函数

问题描述

我正在尝试为 Miranda Conrado 提供的笛卡尔积迭代器编写一个包装类（源代码可以在GitHub上找到）。为方便起见，我也会在这里引用相关的代码。

我的类可以通过两种方式构建——一种直接，只需将容器转发给product_iterator构造函数，另一种有点棘手：它需要一些描述创建容器所需的 linspace 的元组，然后从中构造迭代器. 在这里我遇到了死胡同。

这是一些代码。首先，来自 Conrado 的一些相关标题class product_iterator：

// product_iterator.hpp

template <class... Containers>
class product_iterator:
    ...

    public:
      product_iterator();

      product_iterator(product_iterator const& other);

      product_iterator(Containers const&... containers);

      ~product_iterator();

      product_iterator const& operator=(product_iterator const& other);

     ....
};

template <class... Containers>
product_iterator<Containers...>
make_product_iterator(Containers const&... containers) {
  return product_iterator<Containers...>(containers...);
}

这是我的课：

// gridsearch.hpp

typedef std::unordered_map<std::string, Real> result_type;
typedef std::vector<result_type> resultgrid_type;


template <class... Containers>
class GridSearchIterator {
    typedef std::array<std::string,
            std::tuple_size<std::tuple<Containers...> >::value> 
            argname_type;

public:
    GridSearchIterator() : product_it(product_iterator<Containers...>()), 
                           argnames(argname_type()) {}

    GridSearchIterator(const argname_type& names, 
                       const Containers& ...containers);

    template <class... TupleTypes>
    static GridSearchIterator<Containers...> 
                                    initWith(const TupleTypes&& ...tuples);

    template<class F, class... Args>
    decltype(auto) iterate(F func, Args&&... params);

private:
    template <typename TupleType, size_t... Is>
    void product_impl(TupleType&& tuples, std::index_sequence<Is...>);
    template <typename TupleType>
    const auto& unpack_tuple(TupleType& t, size_t index);

    product_iterator<Containers...> product_it;
    argname_type argnames;
};

// implementation:

template <class... Containers>
GridSearchIterator<Containers...>::GridSearchIterator(
                                          const argname_type& names, 
                                          const Containers& ...containers):

                product_it(product_iterator<Containers...>(containers...)),
                                                        argnames(names) {}

template <class... Containers>
template <typename... TupleTypes>
GridSearchIterator<Containers...> GridSearchIterator<Containers...>::initWith(const TupleTypes&& ...tuples) 
{
    GridSearchIterator<Containers...> gsi = 
                                       GridSearchIterator<Containers...>();
    gsi.product_impl(std::tuple<TupleTypes...>(tuples...), 
                     std::index_sequence_for<TupleTypes...>{});
    return gsi;
}

template <class... Containers>
template <typename TupleType, size_t... Is>
void GridSearchIterator<Containers...>::product_impl(TupleType&& tuples, 
                                              std::index_sequence<Is...>) 
{
    product_it = product_iterator<Containers...>(
                                unpack_tuple(std::get<Is>(tuples), Is)...); 
// this is where the problem is; Compiler claims No matching constructor for initialization of 'product_iterator...
}

template <class... Containers>
template <typename TupleType>
const auto& GridSearchIterator<Containers...>::unpack_tuple(TupleType &t, 
                                                            size_t index) 
{
    std::string argname;
    auto left(0), right(0);
    Size step;
    std::tie(argname, left, right, step) = t;
    argnames[index] = argname;
    auto vec = linspace(left, right, step);
    return static_cast<const decltype(vec) &>(vec);
}

上面的函数linspace返回一个由 s均匀分布的left数字向量。它相当于 Numpy 函数。rightstepnp.linspace

我检查并调用unpack_tuple()确实产生了初始化所需的向量product_iterator，但编译器不同意。我的猜测是返回的类型与构造函数所期望unpack_tuple()的有所不同，product_iterator但我无法弄清楚问题所在。或者，问题实际上完全出在其他地方。

为了更好地理解，这是我使用该类的方式：

{
...
    typedef std::tuple<std::string, int, int, size_t> inttuple;
    typedef std::tuple<std::string, double, double, size_t> realtuple;
    typedef std::vector<int> intvector;
    typedef std::vector<Real> realvector;

    inttuple sidespan = std::make_tuple("side",1,1,1);
    real tuple takeprofit = std::make_tuple("takeprofit",1.,2.,2);
    real tuple stoploss = std::make_tuple("stoploss", -1.,-3.,3);
    inttuple period = std::make_tuple("horizon", 100, 100, 1);

    auto grid_iter = GridSearchIterator<intvector, realvector, realvector, intvector>
                                        ::initWith(std::forward<inttuple>(sidespan),
                                                   std::forward<realtuple>(takeprofit),
                                                   std::forward<realtuple>(stoploss),
                                                   std::forward<inttuple>(period));
...
}

我花了几个小时试图解决它，所以任何帮助或指示都会受到高度赞赏，包括关于不同实现的建议。

更新
对不起，我以为我昨天更新了我的问题，但由于某种原因没有保存更改。无论如何，@max66 即使没有其他信息也回答了这个问题。不过，为了完整起见，这里是linspace()定义

template <typename T>
std::vector<T> linspace(T a, T b, size_t N)

和编译器消息：

在 /.../main.cpp:17:
/.../gridsearch.hpp:98:18 包含的文件中：错误：没有匹配的构造函数用于初始化'product_iterator<std::__1::vector<int, std::__1::allocator<int> >, std::__1::vector<double, std::__1::allocator<double> >, std::__1::vector<double, std::__1::allocator<double> >, std::__1::vector<int, std::__1::allocator<int> > >' product_it = product_iterator<Containers...>(unpack_tuple(std::get<Is>(tuples), Is)...);

'GridSearchIterator<std::__1::vector<int, std::__1::allocator<int> >, std::__1::vector<double, std::__1::allocator<double> >, std::__1::vector<double, std::__1::allocator<double> >, std::__1::vector<int, std::__1::allocator<int> > >::product_impl<std::__1::tuple<std::__1::tuple<std::__1::basic_string<char>, int, int, unsigned long>, std::__1::tuple<std::__1::basic_string<char>, double, double, unsigned long>, std::__1::tuple<std::__1::basic_string<char>, double, double, unsigned long>, std::__1::tuple<std::__1::basic_string<char>, int, int, unsigned long> >, 0, 1, 2, 3>'/.../gridsearch.hpp:91:9：注意：在此处请求的函数模板特化的实例化中gsi.product_impl(std::tuple<TupleTypes...>(tuples...), std::index_sequence_for<TupleTypes...>{});

'GridSearchIterator<std::__1::vector<int, std::__1::allocator<int> >, std::__1::vector<double, std::__1::allocator<double> >, std::__1::vector<double, std::__1::allocator<double> >, std::__1::vector<int, std::__1::allocator<int> > >::initWith<std::__1::tuple<std::__1::basic_string<char>, int, int, unsigned long>, std::__1::tuple<std::__1::basic_string<char>, double, double, unsigned long>, std::__1::tuple<std::__1::basic_string<char>, double, double, unsigned long>, std::__1::tuple<std::__1::basic_string<char>, int, int, unsigned long> >'/.../main.cpp:90:88: 注意：在此处请求的函数模板特化的实例化中auto grid_iter = GridSearchIterator<intvector, realvector, realvector, intvector>::initWith(std::forward<inttuple>(sidespan),

在 /.../main.cpp:17 包含的文件中：
在 /.../gridsearch.hpp:22:/.../product_iterator.hpp:73:7 包含的文件中：注意：候选构造函数不可行：'vector<int, allocator<int>>' to 'const vector<double, allocator<double>>'第二个参数没有已知的转换product_iterator(Containers const&... containers);

标签： c++c++11variadic-templatestemplate-meta-programmingstdtuple

解决方案

如果您不提出完整的示例，则很难检查/验证/提出正确的代码。

无论如何，您在这一行中有错误（“没有匹配的构造函数”）

    product_it = product_iterator<Containers...>(
                                unpack_tuple(std::get<Is>(tuples), Is)...);

如果我理解正确，这里Containers...是intvector, realvector, realvector, intvectoraka std::vector<int>, std::vector<Real>, std::vector<Real>, std::vector<int>（我想Real是 的别名double）。

唯一的可变参数构造函数product_iterator是接收的Containers const&... containers，所以我想是你想要匹配的。

在我看来，问题在于unpack_tuple() 

template <class... Containers>
template <typename TupleType>
const auto& GridSearchIterator<Containers...>::unpack_tuple(TupleType &t, 
                                                            size_t index) 
{
    std::string argname;
    auto left(0), right(0);
    Size step;
    std::tie(argname, left, right, step) = t;
    argnames[index] = argname;
    auto vec = linspace(left, right, step);
    return static_cast<const decltype(vec) &>(vec);
}

返回一个( intVector const &) std::vector<int> const &。同样，当用realVector( std::vector<double>，我想) 调用时。

这（如果我没记错的话）是因为您将它们定义为left并初始化它们rightautoint

auto left(0), right(0);

当包含第二和第三位置的元素时，你int也会得到一些。TupleTypeReal

所以当你获得vec

auto vec = linspace(left, right, step);

您获得（我想） a std::vector<int>；曾经; 当你应该获得一个std::vector<Real>.

建议：定义left和right使用依赖于的正确类型TupleType。

通过示例（注意：代码未经测试）

using lr_type = typename std::tuple_element<1u, TupleType>::type;

lr_type  left, right;

从 C++14 开始，您可以使用std::tuple_element_t，`using 可以简化如下

using lr_type = std::tuple_element_t<1u, TupleType>;

如果可以使用 C++17，就可以使用结构化绑定，一切都会变得简单很多

template <typename TupleType>
const auto& GridSearchIterator<Containers...>::unpack_tuple(TupleType &t, 
                                                            size_t index) 
{
    auto [argname, left, right, step] = t;
    argnames[index] = argname;
    auto vec = linspace(left, right, step);
    return static_cast<const decltype(vec) &>(vec);
}

题外话：您确定将unpack_tuple()const引用返回到在方法执行结束时被销毁的值是个好主意吗？

推荐阅读