D

#### Daryle Walker

cross-version converting constructor template being split into two,

and implicit one and an explicit one.

template < typename T, unsigned L >

class my_type

{

public:

my_type() = default;

//...

template < typename U, unsigned M >

my_type( my_type<U, M> const &other );

template < typename V, unsigned N >

explicit my_type( my_type<V, N> const &other );

};

For the first constructor template, I have a mathematical formula

connecting M and L that states which values of M should activate this

constructor. The second constructor template should match any value

of N that doesn't match the formula. Can the std::enable_if template,

probably as a defaulted hidden constructor parameter, in either

constructor template (or both), help here?

I'm also thinking about variadic arguments. That first constructor

template is more like:

template < unsigned M, typename U0, typename ...U >

my_type( my_type<U0, M> const &other0, my_type<U..., M> const

&other );

It's a list of elements, where I mandated that the list must have at

least one element so it won't be confused with the default

constructor. (If I allowed zero arguments, there would be no way to

specify M! Constructor templates must imply ALL template

parameters.) Do I have the syntax right? How would I actually write

the implementation code? I guess I would need some kind of private

helper function....

Let's say that the formula is that M must be a divisor of L (and

neither can be zero). Is there any way at compiler-time to limit the

maximum number of constructor elements? Or do I have to throw an

exception when I find out I went over during runtime? (The count will

include that one mandatory argument. If M == L, then that mandatory

argument must be the sole argument and there should be zero variadic

arguments.)

Daryle W.