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

Ja! Ja, aber es gilt nicht ohne Einschränkungen. Es gibt zwei Möglichkeiten, einen Vektor zu löschen. Wieder 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. Der zweite Weg, einen Vektor zu löschen. Normalerweise stirbt ein nicht statisches Objekt, das in einem Zielfernrohr deklariert wird, wenn es aus dem Umfang ausgeht. Dies bedeutet, dass auf das Objekt nicht in einem Nistbereich (Block) zugegriffen werden kann (Block). Ein Verschachtelungsumfang ist ein äußerer Bereich (Block). Ein verschachtelter Bereich ist ein innerer Bereich, der immer noch Teil des Interessensumfangs ist. Diese beiden Möglichkeiten zum Löschen eines Vektors werden in diesem Artikel erörtert.

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

#enthalten
#enthalten
Verwenden von Namespace STD;

Artikelinhalt

• Zerstören des Vektors
• Den Zielfernrohr verlassen lassen
• Abschluss

Zerstören des Vektors

Jedes erstellte Objekt befindet sich in einem Umfang. Der Vektor wird in diesem Abschnitt des Artikels im Funktionsbereich main () erstellt und zerstört. Die Syntax, um einen Vektor zu zerstören, lautet:

A.~ X ()

wobei 'a' der Name des Vektors ist und X der Klassenname des Vektors ist. Der Vektor ist eine Datenstruktur, die aus einer Klasse instanziiert ist. Der Name der Vektorklasse ist „Vektor“, mit allen Zeichen in Kleinbuchstaben. Wenn der Name des Vektors VTR ist, wird der Vektor mit zerstört,

vtr.~ Vektor.

Das folgende Programm löscht den Vektor:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vector ();
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Rückkehr 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 angezeigt, indem auf die angeblichen Elemente verwiesen wurde. Was ist, wenn der Ausgang mit dem Iterator angezeigt wird?? Betrachten Sie das folgende Programm:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
Vektor:: iterator it = vtr.Start();
vtr.~ vector ();
für (es = es; es; es != vtr.Ende(); es ++)
Cout << *it << ";

Cout << endl;
Rückkehr 0;

Die Ausgabe ist immer noch nichts. In diesem Stadium ist es sicher zu dem Schluss, dass bei der Zerstörung eines Vektors alle Elemente zerstört werden, mit Ausnahme seines Namens.

Vektorname nicht zerstört

Da der Vektorame nicht mit dem Destruktor zerstört wird, kann der Name immer noch im selben Bereich wiederverwendet werden. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vector ();
vtr = 'f', 'g', 'h', 'i', 'j';
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Rückkehr 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 Vektorame wiederverwendet wurde, wurden neue 5 Zeichen als Inhalt an den Vektor gegeben. Die Ausgabe zeigte, dass der neue Inhalt korrekt war.

Es gibt jedoch immer noch eine Nuance. Wenn der neue Inhalt mit der Member -Funktion push_back () angegeben wird, kann die Ausgabe unvollständig sein, und es kann neue Zeichen im Vektor geben. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vector ();
vtr = 'v', 'w', 'x', 'y', 'z';
vtr.~ vector ();
vtr.push_back ('f');
vtr.push_back ('g');
vtr.push_back ('h');
vtr.push_back ('i');
vtr.push_back ('j');
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

p ^ t e u g h i j

'F' fehlt in der Ausgabe, und es gibt seltsame Zeichen. Zunächst wird der Vektorinhalt mit dem Zuordnungsbetreiber angegeben. Der Vektor wird zerstört und der neue Inhalt erneut mit dem Zuordnungsbetreiber zugeordnet. Der Vektor wird erneut zerstört, und diesmal wird der Inhalt mit der Member -Funktion push_back () angegeben. 'F' fehlt in der Ausgabe, und es gibt seltsame Zeichen. Dies muss Erklärung benötigen:

Wenn ein Vektor zerstört wird, werden alle seine Elemente offiziell gelöscht. Was passiert ist, dass die Elemente einfach als unmittelbarer Wirkung zum Vektor angesehen werden und ihre Speicherorte mit sofortiger Wirkung als wiederverwendbar angesehen werden. Wenn dieses Schema wie beim letzten Programm nicht innen nicht perfekt durchgeführt wird.

Const Vector

Wenn eine Vektorerklärung von const für konstant vorangestellt wird, kann sie immer noch zerstört werden, wie oben erläutert. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Const Vector vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vector ();
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";

Cout << endl;
Rückkehr 0;

Die Ausgabe ist nichts. Unter dieser Bedingung (Const Vector) kann jedoch kein Element unter Verwendung der Member -Funktion erase () gelöscht werden.

Verwenden des Namens in einem verschachtelten Bereich

Das Zerstören eines Vektors mit ~ Vektor zerstört den Inhalt (Elemente), nicht den Vektoramen. Der Name kann weiterhin in einem inneren Bereich verwendet werden, der immer noch Teil des Interessesbereichs ist. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Vektor vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vector ();
if (1 == 1)
vtr = 'k', 'l', 'm', 'n', 'o';
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;

Rückkehr 0;

Die Ausgabe ist:

K l m n o

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

Den Zielfernrohr verlassen lassen

Wenn ein deklariertes Objekt aus seinem Geltungsbereich ausgeht, kann es nicht mehr aus seinem Geltungsbereich zugegriffen werden. Dies bedeutet, dass es nicht mehr in einem Nistbereich zugegriffen werden kann. Es kann jedoch in einem verschachtelten Bereich zugegriffen werden. Ein verschachtelter Bereich ist immer noch Teil des fraglichen Bereichs.

Zugang in und aus dem Zielfernrohr

Das folgende Programm zeigt, wie ein Vektor im Umfang zugegriffen wird:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)
Vektor vtr = 'a', 'b', 'c', 'd', 'e';
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;

Rückkehr 0;

Die Ausgabe ist:

A b c d e

Der Main () -Funktionsbereich nistet den If-Block-Bereich. VTR, die im IF-Block-Bereich deklariert ist. Es kann nicht außerhalb des If-Block-Bereichs zugegriffen werden. Es kann im Main () -Funktionsblock, der den If-Block nistet, nicht draußen zugegriffen werden. Das folgende Programm wird nicht kompiliert, da ein Versuch unternommen wird, auf den Vektor außerhalb seines Geltungsbereichs zuzugreifen:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)
Vektor vtr = 'a', 'b', 'c', 'd', 'e';
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;

Cout << vtr[1] << endl;
Rückkehr 0;

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

Verschachtelter Umfang

Ein verschachtelter Bereich ist immer noch Teil des fraglichen Bereichs. Das folgende Programm zeigt, wie ein Vektor in einem verschachtelten Bereich zugegriffen werden kann:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

if (1 == 1)
Vektor vtr = 'a', 'b', 'c', 'd', 'e';
if (1 == 1)
für (int i = 0; i < vtr.size(); i++)
Cout << vtr[i] << ";
Cout << endl;


Rückkehr 0;

Die Ausgabe ist:

A b c d e

Der Main () -Funktionsblock nistet den ersten If-Block, der den zweiten If-Block nistet. Der Vektor wird im ersten If-Block deklariert. Es wurde im verschachtelten (inneren) If-Block zugegriffen.

Der Ansatz, den Vektor sterben zu lassen, wenn er aus dem Umfang ausgeht, sieht im Vergleich zur Verwendung des Destruktors vorzuziehen aus. Wenn der Vektor aus dem Umfang ausgeht, stirbt sein Name auch. Es ist jedoch nicht die ganze Zeit, dass der Programmierer möchte, dass der Vektor stirbt, indem er den Geltungsbereich verlässt. Daher muss der Destruktor gelegentlich eingesetzt 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. Der zweite Weg, einen Vektor zu löschen. Normalerweise stirbt ein nicht statisches Objekt, das in einem Zielfernrohr deklariert wird, wenn es aus dem Umfang ausgeht. Dies bedeutet, dass auf das Objekt nicht in einem Nistbereich (Block) zugegriffen werden kann (Block). Ein Verschachtelungsumfang ist ein äußerer Bereich (Block). Es kann jedoch in einem verschachtelten Bereich zugegriffen werden. Ein verschachtelter Bereich ist ein innerer Bereich, der immer noch Teil des Interessensumfangs ist. Beide Wege haben Einschränkungen. Ein Vektor in einem inneren Bereich muss nicht mit ~ Vektor zerstört werden.