Dans le domaine de la programmation C++, donner la priorité à l’efficacité et aux performances est crucial. La classe « std::string_view », introduite en C++17, présente une alternative polyvalente et économe en mémoire à la manipulation de chaînes traditionnelle. À la base, « std::string_view » est une référence non propriétaire à une séquence de caractères, représentant généralement une sous-chaîne d'une chaîne plus grande. Contrairement à « std :: string » qui possède ses données et gère la mémoire en interne, « std :: string_view » fonctionne sans posséder les données sous-jacentes. Cette caractéristique le rend particulièrement utile pour les scénarios dans lesquels la surcharge liée à la copie ou à la gestion de la mémoire n'est pas souhaitable. Dans cet article, nous explorerons les différents exemples pour comprendre l'utilisation de « std::string_view » en C++.
Exemple 1 : gestion efficace des chaînes
Dans le développement C++ moderne, une gestion efficace des chaînes est cruciale pour optimiser les performances et l’utilisation des ressources. Il permet un accès et une manipulation efficaces des chaînes sans avoir besoin de réallocation ou de duplication de mémoire. Pour illustrer ce concept, examinons un exemple pratique.
Considérez l'extrait de code suivant :
#include
#include
Annuler le processusStringView ( std :: string_view strView ) {
std :: cout << 'Longueur: ' << strView.longueur ( ) << std::endl;
std :: cout << 'Contenu: ' << strView << std::endl;
}
int main ( ) {
std :: chaîne chaîne originale = 'Gestion efficace des chaînes' ;
std :: string_view viewOfString ( chaîne d'origine ) ;
processusStringView ( vueDeChaîne ) ;
retour 0 ;
}
Dans cet exemple, nous avons la fonction « processStringView » qui prend « std::string_view » comme paramètre. La fonction imprime ensuite la longueur et le contenu de la vue chaîne en utilisant la sortie standard. La fonction principale initialise le « std::string » nommé « originalString » avec la valeur « Efficient String Handling ». Par la suite, le « std::string_view » nommé « viewOfString » est créé, faisant référence au contenu de « originalString ».
En passant le « viewOfString » à la fonction « processStringView », nous pouvons effectuer les opérations sur la chaîne de manière efficace, éliminant ainsi la nécessité d'allocations de mémoire supplémentaires. Le « std :: string_view » est une référence légère à la séquence de caractères sous-jacente de « originalString » sans copier les données.
Voici le résultat généré :
Exemple 2 : Interopérabilité avec le code hérité
Dans le domaine du développement C++, l’intégration transparente des nouvelles et anciennes bases de code constitue souvent une préoccupation majeure. Le « std :: string_view » permet aux développeurs d'interagir sans effort avec les fonctions héritées qui renvoient les pointeurs « const char ».
Considérez l'exemple suivant qui démontre l'utilisation pratique de « std::string_view » pour l'interopérabilité. Ici, nous avons une fonction héritée nommée « legacyFunction() » qui renvoie un pointeur « const char » :
#include#include
const char * fonctionhéritage ( ) {
retour 'Chaîne héritée' ;
}
int main ( ) {
std :: string_view LegacyStrView ( fonctionhéritage ( ) ) ;
std :: cout << « Vue de chaîne héritée : » << LegacyStrView << std::endl;
retour 0 ;
}
Nous commençons par définir une fonction héritée nommée « legacyFunction() » qui renvoie un pointeur « const char » qui représente une chaîne étiquetée comme « Legacy String ». Pour intégrer de manière transparente ces données héritées dans notre programme C++ moderne, nous utilisons le « std::string_view ». Dans la fonction main(), en particulier, nous créons une instance de « std::string_view » nommée « legacyStrView » et l'initialisons avec le résultat de la fonction héritée. Cette instanciation nous permet d'encapsuler et de travailler efficacement avec l'ancien pointeur « const char ».
En conséquence, nous pouvons accéder et manipuler la chaîne héritée sans recourir à une copie inutile des données, préservant ainsi l'efficacité et la compatibilité. La dernière étape du code consiste à utiliser « std :: cout » pour imprimer le contenu de la vue chaîne héritée.
La sortie exécutée est :
Exemple 3 : gestion améliorée des littéraux de chaîne
Les littéraux de chaîne en C++ sont traditionnellement représentés sous forme de tableaux de caractères. Le « std :: string_view » simplifie le travail avec les chaînes littérales en fournissant une interface pratique. En permettant un accès direct au tableau de caractères sous-jacent sans avoir besoin de conversions explicites, « std::string_view » rationalise les opérations sur les chaînes littérales.
#include#include
int main ( ) {
const char * monLittéral = 'Bonjour, vue chaîne !' ;
std :: string_view vue littérale ( monLittéral ) ;
std :: cout << 'Premier personnage : ' << vue littérale [ 0 ] << std::endl;
position size_t = literalView.find ( 'Chaîne' ) ;
std :: cout << 'Position de la sous-chaîne : ' << position << std::endl;
retour 0 ;
}
Dans cet exemple, un message « Hello, String View ! » La chaîne littérale est affectée au pointeur « myLiteral ». L'introduction de « std::string_view » facilite une représentation plus efficace de cette chaîne sans avoir besoin de copier son contenu. L'objet « literalView » est créé à l'aide du pointeur « myLiteral » qui nous permet de visualiser et de manipuler la séquence de caractères sous-jacente.
L'utilisation de « std :: string_view » fournit un accès facile aux caractères individuels de la chaîne. Dans l'extrait de code, « literalView[0] » récupère et imprime le premier caractère de la chaîne, démontrant la simplicité et la simplicité d'accès aux éléments. La méthode « find » de « std::string_view » est utilisée pour déterminer la position de la sous-chaîne « String » dans la chaîne d'origine.
Exemple 4 : Extraction de sous-chaînes
La tâche d'extraction de sous-chaîne consiste à récupérer une partie d'une chaîne donnée en fonction de critères spécifiés tels que la position d'un délimiteur. La possibilité d'extraire sans effort les sous-chaînes est une fonctionnalité puissante de « std :: string_view ». Prenons un scénario dans lequel nous devons extraire une partie d'une chaîne en fonction d'un délimiteur :
#include#include
int main ( ) {
std :: chaîne fullString = 'pomme-orange-banane' ;
size_t délimiteurPos = fullString.find ( '-' ) ;
std :: string_view subString = fullString.substr ( 0 , délimiteurPos ) ;
std :: cout << « Sous-chaîne extraite : » << sous-chaîne << std::endl;
retour 0 ;
}
Dans cet extrait de code, nous commençons par la déclaration d'une chaîne originale, « fullString », qui est initialisée avec la valeur « pomme-orange-banane ». Notre objectif est d'effectuer l'extraction de sous-chaîne. Pour y parvenir, nous utilisons la fonction « find » fournie par la bibliothèque standard C++.
Une fois que nous avons identifié la position du délimiteur dans le « fullString », stocké dans la variable « delimiterPos », nous extrayons la sous-chaîne souhaitée. La fonction « substr » est appelée sur la chaîne d'origine, en précisant la position de départ (0) et la longueur de la sous-chaîne qui est précisément la position du délimiteur. Cette opération aboutit à la création du « std::string_view » nommé « subString » qui représente la partie de la chaîne d'origine depuis le début jusqu'au délimiteur.
Exemple 5 : Structures de données économes en mémoire
Le « std :: string_view » joue un rôle crucial dans la conception de structures de données économes en mémoire. Au lieu de stocker plusieurs copies de chaînes, les structures de données peuvent stocker les instances « std::string_view », réduisant ainsi la surcharge de mémoire.
#include#include
enregistrement de structure {
std :: nom de string_view ;
âge entier ;
} ;
int main ( ) {
Enregistrer la personne = { 'John Doe' , 30 } ;
std :: cout << 'Nom: ' << nom d'une personne << ', Âge: ' << personnage << std::endl;
retour 0 ;
}
Dans cet extrait de code, nous présentons l'utilisation de « std::string_view » dans une structure de données économe en mémoire. Nous définissons une structure « Record » qui comprend un membre « std::string_view » nommé « name » et un membre entier appelé « age ». L'utilisation de « std::string_view » dans ce contexte nous permet de créer une représentation légère d'une chaîne sans avoir besoin d'allocation de mémoire supplémentaire.
Dans la fonction « main », nous instancions un objet « Record » nommé « personne » avec le nom « John Doe » et l'âge de 30 ans. Le membre « std::string_view » « nom » sert de vue non propriétaire de les données de caractères correspondant au nom, éliminant ainsi la nécessité de dupliquer le contenu de la chaîne. Le « std :: cout << « Nom : » << personne.nom << « , Âge : » << personne.age << std :: endl; » L'instruction affiche le nom et l'âge de la personne qui sont stockés dans l'objet « Enregistrement ».
Conclusion
Dans le paysage en constante évolution du développement C++, « std::string_view » s'impose comme un ajout précieux à la boîte à outils du programmeur. Les instances illustrées dans cet article mettent en évidence l'adaptabilité et l'utilité de « std::string_view » dans le domaine de la programmation C++. De la manipulation efficace des chaînes à l'interopérabilité transparente avec le code existant en passant par les structures de données économes en mémoire, « std::string_view » est précieux pour les développeurs qui recherchent des performances améliorées et un code optimisé dans divers scénarios. Ces scénarios réels démontrent comment « std::string_view » peut optimiser le code, réduire la surcharge de mémoire inutile et contribuer à l'efficacité globale des applications C++.