I domenet til C++-programmering er prioritering av effektivitet og ytelse avgjørende. Klassen 'std::string_view', introdusert i C++17, presenterer et allsidig og minneeffektivt alternativ til tradisjonell strengmanipulasjon. I kjernen er 'std::string_view' en ikke-eiende referanse til en sekvens av tegn, som vanligvis representerer en understreng av en større streng. I motsetning til 'std::string' som eier dataene sine og administrerer minnet internt, fungerer 'std::string_view' uten å eie de underliggende dataene. Denne egenskapen gjør den spesielt verdifull for scenarier der kostnadene ved kopiering eller administrasjon av minnet er uønsket. I denne artikkelen vil vi utforske de forskjellige eksemplene for å forstå bruken av 'std::string_view' i C++.
Eksempel 1: Effektiv strenghåndtering
I moderne C++-utvikling er effektiv strenghåndtering avgjørende for å optimalisere ytelsen og ressursutnyttelsen. Den gir effektiv tilgang og manipulering av strenger uten behov for omfordeling av minne eller duplisering. For å illustrere dette konseptet, la oss gå nærmere inn på et praktisk eksempel.
Tenk på følgende kodebit:
#include
#include
void processStringView ( std::string_view strView ) {
std::cout << 'Lengde: ' << strView.length ( ) << std::endl;
std::cout << 'Innhold: ' << strView << std::endl;
}
int main ( ) {
std::string originalString = 'Effektiv strenghåndtering' ;
std::string_view viewOfString ( originalString ) ;
processStringView ( viewOfString ) ;
komme tilbake 0 ;
}
I dette eksemplet har vi «processStringView»-funksjonen som tar «std::string_view» som parameter. Funksjonen skriver deretter ut lengden og innholdet av strengvisningen ved å bruke standardutgangen. Hovedfunksjonen initialiserer 'std::string' kalt 'originalString' med verdien 'Efficient String Handling'. Deretter opprettes 'std::string_view' kalt 'viewOfString', som refererer til innholdet i 'originalString'.
Ved å sende 'viewOfString' til 'processStringView'-funksjonen, kan vi utføre operasjonene på strengen effektivt, og eliminere behovet for ekstra minneallokeringer. 'std::string_view' er en lett referanse til den underliggende tegnsekvensen til 'originalString' uten å kopiere dataene.
Her er den genererte utgangen:
Eksempel 2: Interoperabilitet med eldre kode
I området for C++-utvikling er sømløs integrasjon av nye og gamle kodebaser ofte et kritisk problem. 'std::string_view' lar utviklerne samhandle uten problemer med eldre funksjoner som returnerer 'const char'-pekerne.
Tenk på følgende eksempel som viser den praktiske bruken av 'std::string_view' for interoperabilitet. Her har vi en eldre funksjon kalt 'legacyFunction()' som returnerer en 'const char'-peker:
#include#include
const røye * legacyFunction ( ) {
komme tilbake 'Eldre streng' ;
}
int main ( ) {
std::string_view legacyStrView ( legacyFunction ( ) ) ;
std::cout << 'Eldre strengvisning: ' << legacyStrView << std::endl;
komme tilbake 0 ;
}
Vi begynner med å definere en eldre funksjon kalt 'legacyFunction()' som returnerer en 'const char'-peker som representerer en streng som er merket som 'Legacy String'. For å sømløst inkorporere disse eldre dataene i vårt moderne C++-program, bruker vi 'std::string_view'. I hovedfunksjonen () oppretter vi spesifikt en forekomst av 'std::string_view' kalt 'legacyStrView' og initialiserer den med resultatet av den eldre funksjonen. Denne instansieringen lar oss effektivt innkapsle og arbeide med den eldre 'const char'-pekeren.
Som et resultat kan vi få tilgang til og manipulere den gamle strengen uten å ty til unødvendig datakopiering, noe som bevarer både effektivitet og kompatibilitet. Det siste trinnet i koden innebærer å bruke 'std::cout' for å skrive ut innholdet i den gamle strengvisningen.
Den utførte utgangen er:
Eksempel 3: Forbedret håndtering av strengbokstaver
Strengliteraler i C++ er tradisjonelt representert som arrays av tegn. 'std::string_view' forenkler arbeidet med strenglitteraler ved å tilby et praktisk grensesnitt. Ved å tillate direkte tilgang til den underliggende tegnarrayen uten behov for eksplisitte konverteringer, strømlinjeformer 'std::string_view' operasjonene på strengliteraler.
#include#include
int main ( ) {
const røye * myLiteral = 'Hei, String View!' ;
std::string_view literalView ( myLiteral ) ;
std::cout << 'Første karakter: ' << literalView [ 0 ] << std::endl;
size_t position = literalView.find ( 'streng' ) ;
std::cout << 'Substringsposisjon: ' << posisjon << std::endl;
komme tilbake 0 ;
}
I dette eksemplet, en 'Hei, strengvisning!' string literal er tilordnet 'myLiteral'-pekeren. Introduksjonen av 'std::string_view' muliggjør en mer effektiv representasjon av denne strengen uten behov for å kopiere innholdet. 'literalView'-objektet er opprettet ved hjelp av 'myLiteral'-pekeren som lar oss se og manipulere den underliggende tegnsekvensen.
Bruken av 'std::string_view' gir enkel tilgang til individuelle tegn i strengen. I kodebiten henter og skriver 'literalView[0]' ut strengens første tegn, og viser enkelheten og direkte tilgangen til elementene. 'Finn'-metoden til 'std::string_view' brukes for å bestemme posisjonen til 'String'-delstrengen i den opprinnelige strengen.
Eksempel 4: Delstrengekstraksjon
Oppgaven med å trekke ut delstrenger innebærer å hente en del av en gitt streng basert på spesifiserte kriterier som posisjonen til et skilletegn. Muligheten til å enkelt trekke ut understrengene er en kraftig funksjon i 'std::string_view'. Tenk på et scenario der vi må trekke ut en del av en streng basert på et skilletegn:
#include#include
int main ( ) {
std::string fullString = 'eple-appelsin-banan' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , skilletegnPos ) ;
std::cout << 'Uttrukket delstreng: ' << understreng << std::endl;
komme tilbake 0 ;
}
I denne kodebiten begynner vi med erklæringen av en original streng, 'fullString', som initialiseres med verdien 'eple-orange-banan'. Målet vårt er å utføre substring-ekstraksjonen. For å oppnå dette bruker vi 'finn'-funksjonen fra C++ standardbiblioteket.
Når vi har identifisert posisjonen til skilletegnet i 'fullString', lagret i 'delimiterPos'-variabelen, trekker vi ut den ønskede delstrengen. 'Substr'-funksjonen kalles på den opprinnelige strengen, og spesifiserer startposisjonen (0) og lengden på understrengen som er nøyaktig posisjonen til skilletegnet. Denne operasjonen resulterer i opprettelsen av 'std::string_view' kalt 'subString' som representerer delen av den opprinnelige strengen fra begynnelsen opp til skilletegnet.
Eksempel 5: Minneeffektive datastrukturer
'std::string_view' spiller en avgjørende rolle i utformingen av minneeffektive datastrukturer. I stedet for å lagre flere kopier av strenger, kan datastrukturer lagre 'std::string_view'-forekomstene, og dermed redusere minneoverheaden.
#include#include
struct Record {
std::streng_visningsnavn;
int alder;
} ;
int main ( ) {
Rekordperson = { 'John Doe' , 30 } ;
std::cout << 'Navn: ' << person.navn << ', Alder: ' << person.alder << std::endl;
komme tilbake 0 ;
}
I denne kodebiten viser vi bruken av 'std::string_view' i en minneeffektiv datastruktur. Vi definerer en 'Record'-struktur som består av et 'std::string_view'-medlem kalt 'name' og et heltallsmedlem kalt 'age'. Bruken av 'std::string_view' i denne sammenhengen lar oss lage en lett representasjon av en streng uten behov for ekstra minneallokering.
I 'hoved'-funksjonen instansierer vi et 'Record'-objekt kalt 'person' med navnet 'John Doe' og en alder av 30. 'std::string_view'-medlemmet 'name' fungerer som en ikke-eiende visning av tegndataene som tilsvarer navnet, eliminerer nødvendigheten av å duplisere strenginnholdet. 'std::cout << 'Name: ' << person.name << ', Alder: ' << person.age << std::endl;' setningen gir ut navnet og alderen til personen som er lagret i 'Record'-objektet.
Konklusjon
I det stadig utviklende landskapet til C++-utviklingen, fremstår 'std::string_view' som et verdifullt tillegg til programmererens verktøysett. Forekomstene som er illustrert i denne artikkelen fremhever tilpasningsevnen og nytten av 'std::string_view' innen C++-programmering. Fra effektiv strengmanipulering og sømløs interoperabilitet med eldre kode til minneeffektive datastrukturer, 'std::string_view' er verdifullt for utviklere som søker etter forbedret ytelse og optimalisert kode i forskjellige scenarier. Disse scenariene i den virkelige verden viser hvordan 'std::string_view' kan optimalisere koden, redusere unødvendige minnekostnader og bidra til den generelle effektiviteten til C++-applikasjoner.