J'ai un vecteur et je souhaite y stocker les données int au moment de l'exécution. Puis-je stocker les données dans un vecteur 2D de cette manière?
std::vector<std::vector <int>> normal:
for(i=0;i<10;i++){
for(j=0;j<20;j++){
normal[i].Push_back(j);
}
}
Oui, mais vous devez également appuyer sur chacun des sous-vecteurs:
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);
}
}
Vous manipulez un vecteur de vecteurs. En tant que tel, lorsque vous déclarez normal
, il est vide et ne contient aucun élément.
Tu peux soit :
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);
}
Cela peut être légèrement plus efficace que de pousser un vecteur vide à chaque étape comme proposé dans d'autres réponses.
Si vous souhaitez stocker un tableau 2D, ce n'est pas la solution optimale, car:
normal[i].size() == normal[j].size()
À la place, vous pouvez utiliser un vecteur de taille N * M
(où N
est le nombre de lignes et M
le nombre de colonnes) et accéder à un élément à la ligne i
et aux colonnes j
à l'aide de l'index i + j * N
:
size_t N = 20;
size_t M = 20;
std::vector<int> normal;
normal.resize(N * M);
for (size_t i = 0; i < N; ++i)
for (size_t j = 0; j < M; ++j)
normal[i + j * N] = j;
Vous ne pouvez pas affecter directement à [i]
sans allouer d’abord les vecteurs interne et externe. Une solution consiste à créer les vecteurs internes dans votre boucle for, puis une fois ceux-ci renseignés, Push_back au vecteur externe.
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);
}
Voici une autre approche.
#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;
}
}
La sortie du programme est
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
Vous pouvez écrire une fonction correspondante
#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;
}
}
Vous avez un vecteur de vecteurs.
normal [i] N'existe pas car vous ne l'avez pas créé.
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;
}