今天我要问的问题很简单：为什么编译器不能像从函数参数中一样从类构造函数中推断模板参数呢？例如，为什么下面的代码不能有效：
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将从构造函数参数中进行类型推导。
示例：
std::pair p(2, 4.5);
std::tuple t(4, 3, 2.5);
MyClass *pm将无效，原因与声明template <typename T> void foo();的函数不能在没有显式特化的情况下被调用相同。 - Kyle Strand出于其他人已经提到的原因，您无法做您要求的事情，但您可以做以下操作：
template<typename T>
class Variable {
public: Variable(T d) {}
};
template<typename T>
Variable<T> make_variable(T instance) {
return Variable<T>(instance);
}
从所有意义上讲，这就是你所请求的相同东西。
如果你喜欢封装，你可以将make_variable设为静态成员函数。这就是人们所谓的命名构造函数。因此它不仅可以完成你想要的功能，而且几乎被称为你想要的：编译器正在从（命名的）构造函数中推断模板参数。
NB: 任何合理的编译器都会在像下面这样写的时候优化掉临时对象
auto v = make_variable(instance);
auto v = make_variable(instance)，这样你就不需要实际指定类型，这样做更好。 - Claudiutemplate <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已经是正确的类型，因此推理是微不足道的。此外，在调用复制构造函数时，不可能意外地混合类型：mix。MyClass m(string("blah blah blah"));
auto pm = &(MyClass(m));
这里，pm将是指向m的副本的指针。这里，MyClass正在从类型为MyClass<string>（而不是不存在的类型MyClass）的m进行复制构造。因此，在推断pm的类型的点上，有足够的信息可以知道m的模板类型，因此pm的模板类型是string。
此外，以下内容始终会引发编译错误：
MyClass s(string("blah blah blah"));
MyClass i(3);
i = s;
MyClass(const MyClass&);
这里，复制构造函数的参数模板类型“匹配”类的整体模板类型；即，当实例化MyClass<string>时，将与之一起实例化MyClass<string>::MyClass(const MyClass<string>&)，而当实例化MyClass<int>时，将与之一起实例化MyClass<int>::MyClass(const MyClass<int>&)。除非明确指定或声明了一个模板化构造函数，否则编译器没有理由实例化MyClass<int>::MyClass(const MyClass<string>&)，那显然是不合适的。
Pitiș给出了推断Variable<int>和Variable<double>的示例，然后陈述：
我在代码中有两种不同类型（Variable和Variable）的相同类型名（Variable）。从我的主观角度来看，这对代码的可读性影响很大。
正如前面的例子所述，Variable本身并不是一个类型名称，尽管新特性在语法上让它看起来像是一个。
Pitiș随后问如果没有提供允许适当推断的构造函数会发生什么。答案是没有推断被允许，因为推断是由构造函数调用触发的。没有构造函数调用，则没有推断。
这类似于询问在这里推导出了哪个版本的foo：
template <typename T> foo();
foo();
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的推导是非法的。我不完全确定原因，因为对我来说，这看起来不像一个有效的函数声明语法。var4 只是“最令人烦恼的解析”之一（与模板参数推导无关）。我们过去通常会使用额外的括号来解决这个问题，但现在我认为使用大括号来明确表示构造是通常的建议。 - Sumudu FernandoVariable var4(Variable(num));被视为函数声明吗？如果是，那么为什么Variable(num)是有效的参数说明呢？ - Kyle Strand仍有缺失：它使得以下代码相当模糊：
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>
template<>
class Variable<int>
{
// Provide default constructor only.
};
然后我有这段代码:
Variable v( 10);
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);
}
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的一个非常常见的用法是使用不带参数的构造函数：
vector <int> v;
vector <string> v(100);
如果使用推理：
vector v(100);
我们得到的是一个整数向量，而不是字符串，并且可能没有确定大小！
最后，考虑带有“推断”的多参数构造函数：
vector v( 100, foobar() ); // foobar is some class
template<class T> Variable<T> make_Variable(T&& p) {return Variable<T>(std::forward<T>(p));}- Mooing Duck