«

Hello,
We all know that a template function can automatically deduce its
parameter type and instantiate, e.g.

template <tpyename T>
void func(T a);

func(0.f);

This will cause func<float> to be instantiated. The user does not have
to explicitly call func<float>(0.f);

However this line of thinking is broken when it comes to a template
class constructor function, e.g.

class A{
int x;
};

template <typename T>
class C{
C(const T & t) : t(t) {}
T t;
};

template <>
class C<A> {
C(const A & t) : t(t) {}
A t;
};


int main(){

A a;
C c(a);
}

The above code can't be successfully compiled. One has to name the type
returned from the constructor call to pick up the object. But what
really distinguishes from normal function call is that even C(a) fails,
compiler comlains missing template argument. The problem is sometimes
you want automatic (auto) type deduction that a compiler can provide but
you can't get it for constructor call.

What's the current best practice to approach such kind of problem, i.e.
automatic type deduction?

Fei