V oblasti programování v C++ je rozhodující priorita efektivity a výkonu. Třída „std::string_view“, představená v C++17, představuje všestrannou a paměťově efektivní alternativu k tradiční manipulaci s řetězci. Ve svém jádru je „std::string_view“ nevlastní odkaz na sekvenci znaků, běžně představující podřetězec většího řetězce. Na rozdíl od „std::string“, který vlastní svá data a spravuje paměť interně, „std::string_view“ funguje bez vlastnictví základních dat. Tato vlastnost je zvláště cenná pro scénáře, kde je nežádoucí režie kopírování nebo správy paměti. V tomto článku prozkoumáme různé příklady, abychom porozuměli použití „std::string_view“ v C++.
Příklad 1: Efektivní manipulace s řetězci
V moderním vývoji C++ je efektivní zpracování řetězců zásadní pro optimalizaci výkonu a využití zdrojů. Umožňuje efektivní přístup a manipulaci s řetězci bez nutnosti přerozdělení paměti nebo duplikace. Abychom tento koncept ilustrovali, pojďme se ponořit do praktického příkladu.
Zvažte následující fragment kódu:
#include
#include
void processStringView ( std::string_view strView ) {
std::cout << 'Délka:' << strView.length ( ) << std::endl;
std::cout << 'Obsah: ' << strView << std::endl;
}
int main ( ) {
std::string originalString = 'Efektivní manipulace se strunami' ;
std::string_view viewOfString ( původní řetězec ) ;
processStringView ( viewOfString ) ;
vrátit se 0 ;
}
V tomto příkladu máme funkci „processStringView“, která má jako parametr „std::string_view“. Funkce pak vytiskne délku a obsah zobrazení řetězce pomocí standardního výstupu. Hlavní funkce inicializuje „std::string“ s názvem „originalString“ s hodnotou „Efficient String Handling“. Následně je vytvořen „std::string_view“ s názvem „viewOfString“, který odkazuje na obsah „originalString“.
Předáním „viewOfString“ funkci „processStringView“ můžeme provádět operace s řetězcem efektivně, čímž eliminujeme nutnost přidělování paměti navíc. „Std::string_view“ je lehký odkaz na základní sekvenci znaků „originalString“ bez kopírování dat.
Zde je vygenerovaný výstup:
Příklad 2: Interoperabilita se starším kódem
V oblasti vývoje C++ je bezproblémová integrace nových a starých kódových základen často zásadním problémem. „Std::string_view“ umožňuje vývojářům bez námahy pracovat se staršími funkcemi, které vracejí ukazatele „const char“.
Zvažte následující příklad, který demonstruje praktické použití „std::string_view“ pro interoperabilitu. Zde máme starší funkci s názvem „legacyFunction()“, která vrací ukazatel „const char“:
#include#include
konst char * legacyFunction ( ) {
vrátit se 'Starší řetězec' ;
}
int main ( ) {
std::string_view legacyStrView ( legacyFunction ( ) ) ;
std::cout << 'Starší zobrazení řetězce: ' << legacyStrView << std::endl;
vrátit se 0 ;
}
Začneme definováním starší funkce s názvem „legacyFunction()“, která vrací ukazatel „const char“, který představuje řetězec, který je označen jako „Legacy String“. K bezproblémovému začlenění těchto starších dat do našeho moderního programu C++ používáme „std::string_view“. Konkrétně ve funkci main() vytvoříme instanci „std::string_view“ s názvem „legacyStrView“ a inicializujeme ji výsledkem starší funkce. Tato konkretizace nám umožňuje efektivně zapouzdřit a pracovat se starším ukazatelem „const char“.
Výsledkem je, že můžeme přistupovat k staršímu řetězci a manipulovat s ním, aniž bychom se museli uchylovat ke zbytečnému kopírování dat, přičemž zachováváme efektivitu i kompatibilitu. Poslední krok v kódu zahrnuje použití „std::cout“ k vytištění obsahu staršího zobrazení řetězce.
Provedený výstup je:
Příklad 3: Vylepšené zpracování řetězcových literálů
Řetězcové literály v C++ jsou tradičně reprezentovány jako pole znaků. „Std::string_view“ zjednodušuje práci s řetězcovými literály tím, že poskytuje pohodlné rozhraní. Tím, že „std::string_view“ umožňuje přímý přístup k základnímu poli znaků bez potřeby explicitních převodů, zjednodušuje operace s řetězcovými literály.
#include#include
int main ( ) {
konst char * myLiteral = 'Ahoj String View!' ;
std::string_view literalView ( myLiteral ) ;
std::cout << 'První postava:' << doslovný pohled [ 0 ] << std::endl;
size_t position = literalView.find ( 'Tětiva' ) ;
std::cout << 'Pozice podřetězce: ' << pozice << std::endl;
vrátit se 0 ;
}
V tomto příkladu se zobrazí „Ahoj, zobrazení řetězce!“ řetězcový literál je přiřazen ukazateli „myLiteral“. Zavedení „std::string_view“ usnadňuje efektivnější reprezentaci tohoto řetězce bez nutnosti kopírovat jeho obsah. Objekt „literalView“ je vytvořen pomocí ukazatele „myLiteral“, který nám umožňuje prohlížet a manipulovat se základní sekvencí znaků.
Použití „std::string_view“ poskytuje snadný přístup k jednotlivým znakům v řetězci. Ve fragmentu kódu „literalView[0]“ načte a vytiskne první znak řetězce, což ukazuje jednoduchost a přímost přístupu k prvkům. K určení pozice podřetězce „String“ v původním řetězci se používá metoda „find“ pro „std::string_view“.
Příklad 4: Extrakce podřetězců
Úloha extrakce podřetězců zahrnuje načtení části daného řetězce na základě specifikovaných kritérií, jako je pozice oddělovače. Schopnost snadno extrahovat podřetězce je výkonná funkce „std::string_view“. Zvažte scénář, kdy potřebujeme extrahovat část řetězce na základě oddělovače:
#include#include
int main ( ) {
std::string fullString = 'jablko-pomeranč-banán' ;
size_t oddělovačPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , oddělovačPoz ) ;
std::cout << 'Extrahovaný podřetězec:' << podřetězec << std::endl;
vrátit se 0 ;
}
V tomto fragmentu kódu začínáme deklarací původního řetězce „fullString“, který je inicializován hodnotou „apple-orange-banana“. Naším cílem je provést extrakci podřetězců. Abychom toho dosáhli, používáme funkci „najít“, kterou poskytuje standardní knihovna C++.
Jakmile identifikujeme pozici oddělovače v rámci „fullString“, uloženého v proměnné „delimiterPos“, extrahujeme požadovaný podřetězec. Funkce „substr“ je volána na původním řetězci a určuje počáteční pozici (0) a délku podřetězce, což je přesně pozice oddělovače. Výsledkem této operace je vytvoření „std::string_view“ s názvem „subString“, který představuje část původního řetězce od začátku až po oddělovač.
Příklad 5: Paměťově efektivní datové struktury
„Std::string_view“ hraje klíčovou roli při navrhování paměťově efektivních datových struktur. Namísto ukládání více kopií řetězců mohou datové struktury ukládat instance „std::string_view“, čímž snižují režii paměti.
#include#include
struct Record {
std::string_view jméno;
int věk;
} ;
int main ( ) {
Rekordní osoba = { 'John Doe' , 30 } ;
std::cout << 'Název: ' << osoba.jméno << ', věk: ' << osobnost << std::endl;
vrátit se 0 ;
}
V tomto úryvku kódu předvádíme využití „std::string_view“ v rámci paměťově efektivní datové struktury. Definujeme strukturu „Record“, která obsahuje člen „std::string_view“ s názvem „name“ a celočíselný člen s názvem „age“. Použití „std::string_view“ v tomto kontextu nám umožňuje vytvořit odlehčenou reprezentaci řetězce bez potřeby další alokace paměti.
Ve funkci „main“ vytvoříme instanci objektu „Record“ s názvem „person“ se jménem „John Doe“ a věkem 30 let. Člen „std::string_view“ „name“ slouží jako pohled, který nevlastní znaková data odpovídající názvu, čímž se eliminuje nutnost duplikovat obsah řetězce. The “std::cout << “Jméno: ” << person.name << “, Věk: ” << person.age << std::endl;” výpis vypíše jméno a věk osoby, které jsou uloženy v objektu „Záznam“.
Závěr
V neustále se vyvíjejícím prostředí vývoje C++ vyniká „std::string_view“ jako cenný doplněk k programátorské sadě nástrojů. Instance, které jsou ilustrovány v tomto článku, zdůrazňují přizpůsobivost a užitečnost „std::string_view“ v oblasti programování C++. Od efektivní manipulace s řetězci a bezproblémové interoperability se starším kódem až po paměťově efektivní datové struktury je „std::string_view“ cenné pro vývojáře, kteří hledají vyšší výkon a optimalizovaný kód v různých scénářích. Tyto scénáře ze skutečného světa ukazují, jak může „std::string_view“ optimalizovat kód, snížit zbytečnou paměťovou zátěž a přispět k celkové efektivitě aplikací C++.