C++ STL向量数组中类的初始化

我想知道是否有可能在一条“线”内的向量数组中初始化一组类

A类{
公众：
A（int k）{…}
};
[...]
#包括
#包括
使用名称空间std；
数组={A（5），A（6）}，{A（1），A（2），A（3）}，{}；

---

你可以想象这个解决方案不起作用（否则我就不会在这里了！）。最快的方法是什么？

我认为应该允许这样做：

#include <array>
#include <vector>
using namespace std;

class A {
     public:
         A(int k) {}
};

array<vector<A>, 3> v = { vector<A>{5, 6}, vector<A>{1, 2, 3}, vector<A>{} };

#包括
#包括
使用名称空间std；
甲级{
公众：
A（int k）{}
};
数组v={vector{5,6}，vector{1,2,3}，vector{}；

---

在一个快速测试中，g++4.7.1似乎同意了这一点。

这样做了，无需重复提到

a

：

array<std::vector<A>, 3> v{{ {1}, {2,3,4}, {} }};

数组v{{{{1}、{2,3,4}、{}}；

如果构造函数接受两个参数，则将它们写在大括号中：

array<std::vector<A2>, 3> v2{{ {{1,2}}, {{2,3},{4,5},{8,9}}, {} }};

数组v2{{{{{1,2}}、{{2,3}、{4,5}、{8,9}、{}；

我可能更喜欢下面的语法，如果构造函数是显式的，它也可以工作

std::array<std::vector<A2>, 3> v2{{ {A2{1,2}}, {A2{2,3},A2{4,5},A2{8,9}}, {} }};  

std:：数组v2{{A2{1,2}，{A2{2,3}，A2{4,5}，A2{8,9}，{}；

完整示例：

#include <array>
#include <vector>
#include <iostream>

struct A2 {
  A2(int k,int j) : mk(k),mj(j) {}
  int mk;
  int mj;
};

int main (){
  std::array<std::vector<A2>, 3> v2{{ {{1,2}}, {{2,3},{4,5},{8,9}}, {} }};  
  int i=0;
  for (auto &a : v2){
    std::cout << "... " << i++ <<std::endl;
    for (auto &b : a){
      std::cout << b.mk << " " <<b.mj <<std::endl;
    }
  }
}

#包括
#包括
#包括
结构A2{
A2（intk，intj）：mk（k），mj（j）{}
int mk；
int-mj；
};
int main（）{
数组v2{{{{1,2}}，{{2,3}，{4,5}，{8,9}，{}；
int i=0；
用于（自动&a:v2）{
如果构造函数有多个参数怎么办？
#include <array>
#include <vector>
#include <iostream>

struct A2 {
  A2(int k,int j) : mk(k),mj(j) {}
  int mk;
  int mj;
};

int main (){
  std::array<std::vector<A2>, 3> v2{{ {{1,2}}, {{2,3},{4,5},{8,9}}, {} }};  
  int i=0;
  for (auto &a : v2){
    std::cout << "... " << i++ <<std::endl;
    for (auto &b : a){
      std::cout << b.mk << " " <<b.mj <<std::endl;
    }
  }
}