Re: Types ambiguity
On Jan 2, 5:46 pm, bra...@gmail.com wrote:
Consider the following program:
#include <iostream>
#include <string>
class TestClass
{
public:
void f(void) {}
};
template<typename T>
struct F{
typedef void (T::*Type)(void);
};
template<typename T>
void Execute_generic(T) {
std::cout << "Generic function" << std::endl;
}
template<typename T>
void Execute_generic(typename F<T>::Type) {
//void Execute_generic( void (T::*)(void) ) {
std::cout << "Specialization {void (T::*)(void)}" << std::endl;
}
template<typename T>
void Execute_generic(T*) {
std::cout << "Specialization {T*}" << std::endl;
}
template<typename T>
class C {
public:
void fun(T t) { Execute_generic(t); }
};
int main(void)
{
C<std::string> c1;
typedef void (TestClass::*pmem)(void);
C<pmem> c2;
C<double*> c3;
double u=0.0;
c1.fun(std::string("Hello"));
c2.fun(&TestClass::f);
c3.fun(&u);
return 0;
}
When I uncomment the line:
void Execute_generic( void (T::*)(void) )
I got output:
Generic function
Specialization {void (T::*)(void)}
Specialization {T*}
which is what I'm trying to achieve. But when I uncomment the line
that says:
void Execute_generic(typename F<T>::Type)
I got output:
Generic function
Generic function
Specialization {T*}
which I don't understand. What's the difference between void (T::*)
(void) and typename F<T>::Type.
It seems to be the same.
typename F<T>::Type is an non-deduced context. The compiler
cannot use it to deduce T. (There is a very simple technical
reason for this. What the compiler knows when it tries to do
type deduction here is the type it needs for F<T>::Type. The
only way it can find this type, however, is by generating all
possible instantiations of F<T> until it finds one with a Type
that matches. Since the number of possible instantiations is
infinite, the problem is unsolvable.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34