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_, //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_,
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( ...);
}
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
