C++ 如何为包装容器的模板类编写构造函数，其中容器可以是数组或向量？

我希望有一个通用模板类，允许用户传递容器以使用：

template<class Container>
struct Sum
{
  Container m_terms;
...

这将需要添加以下构造函数：

template<class Container>
struct Sum
{
  Container m_terms;

  Sum(std::initializer_list<typename Container::value_type> const& il) :
    m_terms(il) { }
...

模板
结构和
{
集装箱运输术语；
总和（标准：：初始值设定项\u列表常数和il）：
m_项（il）{}
...

class MySum:public Sum
{
使用Sum：：Sum；
...

但是我怎样才能让MySum4也工作呢？

数组

不需要

std:：initializer\u列表

下面是显示编译器错误的更完整代码：

---

如何使用旧的C样式数组和委托构造函数

如下

  template <typename T, std::size_t N, std::size_t ... Is>
  Sum (T const (& il)[N], std::index_sequence<Is...> const)
        : m_terms{{il[Is]...}}
   { }

  template <typename T, std::size_t N>
  Sum (T const (& il)[N]) : Sum(il, std::make_index_sequence<N>{})
   { }

模板
求和（T常量（&il）[N]，标准：：索引\序列常量）
：m_项{{il[Is]…}
{ }
模板
Sum（T const（&il）[N]）：Sum（il，std:：make_index_sequence{}）
{ }

但是你必须加上几个括号来称呼它

struct MySum : Sum<std::vector<int>>
{
  MySum(int t0, int t1, int t2, int t3) : Sum<std::vector<int>>{{t0, t1, t2, t3}} { }
}; // ..........................................................^..............^

struct MySum4 : Sum<std::array<int, 4>>
{
  MySum4(int t0, int t1, int t2, int t3) : Sum<std::array<int, 4>>{{t0, t1, t2, t3}} { }
}; // .............................................................^..............^

struct MySum:Sum
{
MySum（intt0，intt1，intt2，intt3）：和{{t0，t1，t2，t3}{}
}; // ..........................................................^..............^
结构MySum4:Sum
{
MySum4（intt0，intt1，intt2，intt3）：和{{t0，t1，t2，t3}{}
}; // .............................................................^..............^

另一种方法是为ctor

Sum:：Sum

应用带双大括号的变量模板，如下所示。 这个双括号使我们能够将

容器设置为
std:：array
：

template<typename Container>
struct Sum
{
  Container m_terms;

  template<typename ...Args>
  Sum(Args&&... args) : m_terms{{std::forward<Args>(args)...}} { }

  void print()
  {
      for (auto&& term : m_terms){
        std::cout << ' ' << term;
      }

      std::cout << std::endl;
  }
};

模板
结构和
{
集装箱运输术语；
模板
求和（Args&…Args）：m_项{{std:：forward

struct MySum:Sum
{
MySum（intt0，intt1，intt2，intt3）：和{t0，t1，t2，t3}{}
};
结构MySum4:Sum
{
MySum4（intt0，intt1，intt2，intt3）：和{t0，t1，t2，t3}{
};
结构MySumSet:Sum
{
MySumSet（intt0，intt1，intt2，intt3）：和{t0，t1，t2，t3}{
};
结构MySumList:Sum
{
MySumList（intt0，intt1，intt2，intt3）：和{t0，t1，t2，t3}{}
};
int main（）
{  
糠秕肌s（1,2,3,4）；
s、 打印（）；
mysum4s4（1,2,3,4）；
s4.打印（）；
静态_断言（s4.m_terms.size（）=4）；
MySumSet ss（1,2,3,4）；
ss.print（）；
mysumlistsl（1,2,3,4）；
sl.print（）；
}
为了完整性，我想用一种我后来才意识到的方法来回答我自己的问题；也就是说，只需允许调用方将容器（它知道其类型）作为右值传递。让我惊讶的是，当传递双括号时，这将适用于所有容器

struct Sum
{
  Container m_terms;

  Sum(Container&& terms) : m_terms(std::move(terms)) { }

  void print()
  {
    for (auto&& term : m_terms)
      std::cout << ' ' << term;
    std::cout << std::endl;
  }
};

struct Sum
{
集装箱运输术语；
总和（容器和术语）：m_术语（std:：move（术语））{}
作废打印（）
{
用于（自动和术语：m_术语）
std：：cout“其他类将从中派生”不要这样做。只需让它们成为成员。避免深入inheritance@NicolBolas在过去的两周里，我已经有了它，但是Sum类有六个虚拟函数需要访问容器（以及它存储的类型）。它变得非常混乱；通过将容器移动到基类，我的代码得到了极大的清理-除了两个派生类使用数组的一个问题。C++11或C++17？在C++17中，聚合初始化使这变得轻而易举。基和类型是什么？派生的mysum/mysum4类型是什么？您真的在传递吗nd
Sum
指针，其派生类型为
MySum
，在其他情况下它是
MyOtherSum
？令人印象深刻…给我一天时间来消化这一点（现在必须运行到国际象棋比赛，然后先睡觉）。不过已经在wandbox中测试过了，并且它可以工作：）。
  template <typename T, std::size_t N, std::size_t ... Is>
  Sum (T const (& il)[N], std::index_sequence<Is...> const)
        : m_terms{{il[Is]...}}
   { }

  template <typename T, std::size_t N>
  Sum (T const (& il)[N]) : Sum(il, std::make_index_sequence<N>{})
   { }

struct MySum : Sum<std::vector<int>>
{
  MySum(int t0, int t1, int t2, int t3) : Sum<std::vector<int>>{{t0, t1, t2, t3}} { }
}; // ..........................................................^..............^

struct MySum4 : Sum<std::array<int, 4>>
{
  MySum4(int t0, int t1, int t2, int t3) : Sum<std::array<int, 4>>{{t0, t1, t2, t3}} { }
}; // .............................................................^..............^

template<typename Container>
struct Sum
{
  Container m_terms;

  template<typename ...Args>
  Sum(Args&&... args) : m_terms{{std::forward<Args>(args)...}} { }

  void print()
  {
      for (auto&& term : m_terms){
        std::cout << ' ' << term;
      }

      std::cout << std::endl;
  }
};

struct MySum : Sum<std::vector<int>>
{
    MySum(int t0, int t1, int t2, int t3) : Sum<std::vector<int>>{t0, t1, t2, t3} { }
};

struct MySum4 : Sum<std::array<int, 4>>
{
    MySum4(int t0, int t1, int t2, int t3) : Sum<std::array<int, 4>>{t0, t1, t2, t3} { }
};

struct MySumSet : Sum<std::set<int>>
{
    MySumSet(int t0, int t1, int t2, int t3) : Sum<std::set<int>>{t0, t1, t2, t3} { }
};

struct MySumList : Sum<std::list<int>>
{
    MySumList(int t0, int t1, int t2, int t3) : Sum<std::list<int>>{t0, t1, t2, t3} { }
};

int main()
{  
    MySum s(1, 2, 3, 4);
    s.print();

    MySum4 s4(1, 2, 3, 4);
    s4.print();
    static_assert(s4.m_terms.size() == 4);

    MySumSet ss(1, 2, 3, 4);
    ss.print();

    MySumList sl(1, 2, 3, 4);
    sl.print();
}

struct Sum
{
  Container m_terms;

  Sum(Container&& terms) : m_terms(std::move(terms)) { }

  void print()
  {
    for (auto&& term : m_terms)
      std::cout << ' ' << term;
    std::cout << std::endl;
  }
};

struct MySum : Sum<std::vector<int>>
{
  MySum(int t0, int t1, int t2, int t3) : Sum<std::vector<int>>{{t0, t1, t2, t3}} { }
};

struct MySum4 : Sum<std::array<int, 4>>
{
  MySum4(int t0, int t1, int t2, int t3) : Sum<std::array<int, 4>>{{t0, t1, t2, t3}} { }
};

struct MySumSet : Sum<std::set<int>>
{
    MySumSet(int t0, int t1, int t2, int t3) : Sum<std::set<int>>{{t0, t1, t2, t3}} { }
};

struct MySumList : Sum<std::list<int>>
{
    MySumList(int t0, int t1, int t2, int t3) : Sum<std::list<int>>{{t0, t1, t2, t3}} { }
};

int main()
{  
    MySum s(1, 2, 3, 4);
    s.print();

    MySum4 s4(1, 2, 3, 4);
    s4.print();
    static_assert(s4.m_terms.size() == 4);

    MySumSet ss(1, 2, 3, 4);
    ss.print();

    MySumList sl(1, 2, 3, 4);
    sl.print();
}