Resolving C++ constructor & call ambiguity - c++

Question

I have a nice and small jack-of-all trades Array type that fits all my needs until now.
template <typename T>
class Array
{
...
public:
int Data; // custom value
virtual void InitData() { Data = 0; }
Array(const Array& array);
template <typename U, typename = std::enable_if<std::is_same<U, T>::value, U>> Array(const Array<U>& array);
template <typename... Ts> Array(const Ts&... items);
void Add(const T& item);
template <typename... Ts> void Add(const T& item, const Ts&... rest);
void Add(const Array& array);
}
The template <typename... Ts> Array(const Ts&... items); lets me do Array<T> array = { ... }, and to assign and return {...} initializer lists. Because none of the constructors are explicit, it is incredibly convenient, but is also the reason I'm stuck now.
I would like to be able to add anything "reasonable" to the arrays. My main use case right now is:
using Curve = Array<float2>;
class Poly : public Array<float2> { using Array::Array; void InitData() override { Data = 1; } };
class Curve2 : public Array<float2> { using Array::Array; void InitData() override { Data = 2; } };
class Curve3 : public Array<float2> { using Array::Array; void InitData() override { Data = 3; } };
The std::is_same<> stuff above is specifically to be able to treat all the curves as the same but not the same: the curve types of different degree, and everything is nicely "statically typed", so all I do in a function like DrawCurve(const Curve&) is check the degree and then take appropriate action. Curve is a nice alias for Array, and Curve2 etc. are degree specializations. It works very nicely.
When I get into curve construction, I usually have a curve object, to which I add either points or curve segments. So I'd like to be able to do:
Curve3 curve;
curve.Add(float2()); // ambiguity
curve.Add(Array<float2>());
Unfortunately, I get an ambiguity here when I call add, because Add() will take either a float2 or an Array<float2>, which works fine, but an Array has the implicit constructor template <typename... Ts> Array(const Ts&...), which can take float2 as an argument. So the ambiguity is between
Array::Add(float2()); // and
Array::Add(Array<float2>(float2()));
I have tried making constructors that take arrays explicit, like
template <typename A, typename = std::enable_if<std::is_same<A, Array>::value, A>>
void Add(const Array& array);
But then I get new conversion errors from Curve3 to float2 etc. and it becomes a mess.
My hope is that somewhere in the depths of templates or other C++ goodies lies a simple solution that is just what I need. (Yes, I know that I can just rename the methods ::AddItem() and ::AddArray() and the problem will be over in a second, but I don't want this because eventually I want to double all this with += and then mostly just use that.
Any ideas?

Answer 1

Observe that you want
template <typename... Ts> Array(const Ts&... items);
to be used only if the parameter pack contains at least one item, and that item's type is not an Array template instance. If the parameter pack is empty, this becomes a default constructor, so let's handle this case separately. Go ahead and explicitly define a default constructor, if you need to, and have it do what it needs to do; now we can eliminate that possibility from this use case, and forge ahead.
Having gotten that out of the way, what you want to do here is to use this constructor only when it has one argument:
template <typename T1, typename... Ts> Array(const T1 &t1, const Ts&... items);
You will have to modify this constructor to use the explicit t1, in addition to the existing parameter pack it uses. That should be simple enough, but that won't be sufficient. There's still ambiguity. You want to have this constructor selected only if T1 is not an Array.
There's probably a way to come up with something convoluted and stuff it into a single std::enable_if, and shove it into this template. But for clarity, and simplicity, I would use a helper class:
template<typename T> class is_not_array : public std::true_type {};
template<typename T>
class is_not_array<Array<T>> : public std::false_type {};
And then add a simple std::enable_if into this constructor's template to use SFINAE to select this constructor only when its first template parameter is not an Array, similar to how you're using std::enable_if already, in the other constructor.
This should resolve all ambiguities. This constructor should then be picked only with at least one template parameter that's not an Array, with the assistance of this helper class. When it's an Array, this constructor will not be resolvable, and that case will go to the other constructor.
I would also suggest using universal references in the templates, instead of const T &s.