防止隐式模板实例化

Question

In a method overload situation like this:

struct A
{
  void foo( int i ) { /*...*/ }
  template<typename T> void foo( T t ) { /*...*/ }
}

How can I prevent template instantiation unless explicitly commanded?:

A a;
a.foo<int>( 1 ); // ok
a.foo<double>( 1.0 ); // ok
a.foo( 1 ); // calls non-templated method
a.foo( 1.0 ); // error

Thanks!

Answer 1

You can introduce a depedent_type struct that prevents template argument deduction .

template <typename T>
struct dependent_type
{
    using type = T;
};

struct A
{
  void foo( int i ) { /*...*/ };
  template<typename T> void foo( typename dependent_type<T>::type t ) { /*...*/ }
}

Which in your example:

a.foo<int>( 1 );      // calls the template
a.foo<double>( 1.0 ); // calls the template
a.foo( 1 );           // calls non-templated method
a.foo( 1.0 );         // calls non-templated method (implicit conversion)

wandbox example

(This behavior is explained on cppreference > template argument deduction > non-deduced contexts .)

---

If you want to make a.foo( 1.0 ) a compilation error, you need to constrain the first overload:

template <typename T> 
auto foo( T ) -> std::enable_if_t<std::is_same<T, int>{}> { }

This technique makes the above overload of foo take only int arguments: implicit conversions (eg float to int ) are not allowed. If this is not what you want, consider TemplateRex's answer.

wandbox example

(With the above constrained function, there is a curious interaction between the two overloads when a.foo<int>( 1 ) is called. I asked a question about it as I'm not sure of the underlying rules that guide it.)

Answer 2

By far the simplest way to do what you want is to explicitly delete the overload you don't want:

void foo(double) = delete;

Ie to have the following explicit example:

#include <iostream>

struct A
{
    void foo(int) { std::cout << __PRETTY_FUNCTION__ << "\n"; }
    void foo(double) = delete;

    template<typename T> 
    void foo( T ) {std::cout << __PRETTY_FUNCTION__ << "\n"; }
};

int main() 
{    
    A a;
    a.foo<int>( 1 );        // ok
    a.foo<double>( 1.0 );   // ok
    a.foo( 1 );             // calls non-templated method
    a.foo( 1.0 );           // error    
}

With the last line in main commented out this prints

void A::foo(T) [with T = int] void A::foo(T) [with T = double] void A::foo(int)

and with the last line left in this prints

prog.cc: In function 'int main()': prog.cc:18:16: error: use of deleted function 'void A::foo(double)' a.foo( 1.0 ); // error ^ prog.cc:6:10: note: declared here void foo(double) = delete;

Answer 3

Adding another suggestion to the pot, and in a similar vein as Vittorio's answer you can also add another template parameter to the signature:

template <class UserType, class InputType>
void foo(InputType x){...}

Then to use it you must specify the first template parameter as it cannot be deduced. This has the slight advantage of being able to distinguish between what the user wanted and what was passed in, which could possibly be of use in some cases.

Answer 4

Halelulah!!!!!!! I finally found the answer after years of grief. Cause I knew that cpp rule, seperate declaration from definition was not just thrown in the dump!!!

// declare template
template <class T> void test();

// declare specialization
template <> // very import to start with this token
void<int> test();

// implicit instantiation
template // if you use this instead, you get instantiation
void<int> test();

I still wonder why this is necessary. Probably it is an optimization from those wise people of the Cpp Committee.