Können Sie einen Vektor von Vektoren in C herstellen?++?

Ja! Ja, Sie können einen Vektor von Vektoren in C herstellen++. Der normale Vektor ist eine eindimensionale Listendatenstruktur. Ein Vektor von Vektoren ist eine zweidimensionale Listendatenstruktur aus zwei normalen Vektoren. Eine zweidimensionale Liste ist eine Tabelle, ohne eine ordnungsgemäße Header-Reihe und ohne ordnungsgemäße Header-Spalte. Ein Vektor von Vektoren ist ein Vektor, der andere Vektoren nistet. Das Vorlagenargument für den äußeren Vektor ist ein Vektor. Und so kann ein Vektor von Vektoren nur von einem Typ sein, e.G., Alle Ganzzahlen oder alle Charaktere.

In diesem Artikel wird erklärt. Dazu sollte das C ++ - Programm mit:

#enthalten
#enthalten
Verwenden von Namespace STD;

Beachten Sie die Einbeziehung der Vektorbibliothek.

Artikelinhalt

Konstruktion
Zugriff mit Indizes
Nacheinander zugreifen
Einfügen einer Reihe
Eine Zeile anhängen
Zeilen löschen
Klar
Abschluss

Konstruktion

Der Bau eines normalen Vektors beginnt mit:

Vektor Name

Name ist der Name des Vektors. Der folgende Code erstellt einen eindimensionalen Vektor mit einer verblüfften Initialisierungsliste mit 5 Zeichen:

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

Beginnen Sie mit:

Vektor> Name

Beachten Sie, wie eine Vektorvorlage zu einem weiteren Vorlagenargument geworden ist. Es sollte also als Vektor der Vektoren desselben Typs interpretiert werden. Name ist der Name des Vektors der Vektoren. Der folgende Code erstellt einen zweidimensionalen Vektor mit 6 verblüfften Initialisierungslisten mit jeweils 5 Zeichen für 6 Zeilen.

Vektor> 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';

Der äußere Vektorliteral hat Grenzwerte, und. Jeder Vektor für eine Zeile enthält Grenzwerte, und. Die Zeilenvektorliterale sind durch Kommas getrennt. Das Ende Semikolon befindet sich im unteren rechten Ende der Erstellungstabelle. Der 2D -Vektor hätte auch wie folgt erstellt werden können:

Vektor ONEDV = 'A', 'B', 'C', 'D', 'E';
Vektor> twodv = Oneedv, Oneedv, Oneedv, Oneedv, Oneedv, Oneedv;

Das heißt, ein 1D -Vektor wird erstellt, und sein variabler Name wird als Kenner für die verschiedenen Zeilen verwendet.

Jetzt können die Zeilen tatsächlich unterschiedliche Inhalte haben. In diesem Fall ist jede Zeile ein anderer Vektor mit einem anderen Namen.

Zugriff mit Indizes

Die Syntax zum Zugriff auf ein Element lautet:

2DVectorname [i] [j]

Wo ich die Variable für eine bestimmte Zeile ist und J die Variable für eine bestimmte Spalte ist. Die Zeilenzählung beginnt von Null und die Spaltenzählung beginnt ebenfalls von Null. Der zweidimensionale Vektor der Vektoren muss nicht regelmäßig sein; Das heißt, die Anzahl der Spalten für jede Zeile muss nicht gleich sein. Der folgende Code liest den Wert von Index Zeile 2 (dritte Zeile) und Indexspalte 3 (vierte Spalte):

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

Die Ausgabe ist 'D'.

Dies kann mit dem folgenden Codesegment auf die gleiche Weise geändert und erneut gelesen werden:

vtr [2] [3] = 'z';
char ch = vtr [2] [3];
Cout << ch << endl;

In diesem Fall ist die Ausgabe 'z'.

Nacheinander zugreifen

Die erste Zeile kann ab dem ersten Element, dann auf das zweite Element, dann auf das dritte Element bis zum letzten Element der ersten Zeile zugegriffen werden. Dann kann auf die nächste Zeile auf die gleiche Weise zugegriffen werden, dann auf die und dann auf die folgende, bis die letzte Reihe abgeschlossen ist. Dies erfordert zwei für Schleifen, wie der folgende Code zeigt:

vectoronedv = 'a', 'b', 'c', 'd', 'e';
Vektortwodv = oneedv, oneedv, oneedv, oneedv, oneedv, oneedv;
für (int i = 0; ifür (int j = 0; jCout<
Cout<
Cout<Die Ausgabe ist:

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

Beachten Sie, dass Twodv.size () gibt die Anzahl der Zeilen für die gesamte Tabelle an, während TWODV [i].size () gibt die Anzahl der Zellen (Spalten) für eine bestimmte Zeile an.

Einfügen einer Reihe

Vorne einfügen

Eine Reihe ist zu einem 2D -Vektor, da eine Zelle zu einem 1D -Vektor ist. Der gleiche Insertionsansatz wird verwendet, aber anstelle eines Zellwörtels wird ein Zeilenliteral verwendet. anstelle einer Wertkennung, einer Zeilenkennung (e.G., TWODV [i]) wird verwendet. Der folgende Code zeigt, wie eine Zeile vor dem 2D -Vektor eingefügt wird:

Vektortwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
Vektor:: iterator p = twodv.Start();
vectoronedv = '*', '$', '%', '$', '&';
twodv.Insert (p, oneedv);
für (int i = 0; ifür (int j = 0; jCout<
Cout<
Cout<Die Ausgabe ist:

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

Die Funktion mit Beginn () gibt einen Iterator zurück, der auf die erste Reihe des 2D -Vektors verweist. Beachten Sie, dass der zurückgegebene Iterator vom Typ Vektoren sein muss (e.G. Vektor:: Iterator p). Die Einfügung findet vor dem Iterator statt.

Einfügen innerhalb

Der folgende Code fügt eine Zeile in der Tabelle vor der spitzen dritten Reihe ein:

Vektortwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
Vektor:: iterator p = twodv.Start();
P ++; P ++;
vectoronedv = '*', '$', '%', '$', '&';
twodv.Insert (p, oneedv);
für (int i = 0; ifür (int j = 0; jCout<
Cout<
Cout<Die Ausgabe ist:

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

Der Iterator wurde zweimal inkrementiert, um vor dem Einfügen auf die dritte Reihe zu verweisen. Die Insertion -Erklärung hätte gleichermaßen geschrieben werden können wie,

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

Das Ergebnis wäre das gleiche gewesen.

Eine Zeile anhängen

Eine Zeile kann mit der eine dimensionale Funktion push_back () angehängt werden. Der folgende Code zeigt dies:

Vektortwodv = 'a', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vectoronedv = '*', '$', '%', '$', '&';
twodv.push_back (Oneedv);
für (int i = 0; ifür (int j = 0; jCout<
Cout<
Cout<Die Ausgabe ist:

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

Die Anweisung push_back () hätte gleichermaßen geschrieben werden können wie,

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

Das Ergebnis wäre das gleiche gewesen.

Zeilen löschen

Der folgende Code verwendet die eindimensionale ERASE () Vektorelementfunktion, um die zweite und dritte Zeilen zu löschen, obwohl der zweite Iterator auf die vierte Reihe des 5-Zeilen-Vektors der Vektoren zeigt:

Vektortwodv = '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';
Vektor:: iterator p = twodv.Start();
P ++;
Vektor:: Iterator q = twodv.Ende();
Q--; Q--;
twodv.löschen (p, q);
für (int i = 0; ifür (int j = 0; jCout<
Cout<
Cout<Die Ausgabe ist:

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

Die eindimensionale End () -Vektorelementfunktion gibt einen Iterator zurück, der kurz nach dem Ende des eindimensionalen Vektors (der jetzt ein Vektor von Vektoren ist) zeigt. Es wird im obigen Code zweimal abgeschlossen, um auf die letzte, aber eintreiche Zeile zu verweisen. Immer wenn eine Reihe von Elementen oder Zeilen gelöscht werden soll, wird das Element oder die Zeile, auf die der zweite Iterator gerichtet ist, nicht gelöscht.

Klar

Ein Element ist ein eindimensionaler Vektor, da eine Reihe ein zweidimensionaler Vektor (Vektor von Vektoren) ist. Alle Zeilen eines Vektors können mit der eindimensionalen Clear () -Mivierungsfunktion gelöscht werden. Der folgende Code zeigt dies:

Vektortwodv = '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.klar();
für (int i = 0; ifür (int j = 0; jCout<
Cout<
Cout<Die Ausgabe ist nichts.

Abschluss

Ein Element ist ein eindimensionaler Vektor, da eine Reihe ein zweidimensionaler Vektor (Vektor oder Vektoren) ist. Alle eindimensionalen Elementfunktionen für den eindimensionalen Vektor können für den zweidimensionalen Vektor verwendet werden, der die Zeilen anstelle der Elemente adressiert. Auf einzelne Zellen der Tabelle kann mit twodv [i] [j] zugegriffen werden, wo twodv, i und j ihre gemeinsamen Bedeutungen haben. Der Vektor der Zeilen kann mit TWODV angesprochen werden, und jede Zeile kann mit TWODV [i] angesprochen werden.

C ++

So verwenden Sie den Subtraktionszuweisungsoperator in C ++

In C ++ Das -= ist ein Subtraktionszuweisungsoperator, subtrahiert er zwei gegenüberliegende Seitenw...

Gian Eisenlauer

C -Programmierung

Was ist der Unterschied zwischen = und == Operatoren in der C -Programmierung?

Der = Operator wird verwendet, um einer Variablen einen Wert zuzuweisen, während der Operator = zwei...

Christopher Lammert

Power Shell

So verwenden Sie den Befehl Startschlafen in PowerShell?

Das CMDLET in PowerShell „Start im Schlafen“ ist für die Aussetzung einer Aktivität oder für eine be...

Ahmed Stöckert