web-dev-qa-db-fra.com

Comment puis-je Push_back données dans un vecteur 2D de type int

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);
    }
}
c++multidimensional-arrayvector
3
saru

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);    
    }
}
6
SingerOfTheFall

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 :

Redimensionner le vecteur avant d'insérer des éléments

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.

Utiliser un tableau 2D plat

Si vous souhaitez stocker un tableau 2D, ce n'est pas la solution optimale, car:

  1. Vos données de tableau sont réparties sur N tampons différents alloués dynamiquement (pour N lignes)
  2. Votre tableau peut avoir un nombre différent de colonnes par ligne (car rien n’impose cette 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;
3
A. Monti

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);
}
0
CoryKramer

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;
    }

}
0
Vlad from Moscow

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;
}
0
user3853544