I am building a make_ function for a complicated type with many generic parameters that all have defaults. I believe the following doesn't work in C++03 (but might in C++0X?) template<class T> void myfunc(T t = default_type()) {} if called with no arguments. Here is pseudocode for what I would like to do (unworking, so please bear with any mpl mistakes) struct default_tag{}; struct default_type // metafunction to return the default type to keep it centralized. { typedef int type; type construct() //A construction function? { return type(); } }; template<class T> class myclass { myclass(const T& t){....} //Requires a type }; template<class T> myclass< mpl::if_<mpl::is_same<T, default_tag>, //returns a my_class<> default_type, //call this metafunction if default T > //otherwise pass it in. > make_myclass(const T& t = default_tag()) //Note use of the default_tag { typename myclass< mpl::if_<mpl::is_same<T, default_tag>, default_type, //call this metafunction T >::type resolved_type; //this is what we want to use //Here I am confused of how to conditionally construct a type of default_type::type to pass in? // I thought it might help to have a default_type.construct function but wasn't sure what to do? //Note that T is often too large to do a full 'copy'. It won't be an int. //Pass in t directly or a constructed version of resolved_type if T if 'default'? return my_class<resolved_type>( ...); } The usage I would like to enable: auto m1 = make_myclass(); //Uses the default auto m2 = make_myclass( default_tag() ); //Uses the default as well. Why do I need this? Will actually have a number of these tags where you may want to conditionally choose some as defaults. int n = 5; auto m3 = make_myclass(n); Any ideas on the best idioms to support this and get around the template argument detection problems? Is this possible? If not, can I drop the need for the make_myclass(); usage and still keep the ability to call with a default and conditionally constructs the default object based ont eh type of a metafunction? Thanks, Jesse