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

我今天的问题很简单：为什么编译器不能像从函数参数中那样从类构造函数中推断出模板参数？例如，为什么以下代码无效：

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
}

正如我所说，我知道这是无效的，所以我的问题是为什么呢？允许这样做会造成任何重大的语法漏洞吗？是否存在一个实例，该实例不希望使用此功能（推断类型会导致问题）？我只是在试图理解允许对函数进行模板推断的逻辑，而对于允许适当构造的类则不是。

我认为这是无效的，因为构造函数并不总是该类的唯一入口（我说的是复制构造函数和operator =）。因此，假设您正在使用这样的类：

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);

接受纸张。

由于其他人已解决的原因，您无法执行自己要求的操作，但是您可以执行以下操作：

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);

在开明的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<string>（而不是不存在的类型MyClass）复制构造的。因此，在点pm的类型推断，存在是足够的信息来知道模板型的m，因此，模板型的pm，则string。

此外，以下内容将始终 引发编译错误：

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

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

MyClass(const MyClass&);

在这里，copy-constructor参数的template-type 与整个类的template-type 相匹配。即，何时MyClass<string>被实例化，MyClass<string>::MyClass(const MyClass<string>&);用它实例化，以及何时MyClass<int>被实例化，MyClass<int>::MyClass(const MyClass<int>&);被实例化。除非明确指定它或声明一个模板化的构造函数，否则编译器没有理由实例化MyClass<int>::MyClass(const MyClass<string>&);，这显然是不合适的。

CătălinPitiș的回答

皮蒂ș举了一个推论Variable<int>和的例子Variable<double>，然后说：

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

如前面的示例所述，即使新功能使它在语法上看起来像一个名称，Variable它本身也不是类型名称。

然后，Pitiș询问如果没有给出允许适当推断的构造函数，将会发生什么情况。答案是不允许推论，因为推论是由构造函数call触发的。没有构造函数调用，就没有推断。

这类似于询问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>> ?

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

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

Variable var(num);          // infering ctor
Variable var2(var);         // copy ctor
Variable var3(move(var));   // move ctor
// Variable var4(Variable(num));     // compiler error

我不确定提案和标准的新版本是如何指定的；它似乎由“演绎指南”决定，这是我尚不了解的一些新的标准语。

我也不确定为什么var4扣除是非法的。g ++的编译器错误似乎表明该语句已被解析为函数声明。

仍然缺少：它使以下代码变得很模糊：

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

假设编译器支持您的要求。那么此代码是有效的：

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不提供一个参数构造函数？

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/论文/2015/p0091r0.html

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

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

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);
}

类型的推导仅限于当前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>
}

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

让我们看一下每个人都应该熟悉的类的问题-std :: vector。

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

vector <int> v;

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

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

vector <string> v(100);

在这里，如果使用推断：

vector v(100);

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

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

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

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

对于像vector这样简单的类，由于存在所有这些问题，因此很容易理解为什么不使用推理。

使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成员。

有关更多信息，请参见C ++模板参数推导。