而不是像这样创建矢量:
std::vector<int> v1{1,2,3};
std::vector<double> v2{1.1,2.2,3.3};
std::vector<Object> v3{Object{},Object{},Object{}};
我想用通用功能创建它们:
auto v1 = make_vector(1,2,3);
auto v2 = make_vector(1.1,2.2,3.3);
auto v3 = make_vector(Object{},Object{},Object{});
与std::make_pair和std::make_tuple类似,这是我尝试使用矢量:
#include <iostream>
#include <vector>
#include <utility>
template <typename... T>
auto make_vector(T&&... args)
{
using first_type = typename std::tuple_element<0, std::tuple<T...>>::type;
return std::vector<first_type>{std::forward<T>(args)...};
}
它编译,但当我尝试使用它时:
auto vec = make_vector(1,2,3);
m.cpp: In instantiation of ‘auto make_vector(T&& ...) [with T = {int, int, int}]’:
m.cpp:16:30: required from here
m.cpp:8:78: error: invalid use of incomplete type ‘class std::tuple_element<0ul, std::tuple<int, int, int> >’
using first_type = typename std::tuple_element<0, std::tuple<T...>>::type;
^
In file included from m.cpp:3:0:
/usr/include/c++/5/utility:85:11: note: declaration of ‘class std::tuple_element<0ul, std::tuple<int, int, int> >’
class tuple_element;
^
m.cpp:9:60: error: invalid use of incomplete type ‘class std::tuple_element<0ul, std::tuple<int, int, int> >’
return std::vector<first_type>{std::forward<T>(args)...};
^
In file included from m.cpp:3:0:
/usr/include/c++/5/utility:85:11: note: declaration of ‘class std::tuple_element<0ul, std::tuple<int, int, int> >’
class tuple_element;
^
m.cpp: In function ‘int main()’:
m.cpp:16:30: error: ‘void v1’ has incomplete type
auto v1 = make_vector(1,2,3);
如何制作通用例程,
使用第一个参数的第一个类型来实例化向量?
如何将参数作为初始化值转发给向量?
答案 0 :(得分:9)
由于无论如何都不能使用它来创建空向量,我们可以通过提供额外的模板参数来避免tuple
依赖:
template <class T0, class... Ts>
auto make_vector(T0&& first, Ts&&... args)
{
using first_type = std::decay_t<T0>;
return std::vector<first_type>{
std::forward<T0>(first),
std::forward<Ts>(args)...
};
}
如果first
作为左值传入,则具有工作的额外好处。
答案 1 :(得分:4)
让我们关注make_array
的主角,并允许用户明确指定返回类型,或使用std::common_type
确定的返回类型。
template<class T> struct identity { using type = T; };
template<class D, class... Ts>
struct ret : identity<D> {};
template<class... Ts>
struct ret<void, Ts...> : std::common_type<Ts...> {};
template<class D, class... Ts>
using ret_t = typename ret<D, Ts...>::type;
template<class D = void, class... Ts>
std::vector<ret_t<D, Ts...>> make_vector(Ts&&... args) {
std::vector<ret_t<D, Ts...>> ret;
ret.reserve(sizeof...(args));
using expander = int[];
(void) expander{ ((void)ret.emplace_back(std::forward<Ts>(args)), 0)..., 0 };
return ret;
}
使用完美转发表明您想要消除不必要的复制;这与使用需要每个元素副本的initalizer_list
构造函数不一致。所以相反,上面的代码reserve
是适当的空间,然后emplace_back
逐个使用通常的包扩展技巧。
push_back
,但代价是可能导致类型不匹配。但是,在这种情况下,类型要么由用户明确指定,要么通过common_type
的隐式转换推断出来,因此emplace_back
可能就好了。
答案 2 :(得分:2)
就像你做的那样 - gcc和msvc用一个小#include <tuple>
编译你的函数。