Template metaprogramming question

[Mordachai]

How might I go about creating a template that distinquishes between alternate implementations based on the internal structure of its target datatype?

What I want:

Initialized<Foo> foo;

Where Foo is a struct. In particular, I want Initialized<Foo> to be smart enough to generate code that sets Foo::cbSize to a real value IFF Foo has a member cbSize.

What I have currently:

template <typename T>
struct Initialized : public T
{
// ensure that we aren't trying to overwrite a non-trivial class
BOOST_STATIC_ASSERT((boost::is_POD<T>::value));

// publish our underlying data type
typedef T DataType;

// default (initialized) ctor
Initialized() { Reset(); }

// reset
void Reset() { Zero((T&)(*this)); }

// auto-conversion ctor
template <typename OtherType> Initialized(const OtherType & t) : T(t) { }

// auto-conversion assignment
template <typename OtherType> Initialized<DataType> & operator = (const OtherType & t) { *this = t; }
};


// version for Initialized<T>
template <typename T>
void Zero(Initialized<T> & object)
{
object.Reset();
}

==================

A second level of improvement would be to make Initialized<X> be smart enough to handle basic data types, such as int, float, etc. Obviously, the technique of inheriting from X doesn't work for simple data types (a real shame, as it perfectly describes "is a").

=================

Any help would be appreciated. When it comes to metaprogramming & templates, I'm still struggling to get them to do what I want.

[weaknessforcats]

That's not how you use templates.

Templates are for data types that have the SAME implementation. For specific implementations you write functions that you identy as explicit specializtions of the template.