为什么不从构造函数推断模板参数？

Question

我今天的问题非常简单：为什么编译器不能从类构造函数推断模板参数，就像从函数参数推断一样？ 例如，为什么以下代码不能有效：

template <typename obj>
class Variable {
    obj data;
public:
    Variable(obj d) { data = d; }
};

int main() {
    int num = 2;
    Variable var(num); // would be equivalent to Variable<int> var(num),
    return 0;          // but actually a compile error
}

正如我所说，我知道这是无效的，所以我的问题是为什么不是吗？ 允许这样做会造成任何主要的语法漏洞吗？ 是否存在不希望使用此功能的情况（推断类型会导致问题）？ 我只是想理解允许对函数进行模板推断的逻辑，但不允许对适当构造的类进行模板推断。

Answer 1

我认为它是无效的，因为构造函数并不总是类的唯一入口点（我说的是复制构造函数和运算符=）。所以假设您像这样使用您的类：

MyClass m(string s);
MyClass *pm;
*pm = m;

我不确定是否对于解析器来说，知道 MyClass pm 是什么模板类型是非常明显的；

不确定我说的是否有意义，但请随意添加一些评论，这是一个有趣的问题。

C++ 17

人们普遍认为，C++17 将从构造函数参数进行类型推导。

示例：

std::pair p(2, 4.5);
std::tuple t(4, 3, 2.5);

已接受的论文。

Answer 2

你不能因为其他人已经解决的原因而按照你的要求去做，但你可以这样做：

template<typename T>
class Variable {
    public: Variable(T d) {}
};
template<typename T>
Variable<T> make_variable(T instance) {
  return Variable<T>(instance);
}

无论出于何种意图和目的，这与你所要求的事情是一样的。
如果您喜欢封装，可以将 make_variable 设为静态成员函数。 这就是人们所说的命名构造函数。 因此，它不仅可以执行您想要的操作，而且几乎可以称为您想要的操作：编译器从（命名的）构造函数推断模板参数。

注意：当您编写类似的内容时，任何合理的编译器都会优化掉临时对象

auto v = make_variable(instance);

Answer 3

在 2016 年的开明时代，自从提出这个问题以来，我们已经掌握了两个新标准，并且一个新标准即将到来，要知道的关键是支持 C++17 标准的编译器将按原样编译代码。

C++17 中类模板的模板参数推导

这里（由 Olzhas Zhumabek 对已接受答案的编辑提供）是详细介绍该标准的相关更改的论文。

解决其他答案中的问题

当前评分最高的答案

该答案指出“复制构造函数和 operator=”不知道正确的模板专业化。

这是无稽之谈，因为标准的复制构造函数和 operator= 仅存在 对于已知模板类型：

template <typename T>
class MyClass {
    MyClass(const MyClass&) =default;
    ... etc...
};

// usage example modified from the answer
MyClass m(string("blah blah blah"));
MyClass *pm;   // WHAT IS THIS?
*pm = m;

这里，正如我在评论中指出的那样，没有理由使 MyClass *pm 成为带有或不带有新的推理形式的合法声明：MyClass 不是类型（它是一个模板），因此声明 MyClass 类型的指针没有意义。 这是修复该示例的一种可能方法：

MyClass m(string("blah blah blah"));
decltype(m) *pm;               // uses type inference!
*pm = m;

这里，pm 已经是正确的类型，因此推断很简单。 此外，在调用复制构造函数时不可能意外地混合类型：

MyClass m(string("blah blah blah"));
auto pm = &(MyClass(m));

这里，pm将是指向m副本的指针。 此处，MyClass 是从 m 复制构造的，其类型为 MyClass（并且不是不存在的类型MyClass）。 因此，在推断 pm 的类型时，有足够的信息来了解 m 的模板类型，因此pm 的模板类型是 string。

此外，以下内容总是会引发编译错误：

MyClass s(string("blah blah blah"));
MyClass i(3);
i = s;

这是因为复制构造函数的声明不是模板化的：

MyClass(const MyClass&);

这里，复制构造函数参数的模板类型与整个类的模板类型相匹配； 即，当实例化 MyClass 时，MyClass::MyClass(const MyClass&); 会随之实例化，并且当 >MyClass 被实例化，MyClass::MyClass(const MyClass&); 被实例化。 除非显式指定或声明模板化构造函数，否则编译器没有理由实例化 MyClass::MyClass(const MyClass&);，这显然是不当。

Cătălin Pitiş Pitiş 的回答

给出了一个推导 Variable 和 Variable 的例子，然后指出：

我在两种不同类型（变量和变量）的代码中具有相同的类型名称（变量）。 从我的主观角度来看，它对代码的可读性影响很大。

正如前面的示例中所指出的，Variable 本身不是类型名称，尽管新功能使其在语法上看起来像一个类型名称。

然后皮蒂什问，如果没有给出允许适当推理的构造函数，会发生什么。 答案是不允许推理，因为推理是由构造函数调用触发的。 如果没有构造函数调用，就没有推理。。

这类似于询问此处推导的 foo 版本是多少：

template <typename T> foo();
foo();

答案是，由于所述原因，该代码是非法的。

MSalter 的回答

据我所知，这是对所提议的功能提出合理担忧的唯一答案。

例子是：

Variable var(num);  // If equivalent to Variable<int> var(num),
Variable var2(var); // Variable<int> or Variable<Variable<int>> ?

关键问题是，编译器在这里选择类型推断构造函数还是复制构造函数？

尝试一下代码，我们可以看到复制构造函数被选中。 扩展示例：

int num = 3;
Variable var(num);            // infering ctor
Variable var2(var);           // copy ctor
Variable var3(move(var));     // move ctor
Variable var4{Variable(num)}; // infering ctor
// Variable var4(Variable(num));     // illegal

我不确定该提案和新版本如何标准对此进行了规定； 它似乎是由“演绎指南”决定的，这是我还不明白的一些新的标准术语。

由于“最令人烦恼的解析”（该语句被解析为函数声明），var4 推导是非法的。 我不完全确定为什么，因为对我来说这看起来不像函数声明的有效语法。

Answer 4

仍然缺失：它使得下面的代码相当模糊：

int main()
{
    int num = 2;
    Variable var(num);  // If equivalent to Variable<int> var(num),
    Variable var2(var); //Variable<int> or Variable<Variable<int>> ?
}

Answer 5

假设编译器支持你所要求的。 那么这段代码是有效的：

Variable v1( 10); // Variable<int>

// Some code here

Variable v2( 20.4); // Variable<double>

现在，我在两种不同类型（变量和变量）的代码中具有相同的类型名称（变量）。 从我的主观角度来看，它对代码的可读性影响很大。 在同一命名空间中为两种不同类型使用相同的类型名称对我来说看起来很误导。

稍后更新：
另一件需要考虑的事情是：部分（或完整）模板专业化。

如果我专门化 Variable 并且没有提供您期望的构造函数怎么办？

所以我会：

template<>
class Variable<int>
{
// Provide default constructor only.
};

然后我有代码：

Variable v( 10);

编译器应该做什么？ 使用泛型Variable类定义推断出它是Variable，然后发现Variable不提供单参构造函数？

Answer 6

C++03 和 C++11 标准不允许从传递给构造函数的参数中进行模板实参推导。

但是有一个关于“构造函数的模板参数推导”的提案，因此您可能很快就会得到您想要的东西。 编辑：确实，此功能已在 C++17 中得到确认。

请参阅：http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.html 和 http://www.open-std.org/jtc1/sc22/ wg21/docs/papers/2015/p0091r0.html

Answer 7

许多类不依赖于构造函数参数。 只有少数类只有一个构造函数，并根据该构造函数的类型进行参数化。

如果您确实需要模板推理，请使用辅助函数：

template<typename obj>
class Variable 
{
      obj data;
public: 
      Variable(obj d)
      : data(d)
      { }
};

template<typename obj>
inline Variable<obj> makeVariable(const obj& d)
{
    return Variable<obj>(d);
}

Answer 8

类型推导仅限于当前 C++ 中的模板函数，但人们很早就意识到，在其他上下文中类型推导将非常有用。 因此，C++0x 的 auto。

虽然完全您所建议的内容在 C++0x 中是不可能的，但以下内容表明您可以非常接近：

template <class X>
Variable<typename std::remove_reference<X>::type> MakeVariable(X&& x)
{
    // remove reference required for the case that x is an lvalue
    return Variable<typename std::remove_reference<X>::type>(std::forward(x));
}

void test()
{
    auto v = MakeVariable(2); // v is of type Variable<int>
}

Answer 9

你是对的，编译器很容易猜到，但据我所知，它不在标准或 C++0x 中，所以在编译器提供商添加此功能之前，你必须等待至少 10 年（ISO 标准固定周转率）

Answer 10

让我们参考每个人都应该熟悉的类 - std::vector 来看看这个问题。

首先，向量的一个非常常见的用法是使用不带参数的构造函数：

vector <int> v;

在这种情况下，显然无法进行推理。

第二个常见用途是创建一个预先确定大小的向量：

vector <string> v(100);

这里，如果使用推理：

vector v(100);

我们得到一个整数向量，而不是字符串，并且可能它没有调整大小！

最后，考虑采用多个参数的构造函数 - 使用“推理”：

vector v( 100, foobar() );      // foobar is some class

应该使用哪个参数进行推理？ 我们需要某种方式告诉编译器它应该是第二个。

对于像向量这样简单的类来说，存在所有这些问题，很容易看出为什么不使用推理。

Answer 11

将 ctor 设为模板，变量只能有一种形式，但可以有多种 ctor：

class Variable {
      obj data; // let the compiler guess
      public:
      template<typename obj>
      Variable(obj d)
       {
           data = d;
       }
};

int main()
{
    int num = 2;
    Variable var(num);  // Variable::data int?

    float num2 = 2.0f;
    Variable var2(num2);  // Variable::data float?
    return 0;         
}

看到了吗？ 我们不能有多个 Variable::data 成员。

Answer 12

有关详细信息，请参阅C++ 模板参数推导。