Is there a way to tell a template TYPE in its function?

[meili100]

The code should not compile, but is there a way to tell if T is an "int" type in foo()?

template <typename T>                                                           
class A{                                                                        
public:                                                                         
    void foo();                                                                 
};                                                                              
                                                                                
template <typename T>                                                           
void foo<T>()                                                                   
{                                                                               
    if (T=="int")                                                               
        cout<<"int"<<endl;                                                      
}                                                                               
                                                                                
int main(int argc, char* argv[]){                                               
    A<int> a;                                                                   
    a.foo();                                                                    
    return 0;                                                                   
}

[cpjust]

Did you try using the typeid operator?
I never use it because I found it to be unreliable, but maybe for primative types it would be OK?

[Sebastiani]

it's called 'template specialization'. so basically:

template <typename T>                                                           
class A{                                                                        
public:                                                                         
    void foo();                                                                 
};                                                                              
                                                                                
template <>                                                           
class A<int>{                                                                        
public:                                                                         
    void foo();                                                                 
};      

template <typename T>                                                           
void A<T>::foo()                                                                   
{                                                                               
        cout<<"A<T>::foo()"<<endl;                                                      
}   
                                                          
void A<int>::foo()                                                                   
{                                                                               
        cout<<"A<int>::foo()"<<endl;                                                      
}                                                                              

int main(int argc, char* argv[]){                                               
    
    A<double> a;                                                                   
    A<int> b; 
    a.foo(); 
    b.foo();                                                                   
    return 0;                                                                   
}

[phantomotap]

Use traits if you need part of the behavior of a template to be specific for various types. (In practice it is better to factor the type specific parts out into their own function.)

And you don't need to specialize an entire template to specialize a single function.

Soma

#include <iostream>

template <typename T>
struct is_int
{
operator bool(){return false;}
};

template <>
struct is_int<int>
{
operator bool(){return true;}
};

template <typename T>                                                           
class A{                                                                        
public:                                                                         
    void foo();                                                                 
};                                                                              
                                                                                
template <typename T>                                                           
void A<T>::foo()                                                                   
{                   
if(is_int<T>())
{
std::cout<<"int";
}                
else
{
std::cout<<"not int";
}                                                                                            
}       

template <>                                                           
void A<double>::foo()                                                                   
{          
std::cout<<"double";                                                                                                                     
}                                                                               
                                                                                
int main(int argc, char* argv[]){                                               
    A<int> a;                                                                   
    a.foo();      
    A<double> b;
    b.foo();
    A<long> c;
    c.foo();                                                         
    return 0;                                                                   
}

[CornedBee]

You can't do that if you want to use type-specific code (i.e. something that only compiles for one type) in that template.

Just specialize the function.

template <typename T>                                                           
class A{                                                                        
public:                                                                         
    void foo();                                                                 
};                                                                              
                                                                                
template <typename T>                                                           
void A<T>::foo()                                                                   
{                                                                               
}                                                                               

template <>
void A<int>::foo()
{
        cout<<"int"<<endl;
}
                                                                                
int main(int argc, char* argv[]){                                               
    A<int> a;                                                                   
    a.foo();                                                                    
    return 0;                                                                   
}