In het domein van C++-programmeren is het van cruciaal belang dat prioriteit wordt gegeven aan efficiëntie en prestaties. De klasse “std::string_view”, geïntroduceerd in C++17, biedt een veelzijdig en geheugenefficiënt alternatief voor traditionele stringmanipulatie. In de kern is “std::string_view” een niet-eigen verwijzing naar een reeks tekens, die doorgaans een subtekenreeks van een grotere tekenreeks vertegenwoordigen. In tegenstelling tot “std::string” dat eigenaar is van zijn gegevens en het geheugen intern beheert, werkt “std::string_view” zonder eigenaar te zijn van de onderliggende gegevens. Deze eigenschap maakt het bijzonder waardevol voor scenario's waarin de overhead van het kopiëren of beheren van het geheugen ongewenst is. In dit artikel zullen we de verschillende voorbeelden verkennen om het gebruik van “std::string_view” in C++ te begrijpen.
Voorbeeld 1: Efficiënte stringverwerking
Bij moderne C++-ontwikkeling is efficiënte stringafhandeling cruciaal voor het optimaliseren van de prestaties en het gebruik van bronnen. Het maakt een efficiënte toegang en manipulatie van strings mogelijk zonder dat geheugenherschikking of duplicatie nodig is. Om dit concept te illustreren, gaan we dieper in op een praktisch voorbeeld.
Beschouw het volgende codefragment:
#include
#include
ongeldige processStringView ( std::string_view strView ) {
std::uit << 'Lengte: ' << strView.lengte ( ) << std::endl;
std::uit << 'Inhoud: ' << strBekijk << std::endl;
}
int. hoofd ( ) {
std::stringorigineleString = 'Efficiënte stringverwerking' ;
std::string_view viewOfString ( origineelString ) ;
processStringView ( weergaveVanString ) ;
opbrengst 0 ;
}
In dit voorbeeld hebben we de functie “processStringView” die “std::string_view” als parameter gebruikt. De functie drukt vervolgens de lengte en inhoud van de tekenreeksweergave af met behulp van de standaarduitvoer. De hoofdfunctie initialiseert de “std::string” met de naam “originalString” met de waarde “Efficient String Handling”. Vervolgens wordt de “std::string_view” met de naam ‘viewOfString” aangemaakt, verwijzend naar de inhoud van “originalString”.
Door de “viewOfString” door te geven aan de “processStringView” functie, kunnen we de bewerkingen op de string efficiënt uitvoeren, waardoor de noodzaak voor extra geheugentoewijzingen wordt geëlimineerd. De “std::string_view” is een lichtgewicht verwijzing naar de onderliggende tekenreeks van “originalString” zonder de gegevens te kopiëren.
Hier is de gegenereerde uitvoer:
Voorbeeld 2: Interoperabiliteit met oudere code
Op het gebied van C++-ontwikkeling is de naadloze integratie van nieuwe en oude codebases vaak een cruciaal punt van zorg. Met de “std::string_view” kunnen de ontwikkelaars moeiteloos communiceren met oudere functies die de “const char” -aanwijzers retourneren.
Beschouw het volgende voorbeeld dat het praktische gebruik van “std::string_view” voor interoperabiliteit demonstreert. Hier hebben we een oude functie genaamd “legacyFunction()” die een “const char” -aanwijzer retourneert:
#include#include
const teken * erfenisFunctie ( ) {
opbrengst 'Legacy-reeks' ;
}
int. hoofd ( ) {
std::string_view legacyStrView ( erfenisFunctie ( ) ) ;
std::uit << 'Verouderde tekenreeksweergave: ' << legacyStrView << std::endl;
opbrengst 0 ;
}
We beginnen met het definiëren van een oude functie met de naam “legacyFunction()” die een “const char”-aanwijzer retourneert die een tekenreeks vertegenwoordigt die is gelabeld als “Legacy String”. Om deze verouderde gegevens naadloos in ons moderne C++-programma te integreren, gebruiken we de “std::string_view”. In de functie main() maken we specifiek een exemplaar van “std::string_view” met de naam “legacyStrView” en initialiseren we deze met het resultaat van de oudere functie. Deze instantiatie stelt ons in staat om de oude “const char”-aanwijzer efficiënt in te kapselen en ermee te werken.
Als gevolg hiervan kunnen we de oude string openen en manipuleren zonder toevlucht te nemen tot onnodig kopiëren van gegevens, waardoor zowel de efficiëntie als de compatibiliteit behouden blijven. De laatste stap in de code omvat het gebruik van de “std::cout” om de inhoud van de oude stringweergave af te drukken.
De uitgevoerde uitvoer is:
Voorbeeld 3: Verbeterde verwerking van tekenreeksliterals
Letterlijke tekenreeksen in C++ worden traditioneel weergegeven als reeksen tekens. De “std::string_view” vereenvoudigt het werken met letterlijke tekenreeksen door een handige interface te bieden. Door directe toegang tot de onderliggende karakterarray toe te staan zonder de noodzaak van expliciete conversies, stroomlijnt 'std::string_view' de bewerkingen op letterlijke tekenreeksen.
#include#include
int. hoofd ( ) {
const teken * mijnLiteraal = 'Hallo, Stringview!' ;
std::string_view letterlijke weergave ( mijnLiteraal ) ;
std::uit << 'Eerste teken: ' << letterlijke weergave [ 0 ] << std::endl;
size_t positie = letterlijke weergave.find ( 'Snaar' ) ;
std::uit << 'Subtekenreekspositie: ' << positie << std::endl;
opbrengst 0 ;
}
In dit voorbeeld wordt een 'Hallo, String View!' letterlijke tekenreeks wordt toegewezen aan de “myLiteral”-aanwijzer. De introductie van “std::string_view” maakt een efficiëntere weergave van deze string mogelijk zonder de noodzaak om de inhoud ervan te kopiëren. Het object “literalView” wordt gemaakt met behulp van de “myLiteral”-aanwijzer waarmee we de onderliggende tekenreeks kunnen bekijken en manipuleren.
Het gebruik van “std::string_view” biedt gemakkelijke toegang tot individuele karakters binnen de string. In het codefragment haalt “literalView[0]” het eerste teken van de string op en drukt dit af, wat de eenvoud en directheid van toegang tot de elementen demonstreert. De “find”-methode van “std::string_view” wordt gebruikt om de positie van de “String”-substring binnen de originele string te bepalen.
Voorbeeld 4: Extractie van subtekenreeksen
De taak van het extraheren van subtekenreeksen omvat het ophalen van een deel van een gegeven tekenreeks op basis van gespecificeerde criteria, zoals de positie van een scheidingsteken. De mogelijkheid om moeiteloos de substrings te extraheren is een krachtig kenmerk van “std::string_view”. Beschouw een scenario waarin we een deel van een tekenreeks moeten extraheren op basis van een scheidingsteken:
#include#include
int. hoofd ( ) {
std::string fullString = 'appel-sinaasappel-banaan' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = volledigeString.substr ( 0 , scheidingstekenPos ) ;
std::uit << 'Geëxtraheerde subtekenreeks: ' << subString << std::endl;
opbrengst 0 ;
}
In dit codefragment beginnen we met de declaratie van een originele string, “fullString”, die wordt geïnitialiseerd met de waarde “apple-orange-banana”. Ons doel is om de substringextractie uit te voeren. Om dit te bereiken gebruiken we de “find”-functie van de C++-standaardbibliotheek.
Zodra we de positie van het scheidingsteken binnen de “fullString” hebben geïdentificeerd, opgeslagen in de variabele “delimiterPos”, extraheren we de gewenste subtekenreeks. De functie “substr” wordt aangeroepen op de originele string, waarbij de startpositie (0) en de lengte van de substring worden gespecificeerd, wat precies de positie van het scheidingsteken is. Deze bewerking resulteert in de creatie van de “std::string_view” genaamd “subString” die het gedeelte van de originele string vertegenwoordigt vanaf het begin tot aan het scheidingsteken.
Voorbeeld 5: Geheugenefficiënte datastructuren
De “std::string_view” speelt een cruciale rol bij het ontwerpen van geheugenefficiënte datastructuren. In plaats van meerdere kopieën van strings op te slaan, kunnen datastructuren de “std::string_view”-instanties opslaan, waardoor de geheugenoverhead wordt verminderd.
#include#include
struct opnemen {
std::string_view-naam;
int leeftijd;
} ;
int. hoofd ( ) {
Persoon opnemen = { 'John Doe' , 30 } ;
std::uit << 'Naam: ' << persoon.naam << ', Leeftijd: ' << personage << std::endl;
opbrengst 0 ;
}
In dit codefragment laten we het gebruik zien van “std::string_view” binnen een geheugenefficiënte datastructuur. We definiëren een “Record”-structuur die bestaat uit een “std::string_view”-lid met de naam “name” en een geheel getal-lid met de naam “age”. Het gebruik van “std::string_view” in deze context stelt ons in staat een lichtgewicht representatie van een string te creëren zonder de noodzaak van extra geheugentoewijzing.
In de “main”-functie instantiëren we een “Record”-object met de naam “person” met de naam “John Doe” en de leeftijd van 30 jaar. Het “std::string_view” lid “name” dient als een niet-eigendomsweergave van de tekengegevens die overeenkomen met de naam, waardoor de noodzaak voor het dupliceren van de tekenreeksinhoud wordt geëlimineerd. De “std::cout << “Naam: ” << persoon.naam << “, Leeftijd: ” << persoon.leeftijd << std::endl;” statement geeft de naam en leeftijd van de persoon weer die zijn opgeslagen in het object 'Record'.
Conclusie
In het steeds evoluerende landschap van de C++-ontwikkeling valt “std::string_view” op als een waardevolle toevoeging aan de toolkit van de programmeur. De voorbeelden die in dit artikel worden geïllustreerd benadrukken het aanpassingsvermogen en de bruikbaarheid van “std::string_view” binnen het domein van programmeren in C++. Van efficiënte stringmanipulatie en naadloze interoperabiliteit met oudere code tot geheugenefficiënte datastructuren, 'std::string_view' is waardevol voor ontwikkelaars die op zoek zijn naar verbeterde prestaties en geoptimaliseerde code in diverse scenario's. Deze praktijkscenario's laten zien hoe 'std::string_view' de code kan optimaliseren, onnodige geheugenoverhead kan verminderen en kan bijdragen aan de algehele efficiëntie van C++-applicaties.