В областта на програмирането на C++ приоритизирането на ефективността и производителността е от решаващо значение. Класът “std::string_view”, въведен в C++17, представя гъвкава и ефективна за паметта алтернатива на традиционното манипулиране на низове. В основата си „std::string_view“ е несобствена препратка към поредица от символи, обикновено представляваща подниз на по-голям низ. За разлика от „std::string“, който притежава своите данни и управлява вътрешно паметта, „std::string_view“ работи без да притежава основните данни. Тази характеристика го прави особено ценен за сценарии, при които излишните разходи за копиране или управление на паметта са нежелателни. В тази статия ще разгледаме различните примери, за да разберем използването на „std::string_view“ в C++.
Пример 1: Ефективна обработка на низове
В съвременната разработка на C++ ефективната обработка на низове е от решаващо значение за оптимизиране на производителността и използването на ресурсите. Той позволява ефективен достъп и манипулиране на низове, без да е необходимо преразпределяне на паметта или дублиране. За да илюстрираме тази концепция, нека разгледаме практически пример.
Разгледайте следния кодов фрагмент:
#include
#include
недействителен processStringView ( std::string_view strView ) {
std::cout << 'Дължина:' << strView.length ( ) << std::endl;
std::cout << „Съдържание:“ << strView << std::endl;
}
int main ( ) {
std::string originalString = „Ефективна обработка на низове“ ;
std::string_view viewOfString ( оригинален низ ) ;
processStringView ( viewOfString ) ;
връщане 0 ;
}
В този пример имаме функцията „processStringView“, която приема „std::string_view“ като свой параметър. След това функцията отпечатва дължината и съдържанието на низовия изглед, като използва стандартния изход. Основната функция инициализира „std::string“ с име „originalString“ със стойността „Efficient String Handling“. Впоследствие се създава „std::string_view“, наречен „viewOfString“, препращащ към съдържанието на „originalString“.
Чрез предаване на “viewOfString” на функцията “processStringView”, ние можем да изпълняваме операциите върху низа ефективно, елиминирайки необходимостта от допълнително разпределение на паметта. „std::string_view“ е лека препратка към основната последователност от знаци на „originalString“ без копиране на данните.
Ето генерирания изход:
Пример 2: Оперативна съвместимост с наследен код
В областта на разработката на C++ безпроблемната интеграция на нови и стари кодови бази често е критична грижа. „std::string_view“ позволява на разработчиците да взаимодействат без усилие с наследени функции, които връщат указателите „const char“.
Разгледайте следния пример, който демонстрира практическото използване на „std::string_view“ за оперативна съвместимост. Тук имаме наследена функция, наречена „legacyFunction()“, която връща указател „const char“:
#include#include
const char * legacyFunction ( ) {
връщане „Наследен низ“ ;
}
int main ( ) {
std::string_view legacyStrView ( legacyFunction ( ) ) ;
std::cout << 'Наследен низов изглед: ' << legacyStrView << std::endl;
връщане 0 ;
}
Започваме с дефиниране на наследена функция, наречена „legacyFunction()“, която връща указател „const char“, който представлява низ, който е означен като „Legacy String“. За да включим безпроблемно тези наследени данни в нашата модерна C++ програма, ние използваме „std::string_view“. Във функцията main(), по-конкретно, създаваме екземпляр на „std::string_view“ с име „legacyStrView“ и го инициализираме с резултата от наследената функция. Това инстанциране ни позволява ефективно да капсулираме и работим с наследения указател „const char“.
В резултат на това можем да осъществяваме достъп и да манипулираме наследения низ, без да прибягваме до ненужно копиране на данни, като запазваме ефективността и съвместимостта. Последната стъпка в кода включва използването на „std::cout“ за отпечатване на съдържанието на наследения изглед на низ.
Изпълненият изход е:
Пример 3: Подобрена обработка на низови литерали
Низовите литерали в C++ традиционно се представят като масиви от знаци. “std::string_view” опростява работата с низови литерали, като предоставя удобен интерфейс. Като позволява директен достъп до основния масив от символи без необходимост от изрични преобразувания, „std::string_view“ рационализира операциите върху низовите литерали.
#include#include
int main ( ) {
const char * myLiteral = „Здравей, String View!“ ;
std::string_view literalView ( myLiteral ) ;
std::cout << 'Първи герой:' << literalView [ 0 ] << std::endl;
size_t позиция = literalView.find ( 'низ' ) ;
std::cout << 'Позиция на подниз: ' << позиция << std::endl;
връщане 0 ;
}
В този пример, 'Hello, String View!' низовият литерал се присвоява на указателя “myLiteral”. Въвеждането на „std::string_view“ улеснява по-ефективното представяне на този низ, без да е необходимо да копирате съдържанието му. Обектът „literalView“ се създава с помощта на указателя „myLiteral“, който ни позволява да преглеждаме и манипулираме основната последователност от символи.
Използването на “std::string_view” осигурява лесен достъп до отделни знаци в низа. В кодовия фрагмент „literalView[0]“ извлича и отпечатва първия знак на низа, демонстрирайки простотата и директността на достъпа до елементите. Методът „find“ на „std::string_view“ се използва за определяне на позицията на подниза „String“ в рамките на оригиналния низ.
Пример 4: Извличане на подниз
Задачата за извличане на подниз включва извличане на част от даден низ въз основа на определени критерии, като например позицията на разделител. Възможността за лесно извличане на поднизовете е мощна функция на “std::string_view”. Помислете за сценарий, при който трябва да извлечем част от низ въз основа на разделител:
#include#include
int main ( ) {
std::string fullString = 'ябълка-портокал-банан' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , разделител Поз ) ;
std::cout << 'Извлечен подниз: ' << подниз << std::endl;
връщане 0 ;
}
В този кодов фрагмент започваме с декларирането на оригинален низ, „fullString“, който се инициализира със стойността „ябълка-портокал-банан“. Нашата цел е да извършим извличането на подниз. За да постигнем това, използваме функцията „find“, предоставена от стандартната библиотека на C++.
След като идентифицираме позицията на разделителя в рамките на „fullString“, съхранен в променливата „delimiterPos“, извличаме желания подниз. Функцията 'substr' се извиква върху оригиналния низ, като се посочва началната позиция (0) и дължината на подниза, която е точно позицията на разделителя. Тази операция води до създаването на „std::string_view“, наречен „subString“, който представлява частта от оригиналния низ от началото до разделителя.
Пример 5: Ефективни за паметта структури от данни
„std::string_view“ играе решаваща роля при проектирането на ефективни от паметта структури от данни. Вместо да съхраняват множество копия на низове, структурите от данни могат да съхраняват екземплярите „std::string_view“, като по този начин намаляват излишната памет.
#include#include
struct Record {
std::string_view име;
int възраст;
} ;
int main ( ) {
Записване на лице = { 'Джон Доу' , 30 } ;
std::cout << „Име:“ << лице.име << ', Възраст: ' << лице.възраст << std::endl;
връщане 0 ;
}
В този кодов фрагмент ние демонстрираме използването на „std::string_view“ в рамките на ефективна за паметта структура от данни. Ние дефинираме структура „Запис“, която се състои от член „std::string_view“, наречен „име“, и член с цяло число, наречен „възраст“. Използването на „std::string_view“ в този контекст ни позволява да създадем леко представяне на низ без необходимост от допълнително разпределение на паметта.
Във функцията „main“ създаваме обект „Record“ с име „person“ с името „John Doe“ и възрастта на 30. Членът „std::string_view“ „name“ служи като непритежаващ изглед на символните данни, съответстващи на името, елиминирайки необходимостта от дублиране на съдържанието на низа. „std::cout << „Име: ” << person.name << „, Възраст: ” << person.age << std::endl;” операторът извежда името и възрастта на лицето, които се съхраняват в обекта „Запис“.
Заключение
В непрекъснато развиващия се пейзаж на разработката на C++, „std::string_view“ се откроява като ценно допълнение към инструментариума на програмиста. Случаите, които са илюстрирани в тази статия, подчертават адаптивността и полезността на „std::string_view“ в областта на програмирането на C++. От ефективна манипулация на низове и безпроблемна оперативна съвместимост с наследен код до ефективни за паметта структури от данни, „std::string_view“ е ценен за разработчиците, които търсят подобрена производителност и оптимизиран код в различни сценарии. Тези сценарии от реалния свят демонстрират как „std::string_view“ може да оптимизира кода, да намали ненужното натоварване на паметта и да допринесе за цялостната ефективност на C++ приложенията.