Disproving ISO C++'s definition of function templates

Question

A function template can be overloaded with other function templates and with normal (non-template) functions. A normal function is not related to a function template(i.e., it is never considered to be a specialization), even if it has the same name and the type as a potentially generated function template specialization.

This is the statement from ISO C++ Standard Section 14.5.5, 2nd point. Can this statement be proven wrong?

Edited: I need to disprove it, and for that i need to create a code snippet that will test whether or not this statement holds true.

Can anyone provide a code snippet?

Answer 1

I really don't think you should be arguing with the C++ standard. If you must disprove it, create a code snippet that will test whether or not this statement holds true.

Answer 2

This is the standard. How can you prove it wrong? There is nothing wrong or right here. It is as it is. If you find this is not as it is stated, then the compiler/platform is not following the standard.

Answer 3

This is purely based on what I understand from your defintion of 'negative' and 'fail'. These example show how to make overload resolution fail in some of the common situations

// Case 1: Two non template functions participating in overload resolution (and failing)

namespace A1{
    void f(){}
}

namespace A2{
    void f(){}
}

using A1::f;
using A2::f;

int main(){
   f();
}

Here the compilers will give error related to the fact that the call to 'f' is ambiguous as there are two viable functions. This proves that overload resolution is happening (and failing).

Case 2: // A template and a non template participating in an unsuccessful overload resolution

namespace A1{
    template<class T> int f(){}
}

namespace A2{
    void f(int){}
}

using A1::f;
using A2::f;

int main(){
   f();
}

// Case 3: Two template functions participating in a failed overload resolution

namespace A1{
        template<class T> int f(T, int){return 0;}
}

namespace A2{
        template<class T> double f(T, int){return 0;}
}

using A1::f;
using A2::f;

int main(){
   f(2.2, 2.2);
}

OR better still

namespace A1{ 
        template<class T> int f(T, int){return 0;} 
} 

namespace A2{ 
        template<class T> double f(int, T){return 0;} 
} 

using A1::f; 
using A2::f; 

int main(){ 
   f(2.2, 2.2); 
}