如何写一个“"；列表<；int[，]>&引用；在C++；？ 我试图做一个C++代码的C++代码，主要是因为我遵循C语言的教程，而且我更喜欢使用C++。我的思考过程可能是制作一个外部数组，然后将一个新数组分配到表示矩阵大小的每个索引中。这是好的还是在C++中实现这个更好的方法？ // current C# code List<int[,]> pieces; pieces = new List<int[,]>(); /* I Piece */ pieces.Add(new int[4, 4] { {0, 0, 0, 0}, {1, 1, 1, 1}, {0, 0, 0, 0}, {0, 0, 0, 0} }); /* J Piece */ pieces.Add(new int[3, 3] { {0, 0, 1}, {1, 1, 1}, {0, 0, 0} }); /* O Piece */ pieces.Add(new int[2, 2] { {1, 1}, {1, 1} }); /* S Piece */ pieces.Add(new int[3, 3] { {0, 1, 1}, {1, 1, 0}, {0, 0, 0} }); /* T Piece */ pieces.Add(new int[3, 3] { {0, 1, 0}, {1, 1, 1}, {0, 0, 0} }); /* Z Piece */ pieces.Add(new int[3, 3] { {1, 1, 0}, {0, 1, 1}, {0, 0, 0} });

请尝试

std:：list

或按建议尝试

std:：vector

这里有一个关于向量的完整示例，但是请记住，您必须这样编译：

g++-std=c++0x t.cpp

#include <vector>
#include <iostream>

using namespace std;

int main()
{
    vector<vector<vector<int>>> A = {
      {
        {0, 0, 0, 0},
        {1, 1, 1, 1},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
      },
      {
        {0, 0, 1},
        {1, 1, 1},
        {0, 0, 0}
      },
      {
        {1, 1},
        {1, 1}
      },
      {
        {0, 1, 1},
        {1, 1, 0},
        {0, 0, 0}
      },
      {
        {0, 1, 0},
        {1, 1, 1},
        {0, 0, 0}
      },
      {
        {1, 1, 0},
        {0, 1, 1},
        {0, 0, 0}
      }
    };


    for(int i=0;i<A.size();i++) {
      for(int j=0;j<A[i].size();j++) {
        for(int k=0;k<A[i][j].size();k++) {
          std::cout<<A[i][j][k];
        };
        std::cout<<std::endl;
      };
      std::cout<<std::endl;
    };
}

请尝试

std:：list

或按建议尝试

std:：vector

这里有一个关于向量的完整示例，但是请记住，您必须这样编译：

g++-std=c++0x t.cpp

#include <vector>
#include <iostream>

using namespace std;

int main()
{
    vector<vector<vector<int>>> A = {
      {
        {0, 0, 0, 0},
        {1, 1, 1, 1},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
      },
      {
        {0, 0, 1},
        {1, 1, 1},
        {0, 0, 0}
      },
      {
        {1, 1},
        {1, 1}
      },
      {
        {0, 1, 1},
        {1, 1, 0},
        {0, 0, 0}
      },
      {
        {0, 1, 0},
        {1, 1, 1},
        {0, 0, 0}
      },
      {
        {1, 1, 0},
        {0, 1, 1},
        {0, 0, 0}
      }
    };


    for(int i=0;i<A.size();i++) {
      for(int j=0;j<A[i].size();j++) {
        for(int k=0;k<A[i][j].size();k++) {
          std::cout<<A[i][j][k];
        };
        std::cout<<std::endl;
      };
      std::cout<<std::endl;
    };
}

---

在我看来，向量的向量对于这样一个简单的构造来说似乎有点麻烦

我可能会假设所有的东西都是4x4的，最大的尺寸，只需将碎片嵌入其中，在这种情况下，你就可以

#include <vector>
struct Piece { int v[4][4]; };
std::vector<Piece> pieces { 
     // I piece
     { {
        {0,0,0,0},
        {1,1,1,1},
        {0,0,0,0},
        {0,0,0,0}
     } },
     // J piece
     { {
       {0, 0, 1},  // This is OK since extra element will be 0 initialised by default.
       {1, 1, 1},
       {0, 0, 0}
       // Dont need a row here either as it will be 0 initialised.
     } }
     //Others omitted for now..
  };

#包括
结构件{intv[4][4]；}；
std:：向量块{
//我一块
{ {
{0,0,0,0},
{1,1,1,1},
{0,0,0,0},
{0,0,0,0}
} },
//J片
{ {
{0，0，1}，//这是可以的，因为默认情况下，额外的元素将初始化为0。
{1, 1, 1},
{0, 0, 0}
//这里也不需要行，因为它将被初始化为0。
} }
//其他的暂时省略了。。
};

或对于不符合C++11的编译器：

#include <vector>
struct Piece { int v[4][4]; };
Piece raw_pieces[] = {
     { {
        {0,0,0,0},
        {1,1,1,1},
        {0,0,0,0},
        {0,0,0,0}
     } },
     { {
       {0, 0, 1},  // This is OK since extra element will be 0 initialised by default.
       {1, 1, 1},
       {0, 0, 0}
       // Dont need a row here either as it will be 0 initialised.
     } }
};


std::vector<Piece> pieces(raw_pieces, raw_pieces + sizeof(raw_pieces)/sizeof(Piece));

#包括
结构件{intv[4][4]；}；
每件未加工的(每件){
{ {
{0,0,0,0},
{1,1,1,1},
{0,0,0,0},
{0,0,0,0}
} },
{ {
{0，0，1}，//这是可以的，因为默认情况下，额外的元素将初始化为0。
{1, 1, 1},
{0, 0, 0}
//这里也不需要行，因为它将被初始化为0。
} }
};
标准：：向量块（原始块，原始块+sizeof（原始块）/sizeof（块））；

对于这样一个简单的构造，向量的向量似乎有点麻烦

我可能会假设所有的东西都是4x4的，最大的尺寸，只需将碎片嵌入其中，在这种情况下，你就可以

#include <vector>
struct Piece { int v[4][4]; };
std::vector<Piece> pieces { 
     // I piece
     { {
        {0,0,0,0},
        {1,1,1,1},
        {0,0,0,0},
        {0,0,0,0}
     } },
     // J piece
     { {
       {0, 0, 1},  // This is OK since extra element will be 0 initialised by default.
       {1, 1, 1},
       {0, 0, 0}
       // Dont need a row here either as it will be 0 initialised.
     } }
     //Others omitted for now..
  };

#包括
结构件{intv[4][4]；}；
std:：向量块{
//我一块
{ {
{0,0,0,0},
{1,1,1,1},
{0,0,0,0},
{0,0,0,0}
} },
//J片
{ {
{0，0，1}，//这是可以的，因为默认情况下，额外的元素将初始化为0。
{1, 1, 1},
{0, 0, 0}
//这里也不需要行，因为它将被初始化为0。
} }
//其他的暂时省略了。。
};

或对于不符合C++11的编译器：

#include <vector>
struct Piece { int v[4][4]; };
Piece raw_pieces[] = {
     { {
        {0,0,0,0},
        {1,1,1,1},
        {0,0,0,0},
        {0,0,0,0}
     } },
     { {
       {0, 0, 1},  // This is OK since extra element will be 0 initialised by default.
       {1, 1, 1},
       {0, 0, 0}
       // Dont need a row here either as it will be 0 initialised.
     } }
};


std::vector<Piece> pieces(raw_pieces, raw_pieces + sizeof(raw_pieces)/sizeof(Piece));

#包括
结构件{intv[4][4]；}；
每件未加工的(每件){
{ {
{0,0,0,0},
{1,1,1,1},
{0,0,0,0},
{0,0,0,0}
} },
{ {
{0，0，1}，//这是可以的，因为默认情况下，额外的元素将初始化为0。
{1, 1, 1},
{0, 0, 0}
//这里也不需要行，因为它将被初始化为0。
} }
};
标准：：向量块（原始块，原始块+sizeof（原始块）/sizeof（块））；

是的，但我尝试了vector，结果导致了一些…混乱的代码，没有按照我希望的方式工作。我用我想到的代码进行了编辑。当然，它不想那样工作。是的，但我尝试了vector，它导致了一些…混乱的代码，没有按照我想要的方式工作。用我想到的代码编辑。当然，它不希望这样工作。C#的列表实际上更像C++的std:：vector（它是一个连续数组，而不是一个链表），所以应该是

vector

。丑陋，但它是有意义的。不幸的是，您给出的代码在初始化阶段需要一个表达式，这意味着它的设置有问题。如果使用（迭代）该向量（向量向量向量向量的向量…）的代码对性能敏感，这是一个糟糕的解决方案。你会像兔子一样在内存中跳跃。@C或者看到我的更新了吗？#的列表实际上更像C++的std:：vector（它是一个连续数组，而不是一个链表），所以它应该是

vector

。很难看，但它是有意义的。不幸的是，你给出的代码在初始化阶段需要一个表达式，这意味着它的设置有问题。如果使用（迭代）该向量（向量向量向量向量的向量…）的代码对性能敏感，这是一个糟糕的解决方案。您将像兔子一样在内存中跳跃。@Cdore查看我的更新请家长们注意，visual studio引用的矩阵类型的向量不允许使用{}初始化。您是正确的-我已通过将数组包装到可构造的副本和{}中来更新我的答案初始化结构。你可以看到它在C++11编译器上编译：我只是不知道为什么它不工作，即使你做了修复。可能有一些我不知道的编译器更新。可能是您没有启用C++11模式（或者C++11中对这些功能的VS支持不够）。如果需要，您总是可以逐段构建向量，但语法不会那么好。显然，visual studio引用的矩阵类型的向量不允许使用{}初始化。您是正确的-我已通过将数组包装到可构造的{}副本中来更新我的答案初始化结构。你可以看到它在C++11编译器上编译：我只是不知道为什么它不工作，即使你做了修复。可能有一些我不知道的编译器更新。可能是您没有启用C++11模式（或者C++11中对这些功能的VS支持不够）。如果需要的话，您总是可以一块一块地构建向量，但是语法不会那么好。