Inizializzazione di uno std :: vector bidimensionale

Quindi, ho quanto segue:

std::vector< std::vector <int> > fog;

e lo sto inizializzando in modo molto ingenuo come:

    for(int i=0; i<A_NUMBER; i++)
    {
            std::vector <int> fogRow;
            for(int j=0; j<OTHER_NUMBER; j++)
            {
                 fogRow.push_back( 0 );
            }
            fog.push_back(fogRow);
    }

E sembra molto sbagliato ... C'è un altro modo per inizializzare un vettore come questo?

Utilizza il std::vector::vector(count, value)costruttore che accetta una dimensione iniziale e un valore predefinito:

std::vector<std::vector<int> > fog(
    A_NUMBER,
    std::vector<int>(OTHER_NUMBER)); // Defaults to zero initial value

Se un valore diverso da zero, 4ad esempio, doveva essere il valore predefinito, allora:

std::vector<std::vector<int> > fog(
    A_NUMBER,
    std::vector<int>(OTHER_NUMBER, 4));

Dovrei anche menzionare l'inizializzazione uniforme è stata introdotta in C ++ 11, che consente l'inizializzazione di vectore altri contenitori, utilizzando {}:

std::vector<std::vector<int> > fog { { 1, 1, 1 },
                                    { 2, 2, 2 } };

Supponiamo che tu voglia inizializzare il vettore 2D, m * n, con il valore iniziale 0

potremmo farlo

#include<iostream>
int main(){ 
    int m = 2, n = 5;

    vector<vector<int>> vec(m, vector<int> (n, 0));

    return 0;
}

Non esiste un appendmetodo std::vector, ma se vuoi creare un vettore contenente A_NUMBERvettori di int, ciascuno di quelli contenenti other_numberzeri, puoi farlo:

std::vector<std::vector<int>> fog(A_NUMBER, std::vector<int>(OTHER_NUMBER));

La sintassi generale, come già illustrato è:

std::vector<std::vector<int> > v (A_NUMBER, std::vector <int> (OTHER_NUMBER, DEFAULT_VALUE))  

Qui, il vettore "v" può essere visualizzato come un array bidimensionale, con "A_NUMBER" di righe, con "OTHER_NUMBER" di colonne con il valore iniziale impostato su "DEFAULT_VALUE".

Inoltre può essere scritto in questo modo:

std::vector <int> line(OTHER_NUMBER, DEFAULT_VALUE)
std::vector<std::vector<int> > v(A_NUMBER, line)

L'immissione di valori in un vettore 2-D è simile all'immissione di valori in una matrice 2-D:

for(int i = 0; i < A_NUMBER; i++) {
     for(int j = 0; j < OTHER_NUMBER; j++) {
         std::cin >> v[i][j]
     }
}

Esempi sono già stati indicati in altre risposte ....!

Penso che il modo più semplice per farlo sia:

std::vector<std::vector<int>>v(10,std::vector<int>(11,100));

10 è la dimensione del vettore esterno o globale, che è il principale, e 11 è la dimensione del vettore interno di tipo int, e i valori iniziali sono inizializzati a 100! Questo è il mio primo aiuto in pila, penso che aiuti qualcuno.

Supponiamo di voler inizializzare un vettore intero bidimensionale con n righe em colonne ciascuna con valore ' VAL '

Scrivilo come

std::vector<vector<int>> arr(n, vector<int>(m,VAL));

Questo VAL può essere una variabile di tipo intero o una costante come 100

L'approccio consigliato consiste nell'usare il costruttore di riempimento per inizializzare un vettore bidimensionale con un dato valore predefinito:

std::vector<std::vector<int>> fog(M, std::vector<int>(N, default_value));

dove, M e N sono le dimensioni per il tuo vettore 2D.

Il mio c++ STLcodice per inizializzare 5*3 2-D vectorconzero

#include <iostream>
using namespace std;
#include <vector>
int main()
{// if we wnt to initialise a 2 D vector with 0;

    vector<vector<int>> v1(5, vector<int>(3,0));

    for(int i=0;i<v1.size();i++) 
{
        for(int j=0;j<v1[i].size();j++)

           cout<<v1[i][j]<<" ";

            cout<<endl;
    }
}