Question

我有一个向量，想要在运行时将int数据存储到它中，我可以用这种方式将数据存储在2D向量中吗？

std::vector<std::vector <int>> normal:
    for(i=0;i<10;i++){
        for(j=0;j<20;j++){
            normal[i].push_back(j);
    }
}

Answer 1

是的，但您还需要推送每个子向量：

std::vector<std::vector<int>> normal;
for(int i=0; i<10; i++)
{
    normal.push_back(std::vector<int>());
    for(int j=0; j<20; j++)
    {    
        normal[i].push_back(j);    
    }
}

Answer 2

您正在操纵矢量矢量。因此，在声明normal时它是空的并且不包含任何元素。

你可以：

在插入元素之前调整向量的大小

std::vector<std::vector<int> > normal;
normal.resize(20);

for (size_t i = 0; i < normal.size(); ++i)
{
    for (size_t j = 0; j < 20; ++j)
        normal[i].push_back(j);
}

这可能比在其他答案中提出的每一步推动空向量稍微有效。

使用平面2D阵列

如果要存储2D数组，这不是最佳解决方案，因为：

您的阵列数据分布在N个不同的动态分配缓冲区（N行）
您的数组每行可以有不同数量的列（因为没有强制执行normal[i].size() == normal[j].size()

相反，您可以使用大小为N * M的向量（其中N是行数，M列数），并访问行{{1}处的元素使用索引i：

j

i + j * N

Answer 3

创建一个临时向量将元素推入这个临时向量，然后将这个临时向量（我的代码中的 v2）推入一个二维向量（我的代码中的 v1）。

#include <iostream>
#include <bits/stdc++.h>
#include<algorithm>
 using namespace std;

 int main()
 {

    vector<vector<int>> v1;
    vector<int> v2;
    v2.push_back(1);
    v2.push_back(2);
    v2.push_back(13);
    v2.push_back(14);
    v2.push_back(15);

    v1.push_back(v2);
    //i pushed v2 into v1

    int j=0;
    for(int i=0 ; i<5 ;i++)
    {
        cout<<v1[0][i]<<"\t";
    }
  }

Answer 4

如果不首先分配外部和内部向量，则无法直接分配给[i]。一个解决方案是在for循环中创建内部向量，然后填充后，push_back到外部向量。

std::vector<std::vector<int>> normal;
for(i=0;i<10;i++)
{
    std::vector<int> temp;
    for(j=0;j<20;j++)
    {
        temp.push_back(j);
    }
    normal.push_back(temp);
}

Answer 5

你有一个向量载体。

normal [i]因为你还没有创建它而不存在。

std::vector<std::vector <int> > normal:
for(i=0;i<10;i++){
    normal.emplace_back();
    for(j=0;j<20;j++){
        normal.back().push_back(j);
    }
}

for(i=0;i<10;i++){
    for(j=0;j<20;j++){
        std::cout << normal[i][j] << " ";
    }
    std::cout << std::endl;
}

Answer 6

这是另一种方法。

#include <iostream>
#include <iomanip>
#include <vector>
#include <numeric>

int main() 
{
    std::vector<std::vector <int> > normal;
    normal.resize( 10, std::vector<int>( 20 ) );

    for ( auto &v : normal ) std::iota( v.begin(), v.end(), 0 );

    for ( const auto &v : normal )
    {
        for ( int x : v ) std::cout << std::setw( 2 ) << x << ' ';
        std::cout << std::endl;
    }
}

程序输出

 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19

您可以编写相应的功能

#include <iostream>
#include <iomanip>
#include <vector>
#include <numeric>

template <typename T>
T & init_2d( T &container, size_t m, size_t n )
{
    container.resize( m, typename T::value_type( n ) );

    for ( auto &item : container ) std::iota( item.begin(), item.end(), 0 );

    return container;
}

int main() 
{
    std::vector<std::vector<int>> v;

    for ( const auto &v : init_2d( v, 10, 20 ) )
    {
        for ( int x : v ) std::cout << std::setw( 2 ) << x << ' ';
        std::cout << std::endl;
    }

}

Answer 7

分配n个空向量，即每个索引的空向量。然后可以应用push_back（）。

int main()
{
    int n = 10;
    std::vector<std::vector<int>> normal;
    normal.resize(n);   //Allocating 'n' empty vectors
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < 20; j++)
        {
             normal[i].push_back(j);
        }
    }
    return 0;
}

Answer 8

我认为可以使用这种指向子向量的指针。但是它仍然需要用一个空向量声明，然后我们才能 push_back() 子向量。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int main () {
    vector<vector<ll>> normal;
    for (ll i=0; i<10; i++) {
        normal.push_back({}); //init empty sub vector
        for (ll j=0; j<20; j++) {
            vector<ll>& temp = normal[i]; //point the sub vector
            temp.push_back(j);            //pus_back the sub vector
        }
    }
    for (ll i=0; i<10; i++) {
        for (ll j=0; j<20; j++) {
            printf("%lld ", normal[i][j]);
        }printf("\n");
    }
    return 0;
}

如何在int类型的2d向量中推送数据

8 个答案:

在插入元素之前调整向量的大小

使用平面2D阵列