In template function, how query the type?

Once I found out template using function actually compile on run-time, it scared me away from them for good.

Eh, function templates are compiled at compile time.

Hmm, I was about to point you to that page that said that, but after reading it again, I realized it didn't!

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.

Originally Posted by cpjust

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.

Overloading would still be better here, I think. For example, like this:

Code:

#include <boost/mpl/bool.hpp>

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNumHelper( const std::basic_string<E, T, A>&  str,
							 N&  num, boost::bool_<true> )
	{
		// Signed implementation.
	}

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNumHelper( const std::basic_string<E, T, A>&  str,
							 N&  num, boost::bool_<false> )
	{
		// Unsigned implementation.
	}

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNum( const std::basic_string<E, T, A>&  str,
							 N&  num )
	{
		StringToNumHelper( str, num,
			boost::bool_<std::numeric_limits<N>::is_signed>() );
	}

Originally Posted by CornedBee

Overloading would still be better here, I think. For example, like this:

Code:

#include <boost/mpl/bool.hpp>

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNumHelper( const std::basic_string<E, T, A>&  str,
							 N&  num, boost::bool_<true> )
	{
		// Signed implementation.
	}

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNumHelper( const std::basic_string<E, T, A>&  str,
							 N&  num, boost::bool_<false> )
	{
		// Unsigned implementation.
	}

	template <typename E,
		  typename T,
		  typename A,
		  typename N>
	void StringToNum( const std::basic_string<E, T, A>&  str,
							 N&  num )
	{
		StringToNumHelper( str, num,
			boost::bool_<std::numeric_limits<N>::is_signed>() );
	}

Actually, the StringToNumHelper() implementation is exactly the same for signed & unsigned. The only difference is the signedness of the N type; and since I don't like to copy and paste code for no reason, I did it like that.
I also could have overloaded StringToNum() for each signed & unsigned integer type, but I just felt like condensing it into 1 function.

Originally Posted by cpjust

Actually, the StringToNumHelper() implementation is exactly the same for signed & unsigned. The only difference is the signedness of the N type; and since I don't like to copy and paste code for no reason, I did it like that.
I also could have overloaded StringToNum() for each signed & unsigned integer type, but I just felt like condensing it into 1 function.

I understand the value of doing it yourself, but wouldn't boost::lexical_cast<> serve the purpose you're trying for here?

If the implementation is the same, why have two functions at all?

Originally Posted by brewbuck

I understand the value of doing it yourself, but wouldn't boost::lexical_cast<> serve the purpose you're trying for here?

Maybe... if I ever get the time to learn about all those cool Boost libraries.

Originally Posted by CornedBee

If the implementation is the same, why have two functions at all?

Because I need to pass either a long or unsigned long to the helper function to do it's job correctly here's the helper function:

Code:

	template <typename E,
		  typename T,
		  typename A,
		  typename LN,	// long or unsigned long.
		  typename N>
	void
	StringToNumHelper( const std::basic_string<E, T, A>&  str,
							 LN&  lnum,
							  N&  num )
	{
		std::basic_stringstream<E, T, A> ss( str );

		if ( !(ss >> lnum) || (lnum < std::numeric_limits<N>::min()) || (lnum > std::numeric_limits<N>::max()) )
		{
			throw std::invalid_argument( "Error converting string to number!" );
		}

		num = static_cast<N>( lnum );
	}

I was getting compile errors for everything I did if I tried to combine them into one function.

i was in a similar position once.

the solution i used was to create different derived classes for each type with virtual getters and setters.

I get it - you need a larger type to avoid overflow.

Not hard to solve with a simple metafunction, though. Boost might even have such a thing. But then, Boost also has lexical_cast.