template class instantiate without template parameter, automatic type deduction

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