“......”在变量模板的上下文中，令牌的规则是什么？

Question

在C 11中，有如下可变模板：

template< class T, class... Args >
unique_ptr<T> make_unique( Args&&... args )
{
    return unique_ptr<T>(new T(std::forward<Args>(args)...));
}

这里有一些奇怪的地方：表达式std::forward

另外：在函数实现中，省略号（…）位于兴趣表达的末尾。在模板参数列表和参数列表中省略省略是有原因的吗？




Answer 1

以下内容摘自Andrei Alexandresu在GoingNative 2012上的演讲“变量模板是有趣的”。我可以推荐它对变量模板的一个很好的介绍。

有两件事可以做一个可变的包。可以应用sizeof。。。（vs）获取元素数量并展开它。

Use            Expansion

Ts...          T1, ..., Tn
Ts&&...        T1&&, ..., Tn&&
x<Ts,Y>::z...  x<T1,Y>::z, ..., x<Tn,Y>::z
x<Ts&,Us>...   x<T1&,U1>, ..., x<Tn&,Un>
func(5,vs)...  func(5,v1), ..., func(5,vn)

扩张向内向外进行。当以锁步展开两个列表时，它们必须具有相同的大小。

gun(A<Ts...>::hun(vs)...);

展开A的模板参数列表中的所有Ts，然后函数hun用allvs展开。

gun(A<Ts...>::hun(vs...));

将A的模板参数列表中的所有Ts和所有vs展开为hun的函数参数。

gun(A<Ts>::hun(vs)...);

使用锁定步骤中的Ts和vs展开函数hun。

Ts不是类型，vs不是值！它们是类型/值列表的别名。任一列表都可能为空。两者都只服从特定的行动。所以以下是不可能的：

typedef Ts MyList;  // error!
Ts var;             // error!
auto copy = vs;     // error!

template <typename... Ts>
void fun(Ts... vs)

any a[] = { vs... };

template <typename... Ts>
struct C : Ts... {};
template <typename... Ts>
struct D : Box<Ts>... { /**/ };

// Inside struct D
template <typename... Us>
D(Us... vs) : Box<Ts>(vs)... {}

std::map<Ts...> m;

只有当参数可能匹配时才会编译。

template <class... Ts> void fun(Ts... vs) {
    auto g = [&vs...] { return gun(vs...); }
    g();
}

struct [[ Ts... ]] IAmFromTheFuture {};

它在规范中，但是还没有可以表示为类型的属性。

Answer 2

在变量模板的上下文中，省略号...用于解压模板参数包，如果它出现在表达式的右侧（暂时调用此表达式模式），或者如果它出现在左侧，则为包参数名字的一面：

...thing  // pack   : appears as template arguments
thing...  // unpack : appears when consuming the arguments

规则是，左侧的任何模式 重复-未打包的模式（现在称为表达式）用逗号分隔，。

通过一些例子可以更好地理解这一点。假设您有此函数模板：

template<typename ...T> //pack
void f(T ... args)      //pack
{
   // here are unpack patterns

   g( args... );        //pattern = args
   h( x(args)... );     //pattern = x(args)
   m( y(args...) );     //pattern = args (as argument to y())
   n( z<T>(args)... );  //pattern = z<T>(args)
}

现在，如果我调用这个函数传递T作为{int， char，短}，那么每个函数调用都扩展为：

g( arg0, arg1, arg2 );           
h( x(arg0), x(arg1), x(arg2) );
m( y(arg0, arg1, arg2) );
n( z<int>(arg0), z<char>(arg1), z<short>(arg2) );

在您发布的代码中，std:：forward遵循n（）函数调用所示的第四种模式。

请注意x（args） 和y（args…） 以上！

您可以使用将数组初始化为：

struct data_info
{
     boost::any  data;
     std::size_t type_size;
};

std::vector<data_info> v{{args, sizeof(T)}...}; //pattern = {args, sizeof(T)}

其扩展为：

std::vector<data_info> v 
{ 
   {arg0, sizeof(int)},
   {arg1, sizeof(char)},
   {arg2, sizeof(short)}
};

我刚刚意识到一个模式甚至可以包括访问说明符，如Public，如以下示例所示：

template<typename ... Mixins>
struct mixture : public Mixins ...  //pattern = public Mixins
{
    //code
};

在本例中，模式展开为：

struct mixture__instantiated : public Mixin0, public Mixin1, .. public MixinN  

也就是说，mixed从所有基类公开派生。

希望有帮助。