为什么在使用可变参数构造函数时必须创建类型别名？

Question

我有一个模板基类，它接受 N 种类型：

template <typename... Ts>
class Base{};

在该基类上使用受保护的继承时，

template <typename... Ts>
class Derived : protected Base<Ts...>{
   //like so...
};

我想另外包含基类的公共构造函数：

template <typename... Ts>
class Derived : protected Base<Ts...>{

   //create an alias
   using Parent = Base<Ts...>;

   //get all constructors as well
   using Parent::Parent; 
};

这行得通。
但是，为什么我必须包含 Parent 别名？

似乎没有它我无法获得构造函数。以下尝试不起作用：

template <typename... Ts>
class Derived : protected Base<Ts...>{

   //get all constructors as well
   using Base<Ts...>::Base<Ts...>; 
};

错误：

clang++ -std=c++1z -o main v.cpp
error: expected ';' after using declaration
       using Base<Ts...>::Base<Ts...>; 
                              ^
                              ;
1 error generated.

我可以切断模板部分，它可以编译，但这似乎不正确：

template <typename... Ts>
class Derived : protected Base<Ts...>{

   //get all constructors as well
   using Base<Ts...>::Base; 
};

我认为它不正确的原因是它似乎不适用于矢量。
无法编译：

template <typename... Ts>
class Derived : protected std::vector<Ts...>{

   //get all constructors as well
   using std::vector<Ts...>::std::vector; 
};

但是，使用别名确实有效。
编译：

template <typename... Ts>
class Derived : protected std::vector<Ts...>{

   //create an alias
   using Parent = std::vector<Ts...>;

   //get all constructors as well
   using Parent::Parent; 
};

问题：
我是否必须使用别名来获得相同的功能，或者有没有办法在不为基本类型创建新名称的情况下内联它？

Answer 1

您不需要类型别名。问题是Base<Ts...> 的构造函数没有被称为Base<Ts...>。它叫做Base。

这行得通：

template<class...Ts>
struct Base {

};

template<class...Ts>
struct Derived : Base<Ts...>
{
    using Base<Ts...>::Base;
};

另外std::vector<...>的构造函数的名字不是std::vector，而是vector

这也有效：

template<class...Ts>
struct Derived : std::vector<Ts...>
{
    using std::vector<Ts...>::vector;
};

但是，不要从 std:: 容器派生！封装它们。

Answer 2

在您的示例中，Base 没有模板构造函数，因此 using Base<Ts...>::Base<Ts...>; 正在尝试查找不存在的构造函数。

想象一下我有一门课像你的

class Base{
    public:
        Base(){}

        template<typename ... Ts>
        Base(){}
};

using Base<Ts...>::Base<Ts...> 会选择哪个构造函数？

using Parent = Base<Ts...> 起作用的原因是，当您编写using Parent::Parent 时，您试图找到一个Parent 的构造函数，该构造函数没有 模板化。它扩展为using Base<Ts...>::Base;。

Answer 3

using Base<Ts...>::Base<Ts...>; 是非法的，因为 [namespace.udecl]p5 中有一条非常普遍的规则：

using-declaration 不得命名 template-id。

这与不能在 using-declarations 中命名特定重载的事实非常相似。但是，我不知道这条规则的基本原理。

---

构造函数和名字的关系……很复杂：

• “构造函数没有名称。” ^{[class.ctor]p1}
• “using-declaration 的声明点没有命名构造函数 [...]”^{[class.ctor]p4}

因此，虽然构造函数没有名称，但它们可以被命名。对我来说，这似乎类似于匿名类型：

struct { int m; } x;
decltype(x) // refers to the type of `x` which has no name

一个应该继承构造函数的using-declaration必须命名一个构造函数。

---

[class.qual]p2 指定构造函数如何在qualified-ids 中命名（由一个nested-name-specifier 和一个unqualified-id 组成）：

在不忽略函数名的查找中， nested-name-specifier 指定一个类 C:

• (2.1) 如果在 nested-name-specifier 之后指定的名称，当在 C 中查找时，是 @987654326 的 injected-class-name @，或
• (2.2) 在作为 member-declaration 的 using-declaration 中，如果在 nested-name-specifier 之后指定的名称是相同的 最后的 identifier 或 simple-template-id 的 template-name 嵌套名称说明符的组件，

该名称被认为是命名类C的构造函数。

为了解决/评论其他一些答案，我会离题一点..

可以说 (2.1) 不适用于 OP：虽然 Base 包含 injected-class-name，但这个名称是 Base 而不是 Base<Ts...>。 nested-name-specifier之后指定的名字是Base<Ts...>，不是injected-class-name。

请注意，依赖基类的 injected-class-name 直到实例化时才知道。考虑

template<typename T>
struct foo : T {
    using T::name;
    void name(double);
};

struct name { name(int); };
struct bar { void name(int); };

foo<name> // constructor inheritance?
foo<bar>  // makes a function visible?

clang++ 拒绝这个例子，而 g++ 接受它。这是CWG 2070

然而，我们确实知道 OP 中的 Base 是一个类，因此可以推断 injected-class-name。这将需要区分在定义时名称已知的类型和不知道名称的类型。别名模板可以隐藏这一点，因此这不是 using-declaration 中qualified-id的form的微不足道的区别。

无论如何，要点 (2.2) 不适用于 Base<Ts...>::Base<Ts...>：它的 nested-name-specifier 是 Base<Ts...>。它的模板名称是Base。 nested-name-specifier 后面的名字是Base<Ts...>。

---

[class.qual]p2.2 允许使用Base<Ts...>::Base 和parent::parent，只需查看qualified-id 中使用的标识符。这里不需要执行实际的名称查找。表单本身足以命名构造函数。