Sa domain ng C++ programming, ang pag-prioritize ng kahusayan at pagganap ay mahalaga. Ang klase na 'std::string_view', na ipinakilala sa C++17, ay nagpapakita ng maraming nalalaman at mahusay sa memory na alternatibo sa tradisyonal na pagmamanipula ng string. Sa kaibuturan nito, ang 'std::string_view' ay isang hindi pagmamay-ari na reference sa isang sequence ng mga character, na karaniwang kumakatawan sa isang substring ng isang mas malaking string. Hindi tulad ng 'std::string' na nagmamay-ari ng data nito at namamahala sa memorya sa loob, gumagana ang 'std::string_view' nang hindi pagmamay-ari ang pinagbabatayan na data. Ginagawa nitong partikular na mahalaga ang katangiang ito para sa mga sitwasyon kung saan hindi kanais-nais ang overhead ng pagkopya o pamamahala ng memorya. Sa artikulong ito, tutuklasin natin ang iba't ibang mga halimbawa upang maunawaan ang paggamit ng 'std::string_view' sa C++.
Halimbawa 1: Mahusay na Paghawak ng String
Sa modernong pag-unlad ng C++, ang mahusay na paghawak ng string ay mahalaga para sa pag-optimize ng pagganap at paggamit ng mapagkukunan. Ito ay nagbibigay-daan sa isang mahusay na pag-access at pagmamanipula ng mga string nang hindi nangangailangan ng memorya ng muling paglalagay o pagdoble. Upang ilarawan ang konseptong ito, suriin natin ang isang praktikal na halimbawa.
Isaalang-alang ang sumusunod na snippet ng code:
#include
#include
void processStringView ( std::string_view strView ) {
std::cout << 'Haba:' << strView.length ( ) << std::endl;
std::cout << 'Nilalaman:' << strView << std::endl;
}
int pangunahing ( ) {
std::string originalString = 'Mahusay na Paghawak ng String' ;
std::string_view viewOfString ( originalString ) ;
processStringView ( viewOfString ) ;
bumalik 0 ;
}
Sa halimbawang ito, mayroon kaming function na 'processStringView' na kumukuha ng 'std::string_view' bilang parameter nito. Pagkatapos ay ipi-print ng function ang haba at nilalaman ng view ng string gamit ang karaniwang output. Sinisimulan ng pangunahing function ang 'std::string' na pinangalanang 'originalString' na may halagang 'Efficient String Handling'. Kasunod nito, ang 'std::string_view' na pinangalanang 'viewOfString' ay nilikha, na tumutukoy sa nilalaman ng 'originalString'.
Sa pamamagitan ng pagpasa ng 'viewOfString' sa function na 'processStringView', magagawa namin ang mga operasyon sa string nang mahusay, na inaalis ang pangangailangan para sa mga karagdagang paglalaan ng memorya. Ang 'std::string_view' ay isang magaan na sanggunian sa pinagbabatayan na pagkakasunud-sunod ng character ng 'originalString' nang hindi kinokopya ang data.
Narito ang nabuong output:
Halimbawa 2: Interoperability sa Legacy Code
Sa larangan ng pag-unlad ng C++, ang tuluy-tuloy na pagsasama ng bago at lumang mga codebase ay kadalasang isang kritikal na alalahanin. Ang 'std::string_view' ay nagbibigay-daan sa mga developer na makipag-ugnayan nang walang kahirap-hirap sa mga legacy na function na nagbabalik ng mga pointer na 'const char'.
Isaalang-alang ang sumusunod na halimbawa na nagpapakita ng praktikal na paggamit ng 'std::string_view' para sa interoperability. Dito, mayroon kaming legacy function na pinangalanang 'legacyFunction()' na nagbabalik ng 'const char' na pointer:
#include#include
const char * legacyFunction ( ) {
bumalik 'Legacy String' ;
}
int pangunahing ( ) {
std::string_view legacyStrView ( legacyFunction ( ) ) ;
std::cout << 'Legacy String View: ' << legacyStrView << std::endl;
bumalik 0 ;
}
Magsisimula kami sa pamamagitan ng pagtukoy sa isang legacy function na pinangalanang 'legacyFunction()' na nagbabalik ng 'const char' pointer na kumakatawan sa isang string na may label na 'Legacy String'. Upang walang putol na isama ang legacy na data na ito sa aming modernong C++ na programa, ginagamit namin ang 'std::string_view'. Sa main() function, partikular, gumawa kami ng instance ng 'std::string_view' na pinangalanang 'legacyStrView' at sinisimulan ito sa resulta ng legacy function. Ang instantiation na ito ay nagbibigay-daan sa amin na mahusay na mag-encapsulate at magtrabaho kasama ang legacy na 'const char' pointer.
Bilang resulta, maaari naming i-access at manipulahin ang legacy na string nang hindi gumagamit ng hindi kinakailangang pagkopya ng data, na pinapanatili ang kahusayan at pagiging tugma. Kasama sa huling hakbang sa code ang paggamit ng “std::cout” para i-print ang content ng legacy string view.
Ang naisakatuparan na output ay:
Halimbawa 3: Pinahusay na Paghawak ng Mga Literal ng String
Ang mga string literal sa C++ ay tradisyonal na kinakatawan bilang mga array ng mga character. Pinapasimple ng 'std::string_view' ang pagtatrabaho sa mga literal na string sa pamamagitan ng pagbibigay ng maginhawang interface. Sa pamamagitan ng pagpapahintulot ng direktang pag-access sa pinagbabatayan na array ng character nang hindi nangangailangan ng tahasang mga conversion, pinapa-streamline ng “std::string_view” ang mga operasyon sa mga literal na string.
#include#include
int pangunahing ( ) {
const char * myLiteral = 'Hello, String View!' ;
std::string_view literalView ( myLiteral ) ;
std::cout << 'Unang karakter: ' << literalView [ 0 ] << std::endl;
size_t position = literalView.find ( 'String' ) ;
std::cout << 'Posisyon ng substring: ' << posisyon << std::endl;
bumalik 0 ;
}
Sa halimbawang ito, isang 'Hello, String View!' string literal ay nakatalaga sa 'myLiteral' pointer. Ang pagpapakilala ng 'std::string_view' ay nagpapadali sa isang mas mahusay na representasyon ng string na ito nang hindi kinakailangang kopyahin ang mga nilalaman nito. Ang object na 'literalView' ay nilikha gamit ang pointer na 'myLiteral' na nagpapahintulot sa amin na tingnan at manipulahin ang pinagbabatayan na pagkakasunud-sunod ng character.
Ang paggamit ng 'std::string_view' ay nagbibigay ng madaling pag-access sa mga indibidwal na character sa loob ng string. Sa snippet ng code, kinukuha at ini-print ng 'literalView[0]' ang unang character ng string, na nagpapakita ng pagiging simple at direktang pag-access sa mga elemento. Ang 'find' na paraan ng 'std::string_view' ay ginagamit upang matukoy ang posisyon ng 'String' substring sa loob ng orihinal na string.
Halimbawa 4: Pagkuha ng Substring
Ang gawain ng pagkuha ng substring ay nagsasangkot ng pagkuha ng isang bahagi ng isang ibinigay na string batay sa tinukoy na pamantayan tulad ng posisyon ng isang delimiter. Ang kakayahang walang kahirap-hirap na i-extract ang mga substring ay isang malakas na tampok ng 'std::string_view'. Isaalang-alang ang isang senaryo kung saan kailangan nating kunin ang isang bahagi ng isang string batay sa isang delimiter:
#include#include
int pangunahing ( ) {
std::string fullString = 'mansanas-kahel-saging' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , delimiterPos ) ;
std::cout << 'Na-extract na Substring: ' << subString << std::endl;
bumalik 0 ;
}
Sa snippet ng code na ito, magsisimula kami sa deklarasyon ng isang orihinal na string, 'fullString', na sinisimulan ng 'apple-orange-banana' na halaga. Ang aming layunin ay isagawa ang substring extraction. Upang makamit ito, ginagamit namin ang function na 'hanapin' na ibinigay ng karaniwang library ng C++.
Kapag natukoy na namin ang posisyon ng delimiter sa loob ng 'fullString', na nakaimbak sa variable na 'delimiterPos', kinukuha namin ang gustong substring. Ang function na 'substr' ay tinatawag sa orihinal na string, na tumutukoy sa panimulang posisyon (0) at ang haba ng substring na eksaktong posisyon ng delimiter. Ang operasyong ito ay nagreresulta sa paglikha ng 'std::string_view' na pinangalanang 'subString' na kumakatawan sa bahagi ng orihinal na string mula sa simula hanggang sa delimiter.
Halimbawa 5: Mga Istraktura ng Data na Mahusay sa Memorya
Ang 'std::string_view' ay gumaganap ng isang mahalagang papel sa pagdidisenyo ng mga istruktura ng data na mahusay sa memorya. Sa halip na mag-imbak ng maraming kopya ng mga string, ang mga istruktura ng data ay maaaring mag-imbak ng mga 'std::string_view' na mga instance, kaya binabawasan ang memory overhead.
#include#include
struct Record {
std::string_view pangalan;
int edad;
} ;
int pangunahing ( ) {
Record person = { 'John Doe' , 30 } ;
std::cout << 'Pangalan: ' << tao.pangalan << ', Edad: ' << tao.edad << std::endl;
bumalik 0 ;
}
Sa snippet ng code na ito, ipinapakita namin ang paggamit ng 'std::string_view' sa loob ng istraktura ng data na mahusay sa memorya. Tinutukoy namin ang isang istraktura ng 'Record' na binubuo ng isang miyembro ng 'std::string_view' na pinangalanang 'pangalan' at isang miyembro ng integer na tinatawag na 'edad'. Ang paggamit ng 'std::string_view' sa kontekstong ito ay nagbibigay-daan sa amin na lumikha ng magaan na representasyon ng isang string nang hindi nangangailangan ng karagdagang paglalaan ng memorya.
Sa 'pangunahing' function, ginagawa namin ang isang bagay na 'Record' na pinangalanang 'tao' na may pangalang 'John Doe' at may edad na 30. Ang 'std::string_view' na miyembro na 'pangalan' ay nagsisilbing isang hindi pagmamay-ari na view ng ang data ng character na naaayon sa pangalan, inaalis ang pangangailangan para sa pagdoble ng nilalaman ng string. Ang “std::cout << “Pangalan: ” << person.name << “, Edad: ” << person.age << std::endl;” Inilalabas ng pahayag ang pangalan at edad ng tao na naka-imbak sa bagay na 'Record'.
Konklusyon
Sa patuloy na umuusbong na tanawin ng pag-unlad ng C++, ang 'std::string_view' ay namumukod-tangi bilang isang mahalagang karagdagan sa toolkit ng programmer. Ang mga instance na inilalarawan sa artikulong ito ay nagtatampok sa kakayahang umangkop at utility ng 'std::string_view' sa loob ng larangan ng C++ programming. Mula sa mahusay na pagmamanipula ng string at tuluy-tuloy na interoperability na may legacy code hanggang sa mga istruktura ng data na mahusay sa memorya, ang 'std::string_view' ay mahalaga para sa mga developer na naghahanap ng pinahusay na pagganap at na-optimize na code sa magkakaibang mga sitwasyon. Ang mga totoong sitwasyong ito ay nagpapakita kung paano maaaring i-optimize ng 'std::string_view' ang code, bawasan ang hindi kinakailangang memory overhead, at mag-ambag sa pangkalahatang kahusayan ng mga C++ na application.