Können Sie einen Vektor in C++ löschen?

Konnen Sie Einen Vektor In C Loschen



Ja! Ja, aber ohne Einschränkungen geht es nicht. Es gibt zwei Möglichkeiten, einen Vektor zu löschen. Auch hier gehen sie nicht ohne Einschränkungen aus. Eine Möglichkeit, einen Vektor zu löschen, besteht darin, den Destruktor des Vektors zu verwenden. In diesem Fall werden alle Elemente gelöscht, der Name des Vektors wird jedoch nicht gelöscht. Die zweite Möglichkeit, einen Vektor zu löschen, besteht darin, ihn einfach außerhalb des Gültigkeitsbereichs zu lassen. Normalerweise stirbt jedes in einem Gültigkeitsbereich deklarierte nicht-statische Objekt, wenn es den Gültigkeitsbereich verlässt. Dies bedeutet, dass auf das Objekt in einem Verschachtelungsbereich (Block) nicht zugegriffen werden kann. Ein Verschachtelungsbereich ist ein äußerer Bereich (Block). Ein verschachtelter Bereich ist ein innerer Bereich, der immer noch Teil des interessierenden Bereichs ist. Diese beiden Möglichkeiten zum Löschen eines Vektors werden in diesem Artikel erläutert.

Um einen Vektor in C++ zu verwenden, sollte das Programm beginnen mit:







#include

#include

verwenden Namensraum std ;

Artikelinhalt

Den Vektor zerstören

Jedes erstellte Objekt befindet sich in einem bestimmten Bereich. In diesem Abschnitt des Artikels wird der Vektor im Funktionsumfang main() erstellt und zerstört. Die Syntax zum Zerstören eines Vektors lautet:



a.~X ( )

Dabei ist „a“ der Name des Vektors und X der Klassenname des Vektors. Der Vektor ist eine von einer Klasse instanziierte Datenstruktur. Der Name der Vektorklasse ist „vector“, wobei alle Zeichen in Kleinbuchstaben geschrieben sind. Wenn der Name des Vektors vtr lautet, wird der Vektor wie folgt zerstört:

vtr.~Vektor.

Das folgende Programm löscht den Vektor:

#include
#include
verwenden Namensraum std ;

int hauptsächlich ( )
{
Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

vtr.~Vektor ( ) ;

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ ) {
cout << vtr [ ich ] << ' ' ;
}
cout << endl ;

zurückkehren 0 ;
}

Die Ausgabe ist nichts, was darauf hinweist, dass alle Vektorelemente außer dem Namen des Vektors gelöscht wurden. Das ist gut. Die obige Ausgabe wurde durch Verweis auf die vermeintlichen Elemente angezeigt. Was passiert, wenn die Ausgabe mithilfe des Iterators angezeigt wird? Betrachten Sie das folgende Programm:

#include

#include

verwenden Namensraum std ;



int hauptsächlich ( )

{

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

Vektor < verkohlen > :: Iterator Es = vtr. beginnen ( ) ;



vtr.~Vektor ( ) ;



für ( Es = Es ; Es ! = vtr. Ende ( ) ; Es ++ ) {

cout << * Es << ' ' ;

}

cout << endl ;



zurückkehren 0 ;

}

Die Ausgabe ist immer noch nichts. In diesem Stadium kann man mit Sicherheit zu dem Schluss kommen, dass bei der Zerstörung eines Vektors alle seine Elemente außer seinem Namen zerstört werden.

Vektorname nicht zerstört

Da der Vektorname nicht mit dem Destruktor zerstört wird, kann der Name weiterhin im gleichen Bereich wiederverwendet werden. Das folgende Programm veranschaulicht dies:

#include

#include



verwenden Namensraum std ;

int hauptsächlich ( )

{

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

vtr.~Vektor ( ) ;

vtr = { 'F' , 'G' , 'H' , 'ICH' , 'J' } ;

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ ) {

cout << vtr [ ich ] << ' ' ;

}

cout << endl ;

zurückkehren 0 ;

}

Die Ausgabe ist:

F G H I J

Der ursprüngliche Inhalt des Vektors hatte 5 Zeichen. Die 5 Elemente wurden alle gelöscht. Da der Vektorname wiederverwendet wurde, wurden dem Vektor neue 5 Zeichen als Inhalt zugewiesen. Die Ausgabe zeigte, dass der neue Inhalt korrekt war.

Es gibt jedoch immer noch eine Nuance. Wenn der neue Inhalt mit der Memberfunktion push_back() angegeben wird, ist die Ausgabe möglicherweise unvollständig und der Vektor enthält möglicherweise neue Zeichen. Das folgende Programm veranschaulicht dies:

#include

#include

verwenden Namensraum std ;



int hauptsächlich ( )

{

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

vtr.~Vektor ( ) ;

vtr = { 'IN' , 'IN' , 'X' , 'UND' , 'MIT' } ;

vtr.~Vektor ( ) ;

vtr. push_back ( 'F' ) ;

vtr. push_back ( 'G' ) ;

vtr. push_back ( 'H' ) ;

vtr. push_back ( 'ICH' ) ;

vtr. push_back ( 'J' ) ;

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ ) {

cout << vtr [ ich ] << ' ' ;

}

cout << endl ;

zurückkehren 0 ;

}

Die Ausgabe ist:

P ^ t e U G H I J

„F“ fehlt in der Ausgabe und es gibt seltsame Zeichen. Der Vektorinhalt wird zunächst über den Zuweisungsoperator angegeben. Mit dem Zuweisungsoperator wird der Vektor zerstört und neuer Inhalt wieder zugewiesen. Der Vektor wird erneut zerstört, und dieses Mal wird der Inhalt mit der Memberfunktion push_back() übergeben. „F“ fehlt in der Ausgabe und es gibt seltsame Zeichen. Das bedarf einer Erklärung:

Wenn ein Vektor zerstört wird, werden alle seine Elemente offiziell gelöscht. Was passiert, ist, dass die Elemente mit sofortiger Wirkung einfach als nicht zum Vektor gehörend betrachtet werden und ihre Speicherorte mit sofortiger Wirkung von jedem anderen Code als wiederverwendbar gekennzeichnet werden. Wenn dieses Schema intern nicht perfekt ausgeführt wird, wie beim letzten Programm oben, wird es Probleme geben und es kann zu der oben erhaltenen Ausgabe kommen.

const-Vektor

Wenn einer Vektordeklaration „const“ für „Konstante“ vorangestellt ist, kann sie trotzdem zerstört werden, wie oben erläutert. Das folgende Programm veranschaulicht dies:

#include

#include

verwenden Namensraum std ;

int hauptsächlich ( )

{

const Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;



vtr.~Vektor ( ) ;



für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ ) {

cout << vtr [ ich ] << ' ' ;

}

cout << endl ;



zurückkehren 0 ;

}

Die Ausgabe ist nichts. Unter dieser Bedingung (const-Vektor) kann jedoch kein Element mit der Member-Funktion erase() gelöscht werden.

Verwendung des Namens in einem verschachtelten Bereich

Das Zerstören eines Vektors mit ~vector zerstört den Inhalt (die Elemente), nicht jedoch den Vektornamen. Der Name kann weiterhin in einem inneren Bereich verwendet werden, der immer noch Teil des interessierenden Bereichs ist. Das folgende Programm veranschaulicht dies:

#include

#include

verwenden Namensraum std ;

int hauptsächlich ( )

{

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;



vtr.~Vektor ( ) ;



Wenn ( 1 == 1 ) {

vtr = { 'K' , 'L' , 'M' , 'N' , 'Ö' } ;

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ )

cout << vtr [ ich ] << ' ' ;

cout << endl ;

}



zurückkehren 0 ;

}

Die Ausgabe ist:

K L M N O

Hinweis: Wenn ein Vektorname wiederverwendet werden soll, sollte er nicht erneut deklariert werden.

Lassen Sie Scope los

Wenn ein deklariertes Objekt seinen Gültigkeitsbereich verlässt, kann außerhalb seines Gültigkeitsbereichs nicht mehr auf es zugegriffen werden. Dies bedeutet, dass in einem Verschachtelungsbereich nicht mehr darauf zugegriffen werden kann. Der Zugriff kann jedoch in einem verschachtelten Bereich erfolgen. Ein verschachtelter Bereich ist immer noch Teil des betreffenden Bereichs.

Zugriff innerhalb und außerhalb des Geltungsbereichs

Das folgende Programm veranschaulicht, wie im Gültigkeitsbereich auf einen Vektor zugegriffen wird:

#include

#include

verwenden Namensraum std ;

int hauptsächlich ( )

{

Wenn ( 1 == 1 ) {

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ )

cout << vtr [ ich ] << ' ' ;

cout << endl ;

}



zurückkehren 0 ;

}

Die Ausgabe ist:

A B C D E

Der Funktionsumfang main() verschachtelt den Umfang des if-Blocks. Auf vtr, das im If-Block-Bereich deklariert ist, kann nur im If-Block-Bereich zugegriffen werden. Außerhalb des if-Block-Bereichs kann nicht darauf zugegriffen werden. Es kann nicht außerhalb des main()-Funktionsblocks zugegriffen werden, der den if-Block verschachtelt. Das folgende Programm lässt sich nicht kompilieren, da versucht wird, auf den Vektor außerhalb seines Gültigkeitsbereichs zuzugreifen:

#include

#include

verwenden Namensraum std ;

int hauptsächlich ( )

{

Wenn ( 1 == 1 ) {

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ )

cout << vtr [ ich ] << ' ' ;

cout << endl ;

}



cout << vtr [ 1 ] << endl ;



zurückkehren 0 ;

}

Wenn der Leser versucht hätte, das Programm zu kompilieren, wäre eine Fehlermeldung ausgegeben worden.

Verschachtelter Bereich

Ein verschachtelter Bereich ist immer noch Teil des betreffenden Bereichs. Das folgende Programm veranschaulicht, wie auf einen Vektor in einem verschachtelten Bereich zugegriffen werden kann:

#include

#include

verwenden Namensraum std ;

int hauptsächlich ( )

{

Wenn ( 1 == 1 ) {

Vektor < verkohlen > vtr = { 'A' , 'B' , 'C' , 'D' , 'UND' } ;

Wenn ( 1 == 1 ) {

für ( int ich = 0 ; ich < vtr. Größe ( ) ; ich ++ )

cout << vtr [ ich ] << ' ' ;

cout << endl ;

}

}



zurückkehren 0 ;

}

Die Ausgabe ist:

A B C D E

Der Funktionsblock main() verschachtelt den ersten If-Block, der wiederum den zweiten If-Block verschachtelt. Der Vektor wird im ersten if-Block deklariert. Der Zugriff erfolgte im verschachtelten (inneren) if-Block.

Der Ansatz, den Vektor sterben zu lassen, wenn er den Gültigkeitsbereich verlässt, erscheint der Verwendung des Destruktors vorzuziehen. Wenn der Vektor den Gültigkeitsbereich verlässt, stirbt auch sein Name. Allerdings möchte der Programmierer nicht immer, dass der Vektor stirbt, weil er den Gültigkeitsbereich verlässt. Daher muss der Destruktor gelegentlich verwendet werden. Beide Wege haben ihre Einschränkungen.

Abschluss

Eine Möglichkeit, einen Vektor zu löschen, besteht darin, den Destruktor des Vektors zu verwenden. In diesem Fall werden alle Elemente gelöscht, der Name des Vektors wird jedoch nicht gelöscht. Die zweite Möglichkeit, einen Vektor zu löschen, besteht darin, ihn einfach außerhalb des Gültigkeitsbereichs zu lassen. Normalerweise stirbt jedes in einem Gültigkeitsbereich deklarierte nicht-statische Objekt, wenn es den Gültigkeitsbereich verlässt. Dies bedeutet, dass auf das Objekt in einem Verschachtelungsbereich (Block) nicht zugegriffen werden kann. Ein Verschachtelungsbereich ist ein äußerer Bereich (Block). Der Zugriff kann jedoch in einem verschachtelten Bereich erfolgen. Ein verschachtelter Bereich ist ein innerer Bereich, der immer noch Teil des interessierenden Bereichs ist. Beide Wege haben Einschränkungen. Ein Vektor in einem inneren Gültigkeitsbereich muss nicht mit ~vector zerstört werden, bevor er den Gültigkeitsbereich verlässt und stirbt.