Turning off template parameter deduction

[KD]

I have a template function and I'm looking for a way to force the
caller to specify the template parameters. In other words, I would
like to turn off template parameter deduction. For example,

template <class T>
void foo(T t)
{
...
}

foo(123); // I want this to fail.
foo<int>(123); // I want this to succeed.

I was hoping that the explicit keyword would work, but it didn't. So
far, the only half working hack that I came up with is having two
parameters S and T, where S is not used so it must be specified. In
the method, I then do static checks that T is convertible to S, but it
doesn't work in all cases and it adds some complexity to the code.

Any ideas?

 

[Fei Liu]

I have a template function and I'm looking for a way to force the
caller to specify the template parameters. In other words, I would
like to turn off template parameter deduction. For example,

template <class T>
void foo(T t)
{
...
}

foo(123); // I want this to fail.
foo<int>(123); // I want this to succeed.

I was hoping that the explicit keyword would work, but it didn't. So
far, the only half working hack that I came up with is having two
parameters S and T, where S is not used so it must be specified. In
the method, I then do static checks that T is convertible to S, but it
doesn't work in all cases and it adds some complexity to the code.

Any ideas?

the more important question to ask is: why would you want to do
something like that?

Although I believe there are ways to do what you wanted but I don't
think there is a generic solution.

F

 

[gpderetta]

the more important question to ask is: why would you want to do
something like that?

To implement something similar to standard C++ casts for example.

Although I believe there are ways to do what you wanted but I don't
think there is a generic solution.

Sure that there is: just put T in a non deducible context:

template<typename T> struct identity { typedef T type; };

template<typename T>
void do_not_deduce(typename identity<T>::type x);

HTH,

 

[KD]

To implement something similar to standard C++ casts for example.




Sure that there is: just put T in a non deducible context:

template<typename T> struct identity { typedef T type; };

template<typename T>
void do_not_deduce(typename identity<T>::type x);

HTH,

Thank you. This seems to work for me, and is cleaner than my previous
solution.

 

[Road.Tang]

To implement something similar to standard C++ casts for example.

IMO, to implement cast like things doesn't need the trick.

template <typename T, typename S> T& user_cast(S& s);

T is result type, can't be deduced yet.

Sure that there is: just put T in a non deducible context:

template<typename T> struct identity { typedef T type; };

template<typename T>
void do_not_deduce(typename identity<T>::type x);

aha , impressive trick.