C++ 将参数包传递给类

Question

I'd like to have a class that gets in it's Ctor unlimited parameters of the same type, and stores them into a vector. It should look like that:

class A(int a, int b, **N time parameter of type T**)
: data(**vector will get N times type T**)
{
}

protected:
vector<T> data;

How should I implement it? Solution could be in c++11/14 I got a few errors such as "parameter packs not expanded with '…' ", etc..

Answer 1

This code sample might be useful:

#include <vector>
#include <utility>

template<typename T>
class MyClass {
public:
    template<typename ...Args>
    MyClass(int a, int b, Args&& ...args) :data{ std::forward<Args>(args)... } {}
private:
    std::vector<T> data;
};

int main() {
    MyClass<char> sample(1, 2, 'a', 'b');
    return 0;
}

[EDIT]: Added std::forward, added missing include for utility

Answer 2

Assuming that T could be anything, even something quite large or non-copyable, we'd want to:

1. preserve efficiency with perfect forwarding.

2. check types.

std::initializer_list satisfies 2 but not 1.

Simple variadic template expansion satisfies 1 and not 2.

This solution uses variadic template expansion and enable_if to enforce type compatibility.

#include <vector>
#include <utility>
#include <string>


namespace detail
{
    constexpr bool all()
    {
        return true;
    }

    template<class...Rest>
    constexpr bool all(bool b, Rest...rest)
    {
        return b and all(rest...);
    };

}


template<class T>
class A
{
public:
    using value_type = T;  // say

    template<class...Rest,
            std::enable_if_t<detail::all(std::is_convertible<Rest, value_type>::value...)>* = nullptr>
    A(int a, int b, Rest&&...rest)
            : a_(a), b_(b)
    {
        this->fill(std::forward_as_tuple(std::forward<Rest>(rest)...),
                   std::make_index_sequence<sizeof...(Rest)>());
    }

private:
    template<class Tuple, std::size_t...Is>
    void fill(Tuple&& t, std::index_sequence<Is...> seq)
    {
        data_.reserve(seq.size());
        using expand = int[];
        void(expand{ 0,
                     (data_.push_back(std::move(std::get<Is>(t))), 0)...
        });
    }
private:
    int a_, b_;
    std::vector<value_type> data_;
};


int main()
{
    using namespace std::literals;

    auto a = A<double>(1, 2, 4.3, 5.5, 6.6);

    auto b = A<std::string>(1, 2, "the", "cat"s, "sat on the mat");

    // error: no matching constructor...
//    auto err = A<std::string>(1, 2, "the", "cat"s, 0.1);

}

Answer 3

Here you go:

#include <iostream>
#include <vector>

template<class T>
struct V
{
    V(int n, std::initializer_list<T> l)
        : data(l)
    {
        (void) n;
    }

    std::vector<T> data;
};

int main()
{
    V<int> v(0,{1,2,3});
}

This is not a perfect example since one needs to construct an object with the weird syntax (n, {optional, arguments, of, same, type}) but it does provide wanted behavior.

Answer 4

The following example is similar to fr3nzy90's, but with the coming C++17 it will allow automatic deduction of T from the constructor arguments:

template <class T>
class MyContainer {
    private:
    std::vector<T> data;

    public:
    // Take the first T value explicitly so it can be used to deduce
    // T from the constructor arguments (C++17 feature).
    template <class... Ts>
    MyContainer(int a, int b, T const & tval, Ts const &... tvals) :
      data{tval, tvals...} {
        …
    }

    // Special case, empty list, no implicit type deduction, because
    // there is no T value to deduce it from.
    MyContainer(int a, int b) {
        …
    }
};