Nel dominio della programmazione C++, dare priorità all’efficienza e alle prestazioni è fondamentale. La classe 'std::string_view', introdotta in C++17, presenta un'alternativa versatile ed efficiente in termini di memoria alla tradizionale manipolazione delle stringhe. Fondamentalmente, 'std::string_view' è un riferimento non proprietario a una sequenza di caratteri, che comunemente rappresenta una sottostringa di una stringa più grande. A differenza di 'std::string' che possiede i propri dati e gestisce la memoria internamente, 'std::string_view' funziona senza possedere i dati sottostanti. Questa caratteristica lo rende particolarmente utile per scenari in cui il sovraccarico derivante dalla copia o dalla gestione della memoria non è auspicabile. In questo articolo esploreremo i diversi esempi per comprendere l'utilizzo di 'std::string_view' in C++.
Esempio 1: gestione efficiente delle stringhe
Nel moderno sviluppo C++, una gestione efficiente delle stringhe è fondamentale per ottimizzare le prestazioni e l'utilizzo delle risorse. Consente un accesso e una manipolazione efficienti delle stringhe senza la necessità di riallocazione o duplicazione della memoria. Per illustrare questo concetto, approfondiamo un esempio pratico.
Considera il seguente frammento di codice:
#include
#include
void processStringView ( std::string_view strView ) {
std::cout << 'Lunghezza: ' << strView.lunghezza ( ) << std::endl;
std::cout << 'Contenuto: ' << strView << std::endl;
}
int principale ( ) {
std::string stringaoriginale = 'Gestione efficiente delle stringhe' ;
std::string_view viewOfString ( OriginalString ) ;
processStringView ( vistaOfString ) ;
ritorno 0 ;
}
In questo esempio, abbiamo la funzione “processStringView” che accetta “std::string_view” come parametro. La funzione quindi stampa la lunghezza e il contenuto della vista stringa utilizzando l'output standard. La funzione principale inizializza la 'std::string' denominata 'originalString' con il valore 'Efficient String Handling'. Successivamente viene creata la “std::string_view” denominata “viewOfString”, che fa riferimento al contenuto di “originalString”.
Passando 'viewOfString' alla funzione 'processStringView', possiamo eseguire le operazioni sulla stringa in modo efficiente, eliminando la necessità di allocazioni di memoria aggiuntive. 'std::string_view' è un riferimento leggero alla sequenza di caratteri sottostante di 'originalString' senza copiare i dati.
Ecco l'output generato:
Esempio 2: interoperabilità con il codice legacy
Nell'ambito dello sviluppo C++, la perfetta integrazione di basi di codice nuove e vecchie è spesso una preoccupazione critica. 'std::string_view' consente agli sviluppatori di interagire facilmente con le funzioni legacy che restituiscono i puntatori 'const char'.
Considera l'esempio seguente che dimostra l'uso pratico di 'std::string_view' per l'interoperabilità. Qui abbiamo una funzione legacy denominata “legacyFunction()” che restituisce un puntatore “const char”:
#include#include
const car * legacyFunction ( ) {
ritorno 'Corda legacy' ;
}
int principale ( ) {
std::string_view legacyStrView ( legacyFunction ( ) ) ;
std::cout << 'Vista stringa precedente: ' << legacyStrView << std::endl;
ritorno 0 ;
}
Iniziamo definendo una funzione legacy denominata 'legacyFunction()' che restituisce un puntatore 'const char' che rappresenta una stringa etichettata come 'Legacy String'. Per incorporare perfettamente questi dati legacy nel nostro moderno programma C++, utilizziamo 'std::string_view'. Nella funzione main(), nello specifico, creiamo un'istanza di “std::string_view” denominata “legacyStrView” e la inizializziamo con il risultato della funzione legacy. Questa istanziazione ci consente di incapsulare e lavorare in modo efficiente con il puntatore legacy “const char”.
Di conseguenza, possiamo accedere e manipolare la stringa legacy senza ricorrere a copie non necessarie dei dati, preservando sia l'efficienza che la compatibilità. Il passaggio finale del codice prevede l'utilizzo di 'std::cout' per stampare il contenuto della vista stringa legacy.
L'output eseguito è:
Esempio 3: gestione migliorata delle stringhe letterali
Le stringhe letterali in C++ sono tradizionalmente rappresentate come matrici di caratteri. 'std::string_view' semplifica il lavoro con i valori letterali stringa fornendo un'interfaccia comoda. Consentendo un accesso diretto all'array di caratteri sottostante senza la necessità di conversioni esplicite, 'std::string_view' semplifica le operazioni sulle stringhe letterali.
#include#include
int principale ( ) {
const car * myLiteral = 'Ciao, Visualizzazione Stringa!' ;
std::string_view vista letterale ( myLiteral ) ;
std::cout << 'Primo carattere: ' << vista letterale [ 0 ] << std::endl;
size_t posizione =literalView.find ( 'Corda' ) ;
std::cout << 'Posizione della sottostringa: ' << posizione << std::endl;
ritorno 0 ;
}
In questo esempio, un messaggio 'Hello, String View!' la stringa letterale viene assegnata al puntatore 'myLiteral'. L'introduzione di “std::string_view” facilita una rappresentazione più efficiente di questa stringa senza la necessità di copiarne il contenuto. L'oggetto “literalView” viene creato utilizzando il puntatore “myLiteral” che ci consente di visualizzare e manipolare la sequenza di caratteri sottostante.
L'utilizzo di 'std::string_view' fornisce un facile accesso ai singoli caratteri all'interno della stringa. Nello snippet di codice, 'literalView[0]' recupera e stampa il primo carattere della stringa, mostrando la semplicità e l'immediatezza dell'accesso agli elementi. Il metodo 'find' di 'std::string_view' viene utilizzato per determinare la posizione della sottostringa 'String' all'interno della stringa originale.
Esempio 4: estrazione di sottostringhe
L'attività di estrazione della sottostringa prevede il recupero di una porzione di una determinata stringa in base a criteri specifici come la posizione di un delimitatore. La capacità di estrarre facilmente le sottostringhe è una potente funzionalità di 'std::string_view'. Considera uno scenario in cui dobbiamo estrarre una porzione di una stringa in base a un delimitatore:
#include#include
int principale ( ) {
std::string fullString = 'mela-arancia-banana' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , delimitatorePos ) ;
std::cout << 'Sottostringa estratta: ' << sottostringa << std::endl;
ritorno 0 ;
}
In questo frammento di codice iniziamo con la dichiarazione di una stringa originale, 'fullString', che viene inizializzata con il valore 'apple-orange-banana'. Il nostro obiettivo è eseguire l'estrazione della sottostringa. Per raggiungere questo obiettivo, utilizziamo la funzione 'trova' fornita dalla libreria standard C++.
Una volta individuata la posizione del delimitatore all'interno della “fullString”, memorizzata nella variabile “delimiterPos”, estraiamo la sottostringa desiderata. Sulla stringa originale viene chiamata la funzione “substr”, specificando la posizione iniziale (0) e la lunghezza della sottostringa che è proprio la posizione del delimitatore. Questa operazione comporta la creazione della “std::string_view” denominata “subString” che rappresenta la porzione della stringa originale dall'inizio fino al delimitatore.
Esempio 5: strutture dati efficienti in termini di memoria
'std::string_view' gioca un ruolo cruciale nella progettazione di strutture dati efficienti in termini di memoria. Invece di memorizzare più copie di stringhe, le strutture dati possono memorizzare le istanze “std::string_view”, riducendo così il sovraccarico della memoria.
#include#include
struttura Registra {
std::string_view nome;
età intera;
} ;
int principale ( ) {
Registra persona = { 'John Doe' , 30 } ;
std::cout << 'Nome: ' << nome.persona << ', Età: ' << personaggio << std::endl;
ritorno 0 ;
}
In questo frammento di codice mostriamo l'utilizzo di 'std::string_view' all'interno di una struttura dati efficiente in termini di memoria. Definiamo una struttura “Record” che comprende un membro “std::string_view” denominato “name” e un membro intero denominato “age”. L'uso di 'std::string_view' in questo contesto ci consente di creare una rappresentazione leggera di una stringa senza la necessità di allocare memoria aggiuntiva.
Nella funzione 'main', istanziamo un oggetto 'Record' denominato 'persona' con il nome 'John Doe' e l'età di 30 anni. Il 'nome' del membro 'std::string_view' funge da vista non proprietaria di i dati dei caratteri corrispondenti al nome, eliminando la necessità di duplicare il contenuto della stringa. Il “std::cout << “Nome: ” << persona.nome << “, Età: ” << persona.età << std::endl;” l'istruzione restituisce il nome e l'età della persona che sono memorizzati nell'oggetto 'Record'.
Conclusione
Nel panorama in continua evoluzione dello sviluppo C++, “std::string_view” si distingue come una preziosa aggiunta al toolkit del programmatore. Gli esempi illustrati in questo articolo evidenziano l'adattabilità e l'utilità di 'std::string_view' nell'ambito della programmazione C++. Dall'efficiente manipolazione delle stringhe e dalla perfetta interoperabilità con il codice legacy alle strutture dati efficienti in termini di memoria, 'std::string_view' è prezioso per gli sviluppatori che cercano prestazioni migliorate e codice ottimizzato in diversi scenari. Questi scenari reali dimostrano come “std::string_view” possa ottimizzare il codice, ridurre il sovraccarico di memoria non necessario e contribuire all'efficienza complessiva delle applicazioni C++.