Re: template class instantiate without template parameter, automatic type deduction
Fei Liu wrote:
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.
Correct. The syntax involves the _type_ name, not a function name.
The problem is
sometimes you want automatic (auto) type deduction that a compiler can
provide but you can't get it for constructor call.
That's not true at all. In your example it's not the constructor that
is a template for which the argument needs to be deduced, it's the type
template that needs to be instantiated. When constructors are concerned,
this is the correct (and working) example:
struct C {
template<class T> C(const T& t) {}
};
struct A {};
int main() {
A a;
C c(a); // compiles just fine
}
What's the current best practice to approach such kind of problem,
i.e. automatic type deduction?
Wrap it in a function template.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask