Puoi creare un vettore di vettori in c++?

SÌ! Sì, puoi creare un vettore di vettori in C++. Il vettore normale è una struttura dei dati dell'elenco monodimensionale. Un vettore di vettori è una struttura dei dati dell'elenco bidimensionale, da due vettori normali. Un elenco bidimensionale è una tabella, senza una riga di intestazione adeguata e senza una colonna di intestazione corretta. Un vettore di vettori è un vettore che nidifica altri vettori. L'argomento del modello per il vettore esterno, è un vettore. E così, un vettore di vettori può essere solo di un tipo, E.G., Tutti i numeri interi o tutti i personaggi.

Questo articolo spiega come creare un vettore di vettori e come applicare alcune ovvie funzioni dei membri del vettore, al vettore di vettori. Per fare ciò, il programma C ++ dovrebbe iniziare con:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Nota l'inclusione della libreria vettoriale.

Contenuto dell'articolo

Costruzione
Accesso con indici
Accesso in sequenza
Inserendo una riga
Aggiungere una riga
Cancellando le file
Chiaro
Conclusione

Costruzione

La costruzione di un vettore normale inizia con:

vettore nome

Il nome è il nome del vettore. Il seguente codice crea un vettore monodimensionale con un elenco di inizializzazione rinforzato di 5 caratteri:

vettore vtr = 'a', 'b', 'c', 'd', 'e';

Per costruire un vettore di vettori, inizia con:

vettore> Nome

Notare come un modello vettoriale è diventato un altro argomento del modello. Quindi, dovrebbe essere interpretato come vettore di vettori dello stesso tipo. Il nome è il nome del vettore dei vettori. Il seguente codice crea un vettore bidimensionale con 6 elenchi di inizializzazione rinforzati di 5 caratteri ciascuno per 6 righe.

vettore> vtr = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';

Il vettore esterno letterale, ha delimitatori, e. Ogni vettore per una riga ha delimitatori, e. I letterali vettoriali di riga sono separati da virgole. Il punto e virgola si trova all'estremità in basso a destra della tabella di creazione. Il vettore 2D avrebbe potuto anche essere creato come segue:

vettore onedv = 'a', 'b', 'c', 'd', 'e';
vettore> twodv = Onedv, Onedv, Onedv, Onedv, Onedv, OneDv;

Cioè, viene creato un vettore 1D e il suo nome variabile viene utilizzato come identificatori per le diverse righe.

Ora, le righe possono effettivamente avere contenuti diversi. In tal caso, ogni riga sarà un vettore diverso con un nome diverso.

Accesso con indici

La sintassi per accedere a un elemento è:

2Dvectorname [i] [j]

Dove sono la variabile per una determinata riga e j è la variabile per una colonna particolare. Il conteggio delle righe inizia da zero e il conteggio delle colonne inizia anche da zero. Il vettore bidimensionale dei vettori non deve essere regolare; Cioè, il numero di colonne per ogni riga non deve essere lo stesso. Il seguente codice legge il valore della riga dell'indice 2 (terza riga) e della colonna indice 3 (quarta colonna):

vettore> vtr = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
char ch = vtr [2] [3];
cout << ch << endl;

L'output è, 'D'.

Questo può essere modificato e letto di nuovo allo stesso modo, con il seguente segmento di codice:

VTR [2] [3] = 'Z';
char ch = vtr [2] [3];
cout << ch << endl;

In questo caso, l'output è 'z'.

Accesso in sequenza

È possibile accedere alla prima riga a partire dal primo elemento, quindi il secondo elemento, quindi il terzo elemento, fino all'ultimo elemento della prima riga. Quindi, è possibile accedere alla riga successiva allo stesso modo, quindi quella dopo, quindi quella seguente, fino a quando l'ultima riga è completata. Questo necessita di due per loop come il seguente codice illustra:

vectoronedv = 'a', 'b', 'c', 'd', 'e';
vettoretwodv = Onedv, Onedv, Onedv, Onedv, Onedv, Onedv;
per (int i = 0; iper (int j = 0; jcout<
cout<
cout<L'output è:

A b c d e
A b c d e
A b c d e
A b c d e
A b c d e
A b c d e

Nota che Twodv.size () fornisce il numero di righe per l'intero tavolo, mentre Twodv [i].size () fornisce il numero di celle (colonne) per una determinata riga.

Inserendo una riga

Inserendo davanti

Una riga è per un vettore 2D, poiché una cella è per un vettore 1D. Viene utilizzato lo stesso approccio di inserzione, ma invece di un letterale cellulare, viene utilizzata una fila letterale; Invece di un identificatore di valore, un identificatore di riga (E.G., Twodv [i]) è usato. Il seguente codice mostra come una riga viene inserita davanti al vettore 2D:

vettoretwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vettore:: iterator p = twodv.inizio();
vectoronedv = '*', '$', '%', '$', '&';
Twodv.inserire (P, OneDV);
per (int i = 0; iper (int j = 0; jcout<
cout<
cout<L'output è:

* $ % $ &
A b c d e
A b c d e
A b c d e
A b c d e

La funzione membro Begin () restituisce un iteratore che punta alla prima riga del vettore 2D. Si noti che l'iteratore restituito deve essere di tipo vettore dei vettori (E.G. vettore:: iteratore p). L'inserimento avviene davanti a dove indica l'iteratore.

Inserendo all'interno

Il seguente codice inserisce una riga all'interno della tabella, davanti alla terza riga appuntita:

vettoretwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vettore:: iterator p = twodv.inizio();
p ++; p ++;
vectoronedv = '*', '$', '%', '$', '&';
Twodv.inserire (P, OneDV);
per (int i = 0; iper (int j = 0; jcout<
cout<
cout<L'output è:

A b c d e
A b c d e
* $ % $ &
A b c d e
A b c d e

L'iteratore è stato incrementato due volte per indicare la terza riga prima dell'inserimento. La dichiarazione di inserzione avrebbe potuto essere equamente scritta come,

Twodv.insert (p, '*', '$', '%', '$', '&');

Il risultato sarebbe stato lo stesso.

Aggiungere una riga

Una riga può essere aggiunta utilizzando la funzione monodimensionale push_back (). Il seguente codice illustra questo:

vettoretwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vectoronedv = '*', '$', '%', '$', '&';
Twodv.push_back (ONEDV);
per (int i = 0; iper (int j = 0; jcout<
cout<
cout<L'output è:

A b c d e
A b c d e
A b c d e
A b c d e
* $ % $ &

L'istruzione push_back () potrebbe essere ugualmente scritta come,

Twodv.push_back ('*', '$', '%', '$', '&');

Il risultato sarebbe stato lo stesso.

Cancellando le file

Il seguente codice utilizza la funzione membro vettoriale monodimensionale () per cancellare la seconda e la terza riga, sebbene il secondo iteratore stia puntando alla quarta riga, del vettore di 5 righe dei vettori:

vettoretwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vettore:: iterator p = twodv.inizio();
p ++;
vettore:: iteratore Q = twodv.FINE();
Q--; Q--;
Twodv.cancella (p, q);
per (int i = 0; iper (int j = 0; jcout<
cout<
cout<L'output è:

A b c d e
A b c d e
A b c d e

La funzione membro vettoriale di fine () unidimensionale restituisce un iteratore, che punta subito dopo la fine del vettore unidimensionale (che ora è un vettore di vettori). Viene decrementato due volte nel codice sopra, per indicare l'ultima ma una riga. Ogni volta che deve essere cancellata una serie di elementi o righe, l'elemento o la riga indicati dal secondo iteratore, non viene cancellata.

Chiaro

Un elemento è per un vettore monodimensionale, poiché una riga è un vettore bidimensionale (vettore di vettori). Tutte le righe di un vettore possono essere cancellate con la funzione membro clear () monodimensionale. Il seguente codice illustra questo:

vettoretwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
Twodv.chiaro();
per (int i = 0; iper (int j = 0; jcout<
cout<
cout<L'output non è niente.

Conclusione

Un elemento è per un vettore monodimensionale, poiché una riga è un vettore bidimensionale (vettore o vettori). Tutte le funzioni di un membro unidimensionale per il vettore monodimensionale, possono essere utilizzate per il vettore bidimensionale, affrontando le righe anziché gli elementi. È possibile accedere a singole celle della tabella con twodv [i] [j], dove twodv, io e j hanno i loro significati comuni. Il vettore delle righe può essere affrontato con TWODV e ogni riga può essere affrontata con TWODV [i].

Salesforce

Salesforce Apex - Mappa

Tutorial sulla mappa Apex Salesforce e i suoi metodi utilizzati negli scenari di trigger per caricar...

Dr. Ursula Marini

Programmazione Bash

Come aggiungere un nuovo elemento a un array senza specificare l'indice in bash

Per aggiungere un nuovo elemento a un array senza specificare l'indice in bash, utilizzare l'operato...

Dante Palumbo

Programmazione C

Come compilare ed eseguire un programma C nel prompt dei comandi

Sul prompt dei comandi di Windows, è possibile compilare facilmente ed eseguire un programma C trami...

Artemide Ricci