My variadic templated constructor hides copy constructor, preventing the class to be copied

Question

I made a Vector class. I was happy with it, it's kinda weird but it seemed to work at the start. But I just found out copying the vectors is impossible.

The reason is that to allow the number of coordinates to be a template, there is a templated variadic constructor which expects the right number of coordinates.

This is what it looks like, with the utility math methods removed:

template 
class Vector
{
public:
  using CoordType = NumType;

  //Vector(const Vector& v) : values(v.values) {}
  //Vector(Vector&& v) : values(std::move(v.values)) {}

  template
  constexpr Vector(NumTypes&&... vals) : values{ std::forward(vals)... }
  {
    static_assert(sizeof...(NumTypes) == Size, "You must provide N arguments.");
  }

  Vector(const std::array& values) : values(values) {}
  Vector(std::array&& values) : values(std::move(values)) {}

  const NumType& operator[](size_t offset) const { return values[offset]; }
  NumType& operator[](size_t offset) { return values[offset]; }
  //Vector& operator=(const Vector& other) { values = other.values; }
  //Vector& operator=(Vector&& other) { values = std::move(other.values); }

  std::array values;

};

As you can see - now commented out - I did try to implement copy and move and assignment operations manually. It had no effect, the error is always along the lines of:

cannot convert ‘Vector’ to ‘int’ in initialization

This is because it is still trying to use the variadic constructor, instead of the copy constructor.

Here is a full ~~working~~ broken sample: https://ideone.com/Jz86vP

user_2684539 · Answer

You might:

SFINAE your variadic constructor, for example:

template ::value,
                          int> = 0>
constexpr Vector(NumTypes&&... vals) : values{ std::forward(vals)... }
{
}

Note: std::conjunction is C++17, but can be done in C++14.

or prepend a tag:

template 
constexpr Vector(struct SomeTag, NumTypes&&... vals) :
    values{ std::forward(vals)... }
{
}

or redesign the class, for example, something like:

template 
using always_type = T;

template  class VectorImpl;

template 
class VectorImpl>
{
public:
  using CoordType = NumType;

  VectorImpl(const VectorImpl&) = default;
  VectorImpl(VectorImpl&&) = default;
  VectorImpl& operator=(const VectorImpl&) = default;
  VectorImpl& operator=(VectorImpl&&) = default;

  constexpr VectorImpl(always_type... vals) : values{ std::forward(vals)... }
  {
  }

  VectorImpl(const std::array& values) : values(values) {}
  VectorImpl(std::array&& values) : values(std::move(values)) {}

  const NumType& operator[](size_t offset) const { return values[offset]; }
  NumType& operator[](size_t offset) { return values[offset]; }

  std::array values;
};

template 
using Vector = VectorImpl>;

Demo

My variadic templated constructor hides copy constructor, preventing the class to be copied

1 Answers