Stringa C ++ inversa
Una stringa può essere creata in due modi principali in C++. Una stringa può essere creata come puntatore costante a una sequenza di caratteri. Una stringa può anche essere creata istanziando un oggetto stringa dalla classe stringa. Questo articolo tratta gli oggetti stringa istanziati dalla classe stringa. Ciò significa che la libreria String deve essere inclusa per eseguire i campioni di codice in questo articolo.
Un oggetto stringa è una struttura di dati in cui la stringa letterale è un elenco. Ogni personaggio è di un elemento nell'elenco. E così, una corda letterale può essere gestita come una serie di elementi.
Questo articolo spiega la soluzione classica per invertire una stringa in C++. Questo essenzialmente ripete la corda letterale, all'indietro. Avere una conoscenza sommaria dell'iterazione in avanti consente al lettore di comprendere meglio l'iterazione inversa. Questo articolo tratta gli oggetti stringa istanziati dalla classe stringa.
Tutto il codice stringa per questo tutorial è scritto nella funzione C ++ main () se non diversamente indicato.
Contenuto dell'articolo
- Iterazione stringa in avanti
- Iterazione inversa della stringa
- String Iterazione inversa costante
- Conclusione
Iterazione in avanti
Un iteratore è una classe di punta da cui è possibile istanziare gli oggetti dell'iteratore. Un oggetto iteratore può essere utilizzato per scansionare gli elementi della stringa dall'inizio dell'elenco delle stringhe alla fine dell'elenco delle stringhe. La funzione del membro della stringa, inizio (), restituisce un iteratore che indica il primo elemento della stringa letterale. Può essere incrementato fino a quando non raggiunge, subito dopo l'ultimo elemento della stringa. La funzione del membro della stringa, end (), restituisce un iteratore che punta subito dopo l'ultimo elemento della stringa letterale. Può essere decrementato fino a raggiungere, l'ultimo elemento della stringa. Questi due iteratori sono considerati iteratori in avanti, sebbene il secondo si ipotizza all'indietro.
Per un oggetto stringa con il nome della variabile, STR, la seguente istruzione restituirà un Iteratore iniziale:
String :: iterator P = STR.inizio();
Qui, P è un Iteratore di inizio. Un iteratore finale può essere restituito dalla seguente affermazione:
String :: iteratore Q = STR.FINE();
Qui, Q è un iteratore finale. P e Q sopra sono dello stesso tipo e possono anche essere scambiati.
Il seguente codice stampa tutti i caratteri della stringa, dall'inizio alla fine:
String str = 'v', 'w', 'x', 'y', 'z', '\ 0';
per (String :: iterator P = STR.inizio(); P != str.FINE(); p ++)
cout << *p << ";
cout << endl;
L'output è:
v w x y z
'\ 0' non deve essere stampato. Dovrebbe essere lì per segnare la fine della corda letterale. Nota come è stato ottenuto l'iteratore di inizio. L'iterazione scansiona l'elenco pungente dall'inizio alla fine, confrontando l'iteratore di ciascun elemento con quello restituito da STR.inizio(); Dopo l'incremento. Quando l'iteratore restituito è quello subito dopo l'ultimo elemento, l'iteratura si ferma. Un iteratore viene incrementato o decrementato allo stesso modo di un indice. L'espressione, *p restituisce il valore indicato, dall'iteratore, p.
Il seguente codice stampa i valori nella stringa, dall'ultimo carattere al primo carattere, usando l'iteratore finale:
String str = "Vwxyz";
String :: iteratore Q = STR.FINE();
per (q = --q; q> = str.inizio(); Q--)
cout << *q << ";
cout << endl;
L'output è:
z y x w v v
Questa è un'inversione indiretta di una stringa. L'eteratore finale punta subito dopo la fine della stringa letterale, e un tale punto non è un elemento. Affinché indichi l'ultimo elemento, deve essere decrementato. Da lì, l'iterazione può andare all'indietro.
Per questo motivo, l'iteratore finale è stato dichiarato al di fuori del loop. Il valore iniziale dell'iteratore nel per loop è un singolo decremento. L'iteratore viene decrementato in passaggi fino a raggiungere il primo elemento come indicato da "STR.inizio()". Questo è un modo informale per iterare l'indietro. Cioè, questo è un modo informale per invertire un vettore (indirettamente).
Cambiare il carattere di un elemento
L'oggetto stringa è una struttura di dati, in cui la stringa letterale è di un elenco. L'elenco è costituito da elementi. Ogni elemento ha un carattere e quel carattere è il valore dell'elemento. I caratteri sono anche valori della stringa. La stringa completa letterale è il valore dell'oggetto stringa.
Quando la dichiarazione dell'oggetto stringa non è preceduta da const (per costante), il valore di qualsiasi elemento nella stringa può essere modificato. Illustrazione:
String str = "Vwxyz";
String :: iteratore Q = STR.FINE();
Q--; Q--; Q--;
*q = 'a';
String :: iterator b = str.FINE();
per (b = - -b; b> = str.inizio(); B--)
cout << *B << ";
cout << endl;
L'output è:
z y a w v
"Q-; Q-; Q-;"Decremento l'iteratore finale 3 volte per puntare a" C ".
Quando la dichiarazione dell'oggetto stringa è preceduta da const, i caratteri sono di sola lettura. Per tale codice, l'iteratore restituito deve essere const_iterator. In questo caso, il codice non si compila. Il seguente codice emetterà un messaggio di errore:
const string str = "vwxyz";
String :: const_iterator Q = STR.FINE();
Q--; Q--; Q--;
*q = 'a';
Iterazione inversa
L'iteratore utilizzato con iterazione inversa è reverse_iterator. Un'altra funzione membro della classe String è, Rend (), che restituisce un iteratore che punta proprio davanti al primo elemento dell'oggetto stringa. Tuttavia, un'altra funzione membro della classe String è rbegin (), che restituisce un iteratore che indica l'ultimo elemento dell'oggetto stringa. Il seguente codice illustra l'uso del retrod_iterator restituito, leggendo nella direzione in avanti, dal primo elemento all'ultimo elemento:
String str = "Vwxyz";
String :: inverse_iterator P = STR.rend ();
per (p = - -p; p> = str.rbegin (); P--)
cout << *p << ";
cout << endl;
L'output è:
v w x y z
Si noti che con il reverse_iterator, ++ è - e =, nella condizione di while.
Il seguente codice itera indietro, utilizzando l'iteratore di rbegin ():
String str = "Vwxyz";
per (String :: Inverse_iterator Q = STR.rbegin (); Q <= str.rend(); q++)
cout << *q << ";
cout << endl;
L'output è:
z y x w v v
Ancora una volta, ++ viene usato al posto di - e = = .
Cambiare il carattere di un elemento
Quando la dichiarazione dell'oggetto stringa non è preceduta da const (per costante), il valore di qualsiasi elemento nella stringa può essere modificato. Illustrazione:
String str = "Vwxyz";
String :: inverse_iterator Q = STR.rbegin ();
Q ++; Q ++;
*q = 'a';
per (String :: Inverse_iterator b = STR.rbegin (); B <= str.rend(); B++)
cout << *B << ";
cout << endl;
L'output è:
z y a w v
L'iteratore rbegin (), Q, viene decrementato due volte con “Q ++; Q ++; " puntare a 'c', poiché inizialmente indica l'ultimo elemento.
Se un oggetto stringa è preceduto con const, allora i non possono essere modificati con qualsiasi tipo di iteratore. Il compilatore emetterà un messaggio di errore per il seguente codice perché il codice tenta di modificare il valore di "C":
const string str = "vwxyz";
String :: const_reverse_iterator Q = STR.rbegin ();
Q ++; Q ++;
*q = 'a';
String Iterazione inversa costante
Un const_reverse_iterator viene restituito dalla funzione membro, Crbegin (). Crbegin () è come rbegin (), ma il valore indicato dal suo iteratore non può essere modificato. Un const_reverse_iterator viene restituito anche da un'altra funzione membro, cred (). cred () è come rend (), ma il valore indicato, dal suo iteratore, non può essere modificato.
Il seguente codice visualizza tutti i valori dell'oggetto stringa, usando const_reverse_iterator, a partire dall'ultimo elemento:
const string str = "vwxyz";
per (String :: const_reverse_iterator Q = STR.Crbegin (); Q <= str.crend(); q++)
cout << *q << ";
cout << endl;
L'output è:
z y x w v v
Sebbene la dichiarazione dell'oggetto stringa non sia preceduta da const, il seguente codice non compilerà. Ciò è dovuto all'uso di const_reverse_iterator. Anche se la dichiarazione fosse preceduta da const, non sarebbe comunque compilata per lo stesso motivo. Il codice è:
const string str = "vwxyz";
String :: const_reverse_iterator Q = STR.Crbegin ();
Q ++; Q ++;
*q = 'a';
Conclusione
La classe String non ha una funzione membro per invertire una stringa. Tuttavia, una stringa può essere invertita indirettamente ripetuta da una parte anteriore. Le funzioni del membro coinvolte sono, end (), inizio (), rend (), rbegin (), cred () e crbegin (). Iteratori coinvolti sono iterator, reverse_iterator e const_reverse_iterator. Queste caratteristiche sono combinate per produrre un'inversione indiretta ma comunque efficace del letterale di un oggetto stringa.