C++ 将一维数组转换为二维向量c++；

有人能帮我写一个逻辑，把ID数组转换成2D向量吗

差不多

int array[] = {1, 4, 5, 7, 9, 3}; // dynamic array
vector <vector int> ex;

int数组[]={1,4,5,7,9,3}；//动态数组
向量ex；

我现在如何将值放入ex from array。。所以它形成了3个值中的2个向量

我一直在寻求帮助，但毫无用处，我自己也尝试过，如下所示：

for(int i=0; i<2; i++)
{   
        rowTemp_ex.assign(array, array+3));
 ex.push_back(rowTemp_ex);
 rowTemp_ex.erase(rowTemp_ex.begin() , rowTemp_ex.end());
}

---

对于（int i=0；i首先，计算将有多少行向量。如果每个行向量都有三个元素，则总数是数组大小除以3

template <typename T, std::size_t N>
std::size_t size(T(&)[N]) { return N; }

int number_of_rows = size(array) / 3;

模板
std:：size_t size（t（&）[N]）{return N；}
整数行数=大小（数组）/3；

现在创建一个向量，每个向量包含三个元素：

std::vector<std::vector<int> > v(number_of_rows, std::vector<int>(3));

std:：vector v（行数，std:：vector（3））；

然后遍历原始数组，使用整数除法和余数运算填充结果的每个单元格：

for(int i = 0; i < size(array); ++i) {
    v[i / 3][i % 3] = array[i];
}

for（int i=0；i
假设您始终需要三个大小各为2的向量，并且2D向量在C数组中成对对齐，请执行以下操作：

int array[] = {1, 4, 5, 7, 9, 3}; // dynamic array
vector<vector<int> > ex;

for(int i = 0; i < 3; ++i)
{
    vector<int> tmp;
    tmp.push_back(array[2*i]);
    tmp.push_back(array[2*i+1]);
    ex.push_back(tmp);
}

int-array[]={1,4,5,7,9,3}；//动态数组
向量ex；
对于（int i=0；i<3；++i）
{
向量tmp；
tmp.push_-back（数组[2*i]）；
tmp.push_-back（数组[2*i+1]）；
例如推回（tmp）；
}
您在正确的轨道上，但在for循环中出错：

rowTemp_ex.assign(array, array+3));

这将在每次迭代中分配相同的数组部分。您需要将行（3）的大小乘以i：

对
vector:：erase
的调用是多余的，下一次迭代中的
vector:：assign
仍将丢弃以前的内容

这里有一些更一般的内容，也将处理可能的奇怪元素（未测试）：

const size\u t arr\u size=N；
const size\u t n\u cols=M；
常量大小n行=数组大小/n列；
常数大小n\u奇数=阵列大小%n\u列；
int arr[arr_size]={….}；
int*begin=arr；
int*end=arr+（n行*n列）；
while（开始！=结束）{
例如，推回（std:：vector（begin，begin+n_cols））；
begin+=n_cols；
}
if（n_奇数）
例如推回（std:：vector（begin，begin+n_-odd））；
你知道数组中元素的数量吗？因为你说动态：编译器不知道大小，任何人都必须告诉将它们放入
向量的代码部分。关于leemes，回答：你可以用
sizeof（array）/sizeof（int）计算大小
它提供了数组中元素的数量。感谢您的详细解释：）我已经实现了它，只是做了一些细微的更改。
rowTemp_ex.assign(array + i * 3, array + (i * 3) + 3));

i = 0:      0*3                  0*3+3
i = 1:                            1*3                   1*3 + 3
array:    [  0  ][  1  ][   2  ][   3  ][  4   ][  5  ] [one past the end]

const size_t arr_size = N;
const size_t n_cols = M;
const size_t n_rows = arr_size / n_cols;
const size_t n_odd = arr_size % n_cols;

int arr[arr_size] = { .... };

int* begin = arr;
int* end = arr + (n_rows * n_cols);

while( begin != end ) {
    ex.push_back(std::vector<int>(begin, begin + n_cols));
    begin += n_cols;
}

if (n_odd)
    ex.push_back(std::vector<int>(begin, begin + n_odd));