Thread: In template function, how query the type?

If I have a function with a template type, how can I query that at runtime? For example, if I want to know if it's a primitive (int, long, bool, etc) I'll do one thing, otherwise something else.

Code:

template <typename T>
void getData(const std::vector<T> &data)
{
      //I essentially want to do something like this
     if ( type_id( T ) == type_id( int ) ...

}

Often you want the code to work regardless of type.

I got it to work!

Code:

if ( typeid( T ) == typeid( int ) )...

Originally Posted by laserlight

If you can avoid RTTI, avoid it. If you specialise the template, there is no RTTI overhead (though you may add to executable code bloat).

I was using the template because I need excatly the same thing for almost every case except for a few (int, short). In those cases, 50% of the code's the same and 50% is diff. Does it make more sense to overload the functions where I have one for int vectors, one for short vectors and one with a template for everything else instead of doing a few if...else statements? Why? (And will it even work to have the function overloaded with two specialized versions and one templated version?)

Thanks for the help!

I've had some bad experiences with RTTI when using it with derived classes... so I try to avoid it whenever possible.
I had a case where I needed a template to do one thing for signed numbers and another for unsigned. After some searching I came up with this non-RTTI solution:

Code:

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNum( const std::basic_string<E, T, A>&  str,
							 N&  num )
	{
		if ( std::numeric_limits<N>::is_signed == true )
		{
			signed long lnum = 0;
			StringToNumHelper( str, lnum, num );
		}
		else
		{
			unsigned long lnum = 0;
			StringToNumHelper( str, lnum, num );
		}
	}

Most of the time, you'll probably be able to find an equally simple non-RTTI solution if you search hard enough.

Originally Posted by 6tr6tr

I was using the template because I need excatly the same thing for almost every case except for a few (int, short). In those cases, 50% of the code's the same and 50% is diff. Does it make more sense to overload the functions where I have one for int vectors, one for short vectors and one with a template for everything else instead of doing a few if...else statements? Why? (And will it even work to have the function overloaded with two specialized versions and one templated version?)

Just because you can't see the alternate solution doesn't mean it isn't there. If 50% of the code is the same, then that 50% should be broken out into another function, so that only the changing 50% is written in the specializations.

RTTI is a crutch. It often indicates poor programming.

laserlight: why is RTTI so horrible?
i understand that in some applications, due to real time needs, you may be concerned.
but why should we avoid it, in general, for all kind of apps?

Originally Posted by manav

laserlight: why is RTTI so horrible?
i understand that in some applications, due to real time needs, you may be concerned.
but why should we avoid it, in general, for all kind of apps?

Using RTTI in a template defeats the entire purpose of templates, which is that you can specialize on specific types.

ok. so laserlight was saying that avoid RTTI in case of templates.
i thought he was saying avoid RTTI in general. always.

laserlight: i just read some info about RTTI. and yes, we don't need to avoid RTTI. in fact it is just not needed. always.
and it's much easier to use alternatives like templates and virtuals.
actually till now i never had to care about it.