How do you know datatype when using Templates?

[Eternally]

Hi folks,

I've got a program which has a function which uses templates to accept
parameters of any type.

Works well, but there's one certain datatype which I want to special case
and do an extra thing to. The datatype is a class I made.

Is there anyway for me to test a parameters datatype in a template using
function?

Thanks a lot!!!

 

[Victor Bazarov]

I've got a program which has a function which uses templates to accept
parameters of any type.

Works well, but there's one certain datatype which I want to special case
and do an extra thing to. The datatype is a class I made.

Is there anyway for me to test a parameters datatype in a template using
function?

No. Well, there may be, but you better forget about it. That
is not the C++ way. The C++ way would be to either specialise
your template based on your new type or to overload the function
based on your type.

So, given

template<class T> void genericFun(T& t)
{
// does something to 't'
}

class myPreciousNewType {};

you want to add something to 'genericFun' to only do it to
an object of 'myPreciousNewType'. Here is how you do it:

// specialised:
template<> void genericFun<myPreciousNewType>(
myPreciousNewType& mpnt)
{
// basically copy all of it, then add some extra
}

or (better)

// overloaded:
void genericFun(myPreciousNewType& t)
{
// extra functionality
genericFun<myPreciousNewType>(t);
// extra functionality
}

YMMV, and variations of this are easily derived.

Victor

 

[Jumbo]

Hi folks,

I've got a program which has a function which uses templates to accept
parameters of any type.

Works well, but there's one certain datatype which I want to special case
and do an extra thing to. The datatype is a class I made.

Is there anyway for me to test a parameters datatype in a template using
function?

Yes I think I know what you mean , there is a STL <typeinfo>
It works something like this:

#include <iostream>
#include <typeinfo>

class UDT{};

template <typename T>
void foo(T arg){
std::cout << typeid(T).name() << '\n';
}

int main(){
int intX =0;
char chX =0;
UDT udtX;

foo(intX), foo(chX), foo(udtX);
return 0;
}

This will output the following:
int
char
class UDT
....

Look up your docs to get more info about it and you might need to set
compiler options to enable runtime type info .
HTH.
)

 

[Eternally]

No. Well, there may be, but you better forget about it. That
is not the C++ way. The C++ way would be to either specialise
your template based on your new type or to overload the function
based on your type.

So, given

template<class T> void genericFun(T& t)
{
// does something to 't'
}

class myPreciousNewType {};

you want to add something to 'genericFun' to only do it to
an object of 'myPreciousNewType'. Here is how you do it:

// specialised:
template<> void genericFun<myPreciousNewType>(
myPreciousNewType& mpnt)
{
// basically copy all of it, then add some extra
}

or (better)

// overloaded:
void genericFun(myPreciousNewType& t)
{
// extra functionality
genericFun<myPreciousNewType>(t);
// extra functionality
}

YMMV, and variations of this are easily derived.

Victor

Ohhhhh....Rats!

Thanks for the help. I was trying to avoid that, but I guess that's the way
to go.

I say "Rats!" because I kind of accidentally fibbed. Right now I only need
to special case one datatype, but soon it'll be like 5. They'll all be
special cased in the same exact manner though, so the psuedocode could've
looked like:

if(datatype==type1 or datatype==type2 or datatype==type3 or.....){
do the special case
}

I would just create 2 seperate functions with different names, but the
function that we're talking about here is actually the constructor function
in a class that I have.

Thanks a lot for the help though. If you can think of anything else, please
respond, but otherwise I'll just overload it X number of times.

Thanks again!

 

[Eternally]

Yes I think I know what you mean , there is a STL <typeinfo>
It works something like this:

#include <iostream>
#include <typeinfo>

class UDT{};

template <typename T>
void foo(T arg){
std::cout << typeid(T).name() << '\n';
}

int main(){
int intX =0;
char chX =0;
UDT udtX;

foo(intX), foo(chX), foo(udtX);
return 0;
}

This will output the following:
int
char
class UDT
...

Ahhh.....That's perfect. Exactly what I need. Just tested it and it works
great.

Thanks!

 

[tom_usenet]

Ahhh.....That's perfect. Exactly what I need. Just tested it and it works
great.

Note that typeid(T) is a relatively slow operator, whereas template
specialization is compile time and therefore has zero time overhead.

Tom

C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

 

[Dan W.]

Ahhh.....That's perfect. Exactly what I need. Just tested it and it works
great.

Thanks!

It may work, but it slows down your application.

What's wrong with template specialization/overload as Victor
suggested, anyways? Instead of checking type ID and doing a manual
switch to select a function, you let the compiler generate that code
for you. MUCH simpler! And faster. And cleaner.

 

[Jumbo]

Ohhhhh....Rats!

Thanks for the help. I was trying to avoid that, but I guess that's the way
to go.

I say "Rats!" because I kind of accidentally fibbed. Right now I only need
to special case one datatype, but soon it'll be like 5. They'll all be
special cased in the same exact manner though, so the psuedocode could've
looked like:

if(datatype==type1 or datatype==type2 or datatype==type3 or.....){
do the special case
}

I would just create 2 seperate functions with different names, but the
function that we're talking about here is actually the constructor function
in a class that I have.

Thanks a lot for the help though. If you can think of anything else, please
respond, but otherwise I'll just overload it X number of times.

You can specialize constructors just incase you don't realise this.
So you have a different constructor for each specialized type.

This is probably the more efficient way but you'll know best exactly what
your trying do.

HTH.

 

[chandra sekhar]

Hi,

You can use type_info class to get the type information inside a template
method.

One more way is CRuntimeClass if you are using MFC. But is it good to use
specific type stuff inside a template method ?

Bye
Chandra

 

[mubassara]

Could u plz tel me the compiler setting to enable runtime type info .