Inden for C++-programmering er prioritering af effektivitet og ydeevne afgørende. Klassen 'std::string_view', introduceret i C++17, præsenterer et alsidigt og hukommelseseffektivt alternativ til traditionel strengmanipulation. I sin kerne er 'std::string_view' en ikke-ejer reference til en sekvens af tegn, der almindeligvis repræsenterer en understreng af en større streng. I modsætning til 'std::string', som ejer sine data og administrerer hukommelsen internt, fungerer 'std::string_view' uden at eje de underliggende data. Denne egenskab gør den særlig værdifuld til scenarier, hvor overheaden til kopiering eller håndtering af hukommelsen er uønsket. I denne artikel vil vi udforske de forskellige eksempler for at forstå brugen af 'std::string_view' i C++.
Eksempel 1: Effektiv strenghåndtering
I moderne C++-udvikling er effektiv strenghåndtering afgørende for at optimere ydeevnen og ressourceudnyttelsen. Det tillader en effektiv adgang og manipulation af strenge uden behov for hukommelsesomfordeling eller duplikering. For at illustrere dette koncept, lad os dykke ned i et praktisk eksempel.
Overvej følgende kodestykke:
#include
#include
ugyldig procesStringView ( std::string_view strView ) {
std::cout << 'Længde:' << strView.længde ( ) << std::endl;
std::cout << 'Indhold: ' << strView << std::endl;
}
int main ( ) {
std::string originalString = 'Effektiv strenghåndtering' ;
std::string_view viewOfString ( originalString ) ;
processStringView ( viewOfString ) ;
Vend tilbage 0 ;
}
I dette eksempel har vi funktionen 'processStringView', der tager 'std::string_view' som sin parameter. Funktionen udskriver derefter længden og indholdet af strengvisningen ved hjælp af standardoutputtet. Hovedfunktionen initialiserer 'std::strengen' med navnet 'originalString' med værdien 'Efficient String Handling'. Efterfølgende oprettes 'std::string_view' med navnet 'viewOfString', med henvisning til indholdet af 'originalString'.
Ved at overføre 'viewOfString' til 'processStringView'-funktionen kan vi udføre operationerne på strengen effektivt, hvilket eliminerer behovet for ekstra hukommelsesallokeringer. 'std::string_view' er en letvægtsreference til den underliggende tegnsekvens af 'originalString' uden at kopiere dataene.
Her er det genererede output:
Eksempel 2: Interoperabilitet med ældre kode
Inden for C++-udvikling er den sømløse integration af nye og gamle kodebaser ofte et kritisk problem. 'std::string_view' giver udviklerne mulighed for at interagere ubesværet med ældre funktioner, der returnerer 'const char'-pointerne.
Overvej følgende eksempel, der demonstrerer den praktiske brug af 'std::string_view' til interoperabilitet. Her har vi en ældre funktion ved navn 'legacyFunction()', der returnerer en 'const char' pointer:
#include#include
konst char * legacyFunction ( ) {
Vend tilbage 'Ældre streng' ;
}
int main ( ) {
std::string_view legacyStrView ( legacyFunction ( ) ) ;
std::cout << 'Ældre strengvisning: ' << legacyStrView << std::endl;
Vend tilbage 0 ;
}
Vi begynder med at definere en ældre funktion ved navn 'legacyFunction()', som returnerer en 'const char'-pointer, der repræsenterer en streng, der er mærket som 'Legacy String'. For problemfrit at inkorporere disse gamle data i vores moderne C++-program, bruger vi 'std::string_view'. Specifikt i main()-funktionen opretter vi en instans af 'std::string_view' med navnet 'legacyStrView' og initialiserer den med resultatet af den ældre funktion. Denne instansiering giver os mulighed for effektivt at indkapsle og arbejde med den gamle 'const char'-pointer.
Som et resultat kan vi få adgang til og manipulere den gamle streng uden at ty til unødvendig datakopiering, hvilket bevarer både effektivitet og kompatibilitet. Det sidste trin i koden involverer at bruge 'std::cout' til at udskrive indholdet af den gamle strengvisning.
Det udførte output er:
Eksempel 3: Forbedret håndtering af strenge bogstaver
Strengliteraler i C++ er traditionelt repræsenteret som arrays af tegn. 'std::string_view' forenkler arbejdet med strenge bogstaver ved at give en praktisk grænseflade. Ved at tillade en direkte adgang til det underliggende tegnarray uden behov for eksplicitte konverteringer, strømliner 'std::string_view' operationerne på strengliteraler.
#include#include
int main ( ) {
konst char * myLiteral = 'Hej, String View!' ;
std::string_view literalView ( myLiteral ) ;
std::cout << 'Første karakter:' << literalView [ 0 ] << std::endl;
size_t position = literalView.find ( 'Snor' ) ;
std::cout << 'Substring position: ' << position << std::endl;
Vend tilbage 0 ;
}
I dette eksempel, en 'Hej, strengvisning!' string literal er tildelt 'myLiteral'-markøren. Introduktionen af 'std::string_view' letter en mere effektiv repræsentation af denne streng uden behov for at kopiere dens indhold. Objektet 'literalView' er oprettet ved hjælp af 'myLiteral'-markøren, som giver os mulighed for at se og manipulere den underliggende tegnsekvens.
Brugen af 'std::string_view' giver nem adgang til individuelle tegn i strengen. I kodestykket henter og udskriver 'literalView[0]' strengens første tegn, hvilket viser enkelheden og direkte adgang til elementerne. 'Find'-metoden for 'std::string_view' bruges til at bestemme positionen af 'String'-understrengen i den originale streng.
Eksempel 4: Substring Extraction
Opgaven med at udtrække understrengen involverer at hente en del af en given streng baseret på specificerede kriterier såsom positionen af en afgrænser. Evnen til ubesværet at udtrække understrengene er en kraftfuld funktion i 'std::string_view'. Overvej et scenarie, hvor vi skal udtrække en del af en streng baseret på et skilletegn:
#include#include
int main ( ) {
std::string fullString = 'æble-appelsin-banan' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , afgrænserPos ) ;
std::cout << 'Udtrukket understreng: ' << understreng << std::endl;
Vend tilbage 0 ;
}
I dette kodestykke begynder vi med erklæringen af en original streng, 'fullString', som initialiseres med værdien 'æble-orange-banan'. Vores mål er at udføre substring-ekstraktion. For at opnå dette anvender vi 'find'-funktionen fra C++ standardbiblioteket.
Når vi har identificeret positionen af afgrænseren inden for 'fullString', gemt i 'delimiterPos'-variablen, udtrækker vi den ønskede understreng. Funktionen 'substr' kaldes på den oprindelige streng, der angiver startpositionen (0) og længden af understrengen, som præcis er positionen for afgrænseren. Denne operation resulterer i oprettelsen af 'std::string_view' med navnet 'subString', der repræsenterer delen af den originale streng fra begyndelsen op til skilletegn.
Eksempel 5: Hukommelseseffektive datastrukturer
'std::string_view' spiller en afgørende rolle i at designe de hukommelseseffektive datastrukturer. I stedet for at gemme flere kopier af strenge, kan datastrukturer gemme 'std::string_view'-forekomsterne og dermed reducere hukommelsesomkostningerne.
#include#include
struct Record {
std::string_view navn;
int alder;
} ;
int main ( ) {
Rekordperson = { 'John Doe' , 30 } ;
std::cout << 'Navn: ' << person.navn << ', Alder: ' << person.alder << std::endl;
Vend tilbage 0 ;
}
I dette kodestykke viser vi brugen af 'std::string_view' i en hukommelseseffektiv datastruktur. Vi definerer en 'Record'-struktur, der omfatter et 'std::string_view'-medlem ved navn 'name' og et heltalsmedlem kaldet 'age'. Brugen af 'std::string_view' i denne sammenhæng giver os mulighed for at skabe en let repræsentation af en streng uden behov for yderligere hukommelsesallokering.
I 'hoved'-funktionen instansierer vi et 'Record'-objekt ved navn 'person' med navnet 'John Doe' og en alder af 30. 'std::string_view'-medlemmet 'navn' fungerer som en ikke-ejervisning af tegndataene, der svarer til navnet, hvilket eliminerer nødvendigheden af at duplikere strengindholdet. 'std::cout << 'Navn: ' << person.navn << ', Alder: ' << person.alder << std::endl;' sætning udsender navnet og alderen på den person, som er gemt i 'Record'-objektet.
Konklusion
I det stadigt udviklende landskab i C++-udviklingen skiller 'std::string_view' sig ud som en værdifuld tilføjelse til programmørens værktøjskasse. De tilfælde, der er illustreret i denne artikel, fremhæver tilpasningsevnen og anvendeligheden af 'std::string_view' inden for C++-programmering. Fra effektiv strengmanipulation og problemfri interoperabilitet med ældre kode til hukommelseseffektive datastrukturer er 'std::string_view' værdifuldt for udviklere, der søger forbedret ydeevne og optimeret kode i forskellige scenarier. Disse scenarier fra den virkelige verden viser, hvordan 'std::string_view' kan optimere koden, reducere unødvendige hukommelsesomkostninger og bidrage til den samlede effektivitet af C++-applikationer.