RE: [Boost-users] Re: Question

12 May 2005

      Thanks for help,

I have an additional question. Does anyone know why the following
program gives different output on VC++ 6 and VC++ 2003 NET? It is pretty
strange, isn't it?

Thanks in advance.

Pshemek

#include <iostream>
#include <cmath>

using namespace std;

class A
{	
	protected:
		char m_d;
};

class B : public A
{
	public:
		typedef char s;
	private:
		unsigned short g;
};

class C : public A
{
	public:
		typedef short unsigned s;
	private:
		unsigned d;
};

template<bool cond>
class Select {};

template<> class Select<true>
{
	static void Statment1(double g)
	{
		cout << g*g << endl;
	}
	public:
		static void f(double g)
		{
			Statment1(g);
		}
};

template<> class Select<false>
{
	static void Statment2(double g)
	{
		cout << sqrt(g) << endl;
	}
	public:
		static void f(double g)
		{
			Statment2(g);
		}
};

template<bool cond> void exec()
{
	Select<cond>::f(3.0);
}

template<class T>
void foo()
{
	exec<sizeof(T::s)==sizeof(B::s)>();
	exec<sizeof(T::s)==sizeof(C::s)>();	
}

int main()
{
	foo<B>();
	foo<C>();

	return 0;
}

-----Original Message-----
From: boost-users-bounces@lists.boost.org
[mailto:boost-users-bounces@lists.boost.org] On Behalf Of Eric Niebler
Sent: 11 May 2005 18:37
To: boost-users@lists.boost.org
Subject: [Boost-users] Re: Question

Sliwa, Przemyslaw (London) wrote:
...
I would like to write a template which depending on the argument type 
does different things.
For example the pseudo code:
template <class T, class C>
foo(T& nT, C& nC)
{
    // common code;
    if(T==C)
    // specific code;
    .....
// again common code;
}
Can the template meta programming help me in this case?
It may. It depends on whether "specific code" compiles when T!=C. If it 
does, you could do this:

template <class T, class C>
void foo(T& nT, C& nC)
{
     // common code
     if(boost::is_same<T,C>::value)
       { /* specific code */ }
     // again common code
}

where is is_same<> is defined in boost/type_traits/is_same.hpp. If 
"specific code" doesn't compile when T!=C, you need to get fancier. An 
overloaded helper function is the way to go:

template<class T, class C>
void specific_code(T&, C&) {}

template<class T>
void specific_code(T&, T&)
{
   // specific code here
}

template <class T, class C>
void foo(T& nT, C& nC)
{
     // common code
     specific_code(nT, nC);
     // again common code
}

HTH,

-- 
Eric Niebler
Boost Consulting
www.boost-consulting.com
_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users
--------------------------------------------------------

If you are not an intended recipient of this e-mail, please notify the sender, delete it and do not read, act upon, print, disclose, copy, retain or redistribute it. Click here for important additional terms relating to this e-mail.     http://www.ml.com/email_terms/
--------------------------------------------------------