C++ 填写C++；二维对象数组

我有一个关于

std:：fill

的简单问题

首先，我定义一个二维成对数组

const int NMAX = 13;                                                             
typedef pair<int, set<int>> solution;                                            
solution memo[NMAX][NMAX];    

---

但是我遇到了一个总线错误。。。我做错了什么

您的结束指针错误，您的意思是：

std::fill(&memo[0][0], &memo[0][0] + sizeof(memo) / sizeof (solution), s);

---

由于

sizeof（memo）

是

NMAX*NMAX*sizeof（solution）

您的结束指针错误，您的意思是：

std::fill(&memo[0][0], &memo[0][0] + sizeof(memo) / sizeof (solution), s);

---

由于

sizeof（memo）

是

NMAX*NMAX*sizeof（solution）

您的结束指针错误，您的意思是：

std::fill(&memo[0][0], &memo[0][0] + sizeof(memo) / sizeof (solution), s);

---

由于

sizeof（memo）

是

NMAX*NMAX*sizeof（solution）

您的结束指针错误，您的意思是：

std::fill(&memo[0][0], &memo[0][0] + sizeof(memo) / sizeof (solution), s);

---

由于

sizeof（memo）

是

NMAX*NMAX*sizeof（solution）

实际上，我们可以通过

std:：vector

轻松地完成所有这一切：

typedef pair<int, set<int>> solution; 
solution s;                                                                  
s.first = -1;
std::vector<std::vector<solution>> memo(NMAX, std::vector<solution>(NMAX, s));

编辑2:如果你真的是受虐狂并且想自己计算[row][column]索引，那么你可以使用一个

std:：array

并利用

std:：begin（）

和

std:：end（）

调用

std:：fill

：

std::array<solution, NMAX*NMAX> memo;
solution s;                                                                  
s.first = -1;
std::fill(std::begin(memo),std::end(memo), s);

std:：数组备忘录；
溶液s；
s、 第一个=-1；
标准：：填充（标准：：开始（备忘录），标准：：结束（备忘录），s）；

---

实际上，使用

std:：vector

:

typedef pair<int, set<int>> solution; 
solution s;                                                                  
s.first = -1;
std::vector<std::vector<solution>> memo(NMAX, std::vector<solution>(NMAX, s));

编辑2:如果你真的是受虐狂并且想自己计算[row][column]索引，那么你可以使用一个

std:：array

并利用

std:：begin（）

和

std:：end（）

调用

std:：fill

：

std::array<solution, NMAX*NMAX> memo;
solution s;                                                                  
s.first = -1;
std::fill(std::begin(memo),std::end(memo), s);

std:：数组备忘录；
溶液s；
s、 第一个=-1；
标准：：填充（标准：：开始（备忘录），标准：：结束（备忘录），s）；

---

实际上，使用

std:：vector

:

typedef pair<int, set<int>> solution; 
solution s;                                                                  
s.first = -1;
std::vector<std::vector<solution>> memo(NMAX, std::vector<solution>(NMAX, s));

编辑2:如果你真的是受虐狂并且想自己计算[row][column]索引，那么你可以使用一个

std:：array

并利用

std:：begin（）

和

std:：end（）

调用

std:：fill

：

std::array<solution, NMAX*NMAX> memo;
solution s;                                                                  
s.first = -1;
std::fill(std::begin(memo),std::end(memo), s);

std:：数组备忘录；
溶液s；
s、 第一个=-1；
标准：：填充（标准：：开始（备忘录），标准：：结束（备忘录），s）；

---

实际上，使用

std:：vector

:

typedef pair<int, set<int>> solution; 
solution s;                                                                  
s.first = -1;
std::vector<std::vector<solution>> memo(NMAX, std::vector<solution>(NMAX, s));

编辑2:如果你真的是受虐狂并且想自己计算[row][column]索引，那么你可以使用一个

std:：array

并利用

std:：begin（）

和

std:：end（）

调用

std:：fill

：

std::array<solution, NMAX*NMAX> memo;
solution s;                                                                  
s.first = -1;
std::fill(std::begin(memo),std::end(memo), s);

std:：数组备忘录；
溶液s；
s、 第一个=-1；
标准：：填充（标准：：开始（备忘录），标准：：结束（备忘录），s）；

---

---

---

解决方案备忘录[NMAX][NMAX]为什么不
向量备忘录而不是？也
数组备忘录
应该可以。
sizeof
不是元素数，而是字符数（字节）。@πάνταῥεῖ 不一样。向量向量中的数据不连续。@juanchopanza什么？vector提供连续的内存位置。@Félixcanturnet:我们说的是
vector
，它有几个连续的
T
s的非连续缓冲区。
解决方案备忘录[NMAX][NMAX]为什么不
向量备忘录而不是？也
数组备忘录
应该可以。
sizeof
不是元素数，而是字符数（字节）。@πάνταῥεῖ 不一样。向量向量中的数据不连续。@juanchopanza什么？vector提供连续的内存位置。@Félixcanturnet:我们说的是
vector
，它有几个连续的
T
s的非连续缓冲区。
解决方案备忘录[NMAX][NMAX]为什么不
向量备忘录而不是？也
数组备忘录
应该可以。
sizeof
不是元素数，而是字符数（字节）。@πάνταῥεῖ 不一样。向量向量中的数据不连续。@juanchopanza什么？vector提供连续的内存位置。@Félixcanturnet:我们说的是
vector
，它有几个连续的
T
s的非连续缓冲区。
解决方案备忘录[NMAX][NMAX]为什么不
向量备忘录而不是？也
数组备忘录
应该可以。
sizeof
不是元素数，而是字符数（字节）。@πάνταῥεῖ 不一样。向量向量中的数据不连续。@juanchopanza什么？vector提供连续的内存位置。@Félixcanturnet:我们说的是
vector
，它有几个连续的
T
s的非连续缓冲区。我很确定这是UB，因为它访问外部数组是越界的。从技术上看，这是UB；它的作用与
memo[0][NMAX]=s相同；备注[0][NMAX+1]=s等@juanchopanza标准中的相关章节措辞不明确。在这种情况下，不清楚“数组对象的元素”是否可以是
int
。如果你说“不行”，那么许多被普遍接受的技术就会变得非法（例如，用
char*
重复
memo
）。我的解释是，使用
int*
迭代数组是合法的，只要您使用
（int*）&memo
或
（int*）&memo[0]
，那么“数组对象”就明确地表示
memo
，而不是
memo
@MattMcNabb的子对象，它曾经是我的解释（它是OK的）然后我被说服了。现在我不确定了。IIRC对此有一份缺陷报告，但我不知道发生了什么。@juanchopanza re。博士们，我想委员会里没有人想碰它：）我很肯定有什么