Variadic Constructor Parameter List of Unknown Types

Question

Suppose I have a class designed to represent a typical mathematical vector in any dimension. I would like to design this class such that its constructor takes any number of arguments, converts those arguments to long double type and then inserts them into the "point_list" vector in the same order they were provided in the parameter list.

class Pvector
{
  private:
  std::vector<long double> point_list;

  public:
  // some magic constructor here
};

Now, if all of the parameters were of the same type, this wouldn't be difficult since I could just use an initialization list. But the problem is that any of the parameters could be of differing types, and this still needs to accepts any number of parameters (at least one). Essentially, I'm trying to be able to use the constructor like this:

int i;
float j;
double k;
long double l;

Pvector vec1(i, j, k, l);
Pvector vec2(k-i, 5, j);
Pvector vec3(i, i, j, j, k, k, l, l);
etc...

I'm just not sure if it's possible to have a variadic constructor accepting multiple types and then implicitly converting them into long doubles before inserting them into the vector. Is it possible to achieve this, or will all of my parameters have to be the same type if I want a variadic constructor?

Answer 1

You could do it like this:

class Pvector
{
public:
  template <typename ...Ts>
  Pvector(Ts && ...ts)
  {
    point_list.reserve(sizeof...(Ts));
    init(std::forward<Ts>(ts)...);
  }

protected:
private:
  void init() { };

  template <typename ...Ts>
  void init(long double x, Ts && ...ts)
  {
    point_list.push_back(x);
    init(std::forward<Ts>(ts)...);
  }

  std::vector<long double> point_list;
};

Answer 2

You might write a template constructor (which is trickier that one can expect to avoid to match things like Pvector(Pvector&).

class Pvector
{
private:
  std::vector<long double> point_list;

public:
    Pvector() = default;

    Pvector(const Pvector&) = default;
    Pvector(Pvector&&) = default;

    // // SFINAE to avoid to match Pvector(Pvector& t)
    template <typename T,
              typename ... Ts,
              std::enable_if_t<std::is_constructible<std::vector<long double>, T, Ts...>::value
                           && (!std::is_same<Pvector, std::decay_t<T>>::value
                              || sizeof...(Ts) != 0)>* = nullptr>
    Pvector(T&& t, Ts&&... ts) 
    : point_list{t, ts...} {}
    };

But it would be simpler to just take the vector as parameter

class Pvector
{
private:
  std::vector<long double> point_list;

public:
    Pvector() = default;

    Pvector(const Pvector&) = default;
    Pvector(Pvector&&) = default;

    Pvector(std::vector<long double>&& v) : point_list(std::move(v)) {}
};

and call it with extra { }

Pvector vec3({i, i, j, j, k, k, l, l});