Why not infer template parameter from constructor?

my question today is pretty simple: why can't the compiler infer template parameters from class constructors, much as it can do from function parameters? For example, why couldn't the following code be valid:

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
}

As I say, I understand that this isn't valid, so my question is why isn't it? Would allowing this create any major syntactic holes? Is there an instance where one wouldn't want this functionality (where inferring a type would cause issues)? I'm just trying to understand the logic behind allowing template inference for functions, yet not for suitably-constructed classes.

I think it is not valid because the constructor isn't always the only point of entry of the class (I am talking about copy constructor and operator=). So suppose you are using your class like this :

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

I am not sure if it would be so obvious for the parser to know what template type is the MyClass pm;

Not sure if what I said make sense but feel free to add some comment, that's an interesting question.

C++ 17

It is accepted that C++17 will have type deduction from constructor arguments.

Examples:

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

Accepted paper.

You can't do what you ask for reasons other people have addressed, but you can do this:

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

which for all intent and purposes is the same thing you ask for. If you love encapsulation you can make make_variable a static member function. That's what people call named constructor. So not only does it do what you want, but it's almost called what you want: the compiler is infering the template parameter from the (named) constructor.

NB: any reasonable compiler will optimize away the temporary object when you write something like

auto v = make_variable(instance);

In the enlightened age of 2016, with two new standards under our belt since this question was asked and a new one just around the corner, the crucial thing to know is that compilers supporting the C++17 standard will compile your code as-is.

Template-argument deduction for class templates in C++17

Here (courtesy of an edit by Olzhas Zhumabek of the accepted answer) is the paper detailing the relevant changes to the standard.

Addressing concerns from other answers

The current top-rated answer

This answer points out that "copy constructor and operator=" wouldn't know the correct template specializations.

This is nonsense, because the standard copy-constructor and operator= only exist for a known template type:

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;

Here, as I noted in the comments, there is no reason for MyClass *pm to be a legal declaration with or without the new form of inference: MyClass is not a type (it's a template), so it doesn't make sense to declare a pointer of type MyClass. Here's one possible way to fix the example:

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

Here, pm is already of the correct type, and so the inference is trivial. Moreover, it's impossible to accidentally mix types when calling the copy-constructor:

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

Here, pm will be a pointer to a copy of m. Here, MyClass is being copy-constructed from m—which is of type MyClass<string> (and not of the nonexistent type MyClass). Thus, at the point where pm's type is inferred, there is sufficient information to know that the template-type of m, and therefore the template-type of pm, is string.

Moreover, the following will always raise a compile error:

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

This is because the declaration of the copy constructor is not templated:

MyClass(const MyClass&);

Here, the copy-constructor argument's template-type matches the template-type of the class overall; i.e., when MyClass<string> is instantiated, MyClass<string>::MyClass(const MyClass<string>&); is instantiated with it, and when MyClass<int> is instantiated, MyClass<int>::MyClass(const MyClass<int>&); is instantiated. Unless it is explicitly specified or a templatized constructor is declared, there is no reason for the compiler to instantiate MyClass<int>::MyClass(const MyClass<string>&);, which would obviously be inappropriate.

The answer by Cătălin Pitiș

Pitiș gives an example deducing Variable<int> and Variable<double>, then states:

I have the same type name (Variable) in the code for two different types (Variable and Variable). From my subjective point of view, it affects the readability of the code pretty much.

As noted in the previous example, Variable itself is not a type name, even though the new feature makes it look like one syntactically.

Pitiș then asks what would happen if no constructor is given that would permit the appropriate inference. The answer is that no inference is permitted, because the inference is triggered by the constructor call. Without a constructor-call, there is no inference.

This is similar to asking what version of foo is deduced here:

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

The answer is that this code is illegal, for the reason stated.

MSalter's answer

This is, as far as I can tell, the only answer to bring up a legitimate concern about the proposed feature.

The example is:

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

The key question is, does the compiler select the type-inferred constructor here or the copy constructor?

Trying the code out, we can see that the copy constructor is selected. To expand on the example:

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

I am not sure how the proposal and the new version of the standard specify this; it appears to be determined by "deduction guides," which are a new bit of standardese that I don't yet understand.

I am also not sure why the var4 deduction is illegal; the compiler error from g++ seems to indicate that the statement is being parsed as a function declaration.