Wie konvertieren Sie einen Zeichenvektor in einen Stringvektor in C++?

char arrstr [] = 'i', ", 'l', 'o', 'v', 'e', ​​',' y ',' o ',' u ',' '.',' \ 0 ',' a ',' n ',' y ',' t ',' H ',' I ',' n ',' G ',', 'E', 'L', '' S ',' e ';

Zeichen in einer Reihe von Zeichen, die mit dem NUL -Zeichen enden, ist eine Zeichenfolge. Das oben oben genannte Array enthält tatsächlich die Sätze: „Ich liebe dich."Und" alles andere "durch den Charakter getrennt, '\ 0' '.

Cout << arrStr << endl;

würde drucken:

Ich liebe dich.

etwas anderes ignorieren. Dies ist die traditionelle Art, eine Schnur in C zu haben++. Alles andere sollte nach dem Zeichen '\ 0' ignoriert werden, wenn der Array -Inhalt als Zeichenfolge betrachtet werden soll.

Mit dem Zeiger würde die obige Zeichenfolge als:

const char* ptrstr = "Ich liebe dich.";

Und

Cout << ptrStr << endl;

würde drucken:

Ich liebe dich.

Eine Reihe von Zeichen ist ein konstanter Zeiger auf Zeichen, der mit '\ 0' endet. Dies erklärt, warum Const in der Aussage „const char* ptrstr =„ Ich liebe dich liebe.";"; ". Die Doppelzitate beseitigen die Verwendung der Array -Literalstruktur und '\ 0'.

Mit der String -Klasse wäre ein String -Objekt für die obige Phrase

String objstr = String ("Ich liebe dich.");

Und

Cout << objStr << endl;

würde drucken:

Ich liebe dich.

Das String -Objekt könnte weiterhin so instanziiert werden,

String objstr = string ('i', ", 'l', 'o', 'v', 'e', ​​',' y ',' o ',' u ',' '.',' \ 0 ');

Die indirekte Frage ist. Die direkte Frage ist, wenn diese Werte Elemente des Vektors sind, wie diese Konvertierungen durchgeführt werden können. Dieser Artikel erklärt das.

Denken Sie vor dem Einstieg in die Kernerklärung daran, dass 'e' ein Zeichen ist, während "e" eine Zeichenfolge ist. Um Vektoren von String -Objekten zu verwenden, sollte das Programm mit:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;

Artikelinhalt

• Einführung - siehe oben
• Vektor von Array -Chars an Vektorzeigerchars
• Vektor des Zeigers auf Zeichen zum Vektor von String -Objekten
• Abschluss

Vektor von Array -Chars an Vector of Pointer Chars

In diesem Abschnitt wird erklärt.

Jetzt,

char arrstr [] = 'i', ", 'l', 'o', 'v', 'e', ​​',' y ',' o ',' u ',' '.',' \ 0 ',;

Und

const char* ptrstr = "Ich liebe dich.";

bedeuten dasselbe im Inneren, wie der folgende Code zeigt:

char arrstr [] = 'i', ", 'l', 'o', 'v', 'e', ​​',' y ',' o ',' u ',' '.',' \ 0 ',;
für (int i = 0; arrstr [i] != '\ 0'; i ++)
Cout << arrStr[i];
Cout << endl;
const char* ptrstr = "Ich liebe dich.";
für (int i = 0; ptrstr [i] != '\ 0'; i ++)
Cout << ptrStr[i];
Cout << endl;

Die Ausgabe ist:

Ich liebe dich.
Ich liebe dich

Alle Codesegmente für diesen Artikel befinden sich in der Haupt- () Funktionsbehörde. Für das Array wird der Array -Name mit [i] verwendet, um alle Werte im Array zu lesen. Der Zeigername mit [i] wird verwendet, um alle Werte im String -Literal für den Zeiger zu lesen. Beachten Sie, dass '\ 0' am Ende der wörtlichen Zeichenfolge implizit ist. Was für beide Fälle konstant ist, ist der Zeiger und nicht der Wert. Ein Array -Name ist ein konstanter Zeiger auf die Abfolge von Zeichen, die mit '\ 0' enden sollte.

Ein Vektor von Arrays von Zeichen, bei dem jedes Array mit '\ 0' oder einem Vektor von Doppelquote-Streicheliteralen endet, sollte auf die gleiche Weise wie folgt deklariert werden:

Vektor vtr;

Betrachten Sie den folgenden Vektor von Obstnamen, bei dem jeder Fruchtname eine Reihe von Schichten ist und mit '\ 0' endet.

char fruit1 [] = 'p', 'a', 'p', 'a', 'y', 'a', '\ 0';
char fruit2 [] = 's', 't', 'r', 'a', 'w', 'b', 'e', ​​'r', 'r', 'y', '\ 0' ' ;
char fruit3 [] = 'p', 'a', 's', 's', 'i', 'o', 'n', ',' f ',' r ',' u ',' ich ',' t ',' \ 0 ';
char fruit4 [] = 'b', 'a', 'n', 'a', 'n', 'a', '\ 0';
char fruit5 [] = 'o', 'r', 'a', 'n', 'g', 'e', ​​'\ 0';
Vektor vtr fruit1, fruit2, fruit3, fruit4, fruit5;

Der Früchtevektor wurde durch das Schreiben der Array -Namen als Elemente im Vektor errichtet. Der gleiche Vektor kann wie folgt mit String -Literalen konstruiert werden:

Vektor vtr = "Papaya", "Strawberry", "Passion Fruit", "Banane", "Orange";

Es ist also nicht erforderlich, einen Vektor von Arrays-of-Gärern in einen Vektor von const-Pointers-zu-Autos umzuwandeln. Sie sind dasselbe, darunter. Da sie dasselbe sind, kann ein Array-String-Wert in einen const-peinstabs-zu-Autos gelesen werden, wie der folgende Code zeigt:

char fruit1 [] = 'p', 'a', 'p', 'a', 'y', 'a', '\ 0';
char fruit2 [] = 's', 't', 'r', 'a', 'w', 'b', 'e', ​​'r', 'r', 'y', '\ 0' ' ;
char fruit3 [] = 'p', 'a', 's', 's', 'i', 'o', 'n', ',' f ',' r ',' u ',' ich ',' t ',' \ 0 ';
char fruit4 [] = 'b', 'a', 'n', 'a', 'n', 'a', '\ 0';
char fruit5 [] = 'o', 'r', 'a', 'n', 'g', 'e', ​​'\ 0';
Vektor vtr fruit1, fruit2, fruit3, fruit4, fruit5;
für (int i = 0; iconst char* str = vtr [i];
Cout << str << ", ";

Cout << endl;

Die Ausgabe ist:

Papaya, Erdbeere, Passionsfrucht, Banane, Orange,

Die Linie,

const char* str = vtr [i];

ist der Ort, an dem die vermeintliche Umwandlung stattfindet.

Vektor des Zeigers auf Zeichen zum Vektor von String -Objekten

Die Frage der Umwandlung eines Vektors von Zeiger-auf-Autos in die Vektor der String-Objekte ist die gleiche Frage, wie Sie einen Vektor von Arrays-of-CAR-Vektor in die Vektor-Saest-Objekte umwandeln können. Betrachten Sie die folgende Erklärung:

Vektor
vtr = "Papaya", "Strawberry", "Passion Fruit", "Banane", "Orange";

Die folgende Erklärung hat die obige Deklaration in String -Objektformular:

Vektor
vtr = String ("Papaya"), String ("Strawberry"), String ("Passion Fruit"), String ("Banana"), String ("Orange");

In diesem Fall muss „#include“ ganz oben im Programm stehen. Beachten Sie das Vorlagenargument und die String -Objektwerte.

Jetzt ist es möglich, ein String -Literal zuzuweisen und zum Inhalt eines String -Objekts zu werden, wie die folgenden drei Codesegmente zeigen:

String str = "ABC";
const char* strlit = "abc";
String str = strlit;
char arr [] = 'a', 'b', 'c', '\ 0';
String str = arr;

Mit diesem Wissen kann jeder String -Literal in eine String -Objektvariable gelesen werden, wie der folgende Code zeigt:

Vektor vtr = "Papaya", "Strawberry", "Passion Fruit", "Banane", "Orange";
für (int i = 0; iString str = vtr [i];
Cout << str << ", ";

Cout << endl;

Die Ausgabe ist:

Papaya, Erdbeere, Passionsfrucht, Banane, Orange,

Die Linie, die die Konvertierung von wörtlich zu String -Objekt durchführt, lautet:

String str = vtr [i];

Wenn die Vektorwerte Array -Zeichenfolgen waren, wird der folgende Code dasselbe tun:

char fruit1 [] = 'p', 'a', 'p', 'a', 'y', 'a', '\ 0';
char fruit2 [] = 's', 't', 'r', 'a', 'w', 'b', 'e', ​​'r', 'r', 'y', '\ 0' ' ;
char fruit3 [] = 'p', 'a', 's', 's', 'i', 'o', 'n', ',' f ',' r ',' u ',' ich ',' t ',' \ 0 ';
char fruit4 [] = 'b', 'a', 'n', 'a', 'n', 'a', '\ 0';
char fruit5 [] = 'o', 'r', 'a', 'n', 'g', 'e', ​​'\ 0';
Vektor vtr fruit1, fruit2, fruit3, fruit4, fruit5;
für (int i = 0; iString str = vtr [i];
Cout << str << ", ";

Cout << endl;

Die Ausgabe ist gleich:

Papaya, Erdbeere, Passionsfrucht, Banane, Orange,

Die Linie, die die Konvertierung von wörtlich zu einem String -Objekt durchführt, ist immer noch dieselbe:

String str = vtr [i];

Vektor von String -Literalen zum Vektor von String -Objekten

Um einen Vektor von String -Literalen in einen Vektor von String -Objekten zu ändern, muss die folgende Prozedur befolgt werden:

• Erstellen Sie einen anderen leeren Vektor, aber diesmal einen Vektor von String -Objekten.
• Kopieren Sie jede Zeichenfolge, die wörtlich aus dem Vektor von const-character-Pointern in den Vektor von String-Objekten durch Drücken kopieren.
• Zerstöre den alten Vektor von Literalen.

Der folgende Code zeigt dies:

Vektor vtr = "Papaya", "Strawberry", "Passion Fruit", "Banane", "Orange";
Vektor vtrnew;
für (int i = 0; ivtrnew.push_back (vtr [i]);

vtr.~ vector ();
für (int i = 0; iString str = vtrnew [i];
Cout << str << ", ";

Cout << endl;

Die Ausgabe ist:

Papaya, Erdbeere, Passionsfrucht, Banane, Orange,

Die Zeile für den Code, der den alten Vektor zerstört, lautet:

vtr.~ vector ();

Der Inhalt des Vektors wird zerstört, aber nicht der Vektorame. Der alte Vektorame kann jedoch nicht wiederverwendet werden (im selben Bereich).

Abschluss

Ein Array -String -Literal und ein konstanter Zeiger auf Zeichensequenz buchstäblich sind die gleichen Dinge darunter. Ein Array -String -Literal ist ein Array -Literal aus Zeichen, das mit '\ 0' endet. Eine const-zinter-zu-char-Sequenz-Literalsequenz von aufeinanderfolgenden Zeichen, die durch Doppelzitate begrenzt sind, e.G., "ABC". '\ 0' ist am Ende des CONT-Zeigers-zu-Char-Sequenz-Literales implizit.

Ein Array-String-Literal oder ein CONT-Zeiger-zu-Char-Sequenz-Literal kann der Kennung einer Const-Zeiger-zu-Char-Sequenz zugeordnet werden, wie im folgenden Code-Segment dargestellt:

char arr [] = 'a', 'b', 'c', '\ 0';
const char* ss = "def";
ss = arr;
const char* SSS = ss;

Es besteht kein wirklicher Bedarf, einen Vektor von Array-Zeichenfolgen in einen Vektor von Streichliteralen in Doppelquoten umzuwandeln. Es reicht aus, jede Array-Zeichenfolge des Vektors zur Kennung einer Konstant-Zeiger-zu-Char-Sequenz zu lesen.

Wenn jedoch ein Vektor von String -Objekten von einem Vektor von String -Literalen wirklich benötigt wird, sollte die Umwandlung wie folgt durchgeführt werden:

• Erstellen Sie einen anderen leeren Vektor, aber diesmal einen Vektor von String -Objekten.
• Kopieren Sie jede Zeichenfolge, die wörtlich aus dem Vektor von const -Zeichenzeiger zum Vektor von String -Objekten durch Drücken kopieren.
• Zerstöre den alten Vektor von Literalen.

Zerstören eines Vektors bedeutet, seinen Inhalt (Elemente) zu zerstören, aber nicht den Namen des Vektors.