C++ நிரலாக்கத்தின் களத்தில், செயல்திறன் மற்றும் செயல்திறனுக்கு முன்னுரிமை அளிப்பது முக்கியமானது. C++17 இல் அறிமுகப்படுத்தப்பட்ட “std::string_view” வகுப்பு, பாரம்பரிய சரம் கையாளுதலுக்கு பல்துறை மற்றும் நினைவாற்றல் திறன் கொண்ட மாற்றீட்டை வழங்குகிறது. அதன் மையத்தில், 'std:: string_view' என்பது எழுத்துகளின் வரிசைக்கு சொந்தமில்லாத குறிப்பு ஆகும், இது பொதுவாக பெரிய சரத்தின் துணைச்சரத்தைக் குறிக்கிறது. 'std::string' ஆனது அதன் தரவைச் சொந்தமாக வைத்து நினைவகத்தை உள்நாட்டில் நிர்வகிக்கிறது, 'std::string_view' என்பது அடிப்படைத் தரவைச் சொந்தமாக்காமல் இயங்குகிறது. நினைவகத்தை நகலெடுப்பது அல்லது நிர்வகிப்பது விரும்பத்தகாத சூழ்நிலைகளில் இந்த பண்பு குறிப்பாக மதிப்புமிக்கதாக ஆக்குகிறது. இந்தக் கட்டுரையில், C++ இல் “std::string_view” இன் பயன்பாட்டைப் புரிந்துகொள்ள பல்வேறு உதாரணங்களை ஆராய்வோம்.
எடுத்துக்காட்டு 1: திறமையான சரம் கையாளுதல்
நவீன C++ வளர்ச்சியில், செயல்திறன் மற்றும் வளப் பயன்பாட்டை மேம்படுத்துவதற்கு திறமையான சரம் கையாளுதல் முக்கியமானது. நினைவக மறுஒதுக்கீடு அல்லது நகல் தேவையில்லாமல் சரங்களின் திறமையான அணுகல் மற்றும் கையாளுதலை இது அனுமதிக்கிறது. இந்த கருத்தை விளக்குவதற்கு, ஒரு நடைமுறை உதாரணத்தை ஆராய்வோம்.
பின்வரும் குறியீடு துணுக்கைக் கவனியுங்கள்:
#
#
வெற்றிடமான processStringView ( std::string_view strView ) {
std::cout << 'நீளம்:' << strView.நீளம் ( ) << std::endl;
std::cout << 'உள்ளடக்கம்: ' << strபார்வை << std::endl;
}
முழு எண்ணாக ( ) {
std::string originalString = 'திறமையான சரம் கையாளுதல்' ;
std::string_view viewOfString ( அசல் சரம் ) ;
processStringView ( viewOfString ) ;
திரும்ப 0 ;
}
இந்த எடுத்துக்காட்டில், எங்களிடம் “processStringView” செயல்பாடு உள்ளது, அது “std:: string_view” ஐ அதன் அளவுருவாக எடுத்துக்கொள்கிறது. செயல்பாடு நிலையான வெளியீட்டைப் பயன்படுத்தி சரம் காட்சியின் நீளம் மற்றும் உள்ளடக்கத்தை அச்சிடுகிறது. முக்கிய செயல்பாடு 'ஒரிஜினல்ஸ்ட்ரிங்' என்ற பெயரிடப்பட்ட 'std:: string' ஐ 'திறமையான சரம் கையாளுதல்' மதிப்புடன் துவக்குகிறது. பின்னர், 'std::string_view' என்ற பெயரிடப்பட்ட 'viewOfString' உருவாக்கப்பட்டது, இது 'ஒரிஜினல்ஸ்ட்ரிங்' இன் உள்ளடக்கத்தைக் குறிக்கிறது.
'processStringView' செயல்பாட்டிற்கு 'viewOfString' ஐ அனுப்புவதன் மூலம், கூடுதல் நினைவக ஒதுக்கீடுகளின் தேவையை நீக்கி, சரத்தின் செயல்பாடுகளை திறமையாகச் செய்யலாம். “std::string_view” என்பது தரவை நகலெடுக்காமல் “originalString” இன் அடிப்படை எழுத்து வரிசைக்கான இலகுரக குறிப்பு.
உருவாக்கப்பட்ட வெளியீடு இங்கே:
எடுத்துக்காட்டு 2: மரபுக் குறியீட்டுடன் இயங்கக்கூடிய தன்மை
சி++ வளர்ச்சியில், புதிய மற்றும் பழைய கோட்பேஸ்களின் தடையற்ற ஒருங்கிணைப்பு பெரும்பாலும் முக்கியமான கவலையாக உள்ளது. 'std::string_view' ஆனது 'const char' சுட்டிகளை வழங்கும் மரபு செயல்பாடுகளுடன் டெவலப்பர்களை சிரமமின்றி தொடர்பு கொள்ள அனுமதிக்கிறது.
'std::string_view' இன் செயல்பாட்டின் செயல்பாட்டின் செயல்பாட்டிற்கு பின்வரும் உதாரணத்தைக் கவனியுங்கள். இங்கே, எங்களிடம் 'legacyFunction()' என்ற பெயருடைய ஒரு மரபு செயல்பாடு உள்ளது, அது 'const char' சுட்டியை வழங்குகிறது:
##
கான்ஸ்ட் சார் * மரபுச் செயல்பாடு ( ) {
திரும்ப 'மரபுச் சரம்' ;
}
முழு எண்ணாக ( ) {
std::string_view legacyStrView ( மரபுச் செயல்பாடு ( ) ) ;
std::cout << 'Legacy String View:' << legacyStrView << std::endl;
திரும்ப 0 ;
}
'LegacyFunction()' என பெயரிடப்பட்ட ஒரு மரபுச் செயல்பாட்டை வரையறுப்பதன் மூலம் தொடங்குகிறோம், இது 'LegacyFunction()' என பெயரிடப்பட்ட சரத்தை குறிக்கும் 'const char' சுட்டிக்காட்டி வழங்கும். எங்களின் நவீன C++ திட்டத்தில் இந்த மரபுத் தரவை தடையின்றி இணைக்க, 'std::string_view'ஐப் பயன்படுத்துகிறோம். முக்கிய() செயல்பாட்டில், குறிப்பாக, 'legacyStrView' என்று பெயரிடப்பட்ட 'std::string_view' இன் நிகழ்வை உருவாக்கி, அதை மரபுச் செயல்பாட்டின் விளைவாக துவக்குவோம். இந்த இன்ஸ்டண்டியேஷன், பாரம்பரிய 'கான்ஸ்ட் சார்' சுட்டியை திறம்பட இணைக்க மற்றும் வேலை செய்ய அனுமதிக்கிறது.
இதன் விளைவாக, தேவையற்ற தரவு நகலெடுக்காமல், செயல்திறன் மற்றும் இணக்கத்தன்மை ஆகிய இரண்டையும் பாதுகாக்காமல், மரபு சரத்தை அணுகலாம் மற்றும் கையாளலாம். குறியீட்டின் இறுதிப் படியானது மரபுச் சரம் பார்வையின் உள்ளடக்கத்தை அச்சிடுவதற்கு 'std::cout' ஐப் பயன்படுத்துவதை உள்ளடக்குகிறது.
செயல்படுத்தப்பட்ட வெளியீடு:
எடுத்துக்காட்டு 3: மேம்படுத்தப்பட்ட சரம் எழுத்துகள் கையாளுதல்
C++ இல் உள்ள சரம் எழுத்துக்கள் பாரம்பரியமாக எழுத்துக்களின் வரிசைகளாக குறிப்பிடப்படுகின்றன. 'std::string_view' ஒரு வசதியான இடைமுகத்தை வழங்குவதன் மூலம் சரம் எழுத்துகளுடன் வேலை செய்வதை எளிதாக்குகிறது. வெளிப்படையான மாற்றங்களின் தேவையின்றி அடிப்படை எழுத்து வரிசைக்கு நேரடி அணுகலை அனுமதிப்பதன் மூலம், 'std::string_view' ஸ்ட்ரிங் லிட்டரல்களில் செயல்பாடுகளை ஒழுங்குபடுத்துகிறது.
##
முழு எண்ணாக ( ) {
கான்ஸ்ட் சார் * myLiteral = 'ஹலோ, ஸ்டிரிங் வியூ!' ;
std::string_view litralView ( myLiteral ) ;
std::cout << 'முதல் பாத்திரம்:' << நேரடி பார்வை [ 0 ] << std::endl;
size_t நிலை = literalView.find ( 'லேசான கயிறு' ) ;
std::cout << 'சப்ஸ்ட்ரிங் நிலை:' << நிலை << std::endl;
திரும்ப 0 ;
}
இந்த எடுத்துக்காட்டில், “ஹலோ, சரம் பார்வை!” 'மைலிட்டரல்' சுட்டிக்கு சரம் எழுத்து ஒதுக்கப்படுகிறது. 'std::string_view' இன் அறிமுகமானது, இந்த சரத்தின் உள்ளடக்கங்களை நகலெடுக்க வேண்டிய அவசியமின்றி மிகவும் திறமையான பிரதிநிதித்துவத்தை எளிதாக்குகிறது. 'literalView' ஆப்ஜெக்ட் 'myLiteral' சுட்டியைப் பயன்படுத்தி உருவாக்கப்பட்டது, இது அடிப்படை எழுத்து வரிசையைப் பார்க்கவும் கையாளவும் அனுமதிக்கிறது.
“std::string_view” இன் பயன்பாடு சரத்திற்குள் உள்ள தனிப்பட்ட எழுத்துகளுக்கு எளிதான அணுகலை வழங்குகிறது. குறியீடு துணுக்கில், 'லிட்டரல் வியூ[0]' சரத்தின் முதல் எழுத்தை மீட்டெடுத்து அச்சிடுகிறது, உறுப்புகளை அணுகுவதற்கான எளிமை மற்றும் நேரடித்தன்மையைக் காட்டுகிறது. 'std::string_view' இன் 'கண்டுபிடி' முறையானது அசல் சரத்திற்குள் 'ஸ்ட்ரிங்' துணைச்சரத்தின் நிலையைத் தீர்மானிக்கப் பயன்படுத்தப்படுகிறது.
எடுத்துக்காட்டு 4: சப்ஸ்ட்ரிங் பிரித்தெடுத்தல்
சப்ஸ்ட்ரிங் பிரித்தெடுத்தல் பணியானது, ஒரு பிரிப்பானின் நிலை போன்ற குறிப்பிட்ட அளவுகோல்களின் அடிப்படையில் கொடுக்கப்பட்ட சரத்தின் ஒரு பகுதியை மீட்டெடுப்பதை உள்ளடக்கியது. சப்ஸ்ட்ரிங்ஸை சிரமமின்றி பிரித்தெடுக்கும் திறன் “std::string_view” இன் சக்திவாய்ந்த அம்சமாகும். ஒரு சரத்தின் ஒரு பகுதியை பிரித்தெடுப்பதன் அடிப்படையில் பிரித்தெடுக்க வேண்டிய சூழ்நிலையைக் கவனியுங்கள்:
##
முழு எண்ணாக ( ) {
std::string fullString = 'ஆப்பிள்-ஆரஞ்சு-வாழைப்பழம்' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , delimiterPos ) ;
std::cout << 'பிரித்தெடுக்கப்பட்ட சப்ஸ்ட்ரிங்:' << சப்ஸ்ட்ரிங் << std::endl;
திரும்ப 0 ;
}
இந்த குறியீடு துணுக்கில், 'ஆப்பிள்-ஆரஞ்சு-பனானா' மதிப்புடன் துவக்கப்படும் அசல் சரமான 'ஃபுல்ஸ்ட்ரிங்' அறிவிப்புடன் தொடங்குகிறோம். சப்ஸ்ட்ரிங் பிரித்தெடுப்பதைச் செய்வதே எங்கள் குறிக்கோள். இதை அடைய, C++ நிலையான நூலகத்தால் வழங்கப்படும் 'கண்டுபிடி' செயல்பாட்டைப் பயன்படுத்துகிறோம்.
'delimiterPos' மாறியில் சேமிக்கப்பட்ட 'fullString' க்குள் டிலிமிட்டரின் நிலையை நாம் கண்டறிந்ததும், விரும்பிய சப்ஸ்ட்ரிங் பிரித்தெடுக்கிறோம். 'substr' செயல்பாடு அசல் சரத்தில் அழைக்கப்படுகிறது, இது தொடக்க நிலை (0) மற்றும் துணை சரத்தின் நீளத்தைக் குறிப்பிடுகிறது, இது துல்லியமாக பிரிப்பானின் நிலையாகும். இந்தச் செயல்பாட்டின் விளைவாக, 'subString' என்ற பெயரிடப்பட்ட 'std::string_view' உருவாக்கப்படுகிறது, இது அசல் சரத்தின் தொடக்கத்திலிருந்து பிரிப்பான் வரையிலான பகுதியைக் குறிக்கிறது.
எடுத்துக்காட்டு 5: நினைவகம்-திறமையான தரவு கட்டமைப்புகள்
'std::string_view' நினைவக திறன் கொண்ட தரவு கட்டமைப்புகளை வடிவமைப்பதில் முக்கிய பங்கு வகிக்கிறது. சரங்களின் பல நகல்களைச் சேமிப்பதற்குப் பதிலாக, தரவு கட்டமைப்புகள் “std::string_view” நிகழ்வுகளைச் சேமிக்கலாம், இதனால் நினைவக மேல்நிலையைக் குறைக்கிறது.
##
struct பதிவு {
std::string_view பெயர்;
முழு வயது;
} ;
முழு எண்ணாக ( ) {
பதிவு நபர் = { 'ஜான் டோ' , 30 } ;
std::cout << 'பெயர்:' << நபர்.பெயர் << ', வயது: ' << நபர்.வயது << std::endl;
திரும்ப 0 ;
}
இந்த குறியீடு துணுக்கில், நினைவக திறன் கொண்ட தரவு கட்டமைப்பிற்குள் “std::string_view” இன் பயன்பாட்டைக் காண்பிக்கிறோம். 'பெயர்' என பெயரிடப்பட்ட 'std::string_view' உறுப்பினரையும் 'வயது' எனப்படும் முழு எண் உறுப்பினரையும் உள்ளடக்கிய 'பதிவு' கட்டமைப்பை நாங்கள் வரையறுக்கிறோம். இந்தச் சூழலில் “std::string_view”ஐப் பயன்படுத்துவது கூடுதல் நினைவக ஒதுக்கீடு தேவையில்லாமல் சரத்தின் இலகுரக பிரதிநிதித்துவத்தை உருவாக்க அனுமதிக்கிறது.
'முக்கிய' செயல்பாட்டில், 'ஜான் டோ' என்ற பெயருடன் 'நபர்' என்ற பெயரிடப்பட்ட 'பதிவு' பொருளின் 30 வயதை நாங்கள் நிறுவுகிறோம். 'std::string_view' உறுப்பினர் 'பெயர்' என்பது உரிமையற்ற பார்வையாக செயல்படுகிறது பெயருடன் தொடர்புடைய எழுத்துத் தரவு, சரம் உள்ளடக்கத்தை நகலெடுப்பதற்கான அவசியத்தை நீக்குகிறது. The “std::cout << “பெயர்: ” << நபர்.பெயர் << “, வயது: ” << person.age << std::endl;” அறிக்கையானது 'பதிவு' பொருளில் சேமிக்கப்பட்டுள்ள நபரின் பெயர் மற்றும் வயதை வெளியிடுகிறது.
முடிவுரை
C++ மேம்பாட்டின் எப்போதும் வளரும் நிலப்பரப்பில், 'std::string_view' என்பது புரோகிராமரின் கருவித்தொகுப்பில் மதிப்புமிக்க கூடுதலாக உள்ளது. இந்தக் கட்டுரையில் விளக்கப்பட்டுள்ள நிகழ்வுகள், C++ நிரலாக்கத்தின் எல்லைக்குள் 'std::string_view' இன் ஏற்புத்திறன் மற்றும் பயன்பாட்டை எடுத்துக்காட்டுகின்றன. திறமையான சரம் கையாளுதல் மற்றும் மரபுக் குறியீட்டுடன் தடையற்ற இயங்குதன்மை முதல் நினைவக-திறனுள்ள தரவு கட்டமைப்புகள் வரை, 'std:: string_view' பல்வேறு சூழ்நிலைகளில் மேம்பட்ட செயல்திறன் மற்றும் உகந்த குறியீட்டை தேடும் டெவலப்பர்களுக்கு மதிப்புமிக்கது. இந்த நிஜ உலக காட்சிகள் 'std::string_view' குறியீட்டை எவ்வாறு மேம்படுத்தலாம், தேவையற்ற நினைவக மேல்நிலையைக் குறைக்கலாம் மற்றும் C++ பயன்பாடுகளின் ஒட்டுமொத்த செயல்திறனுக்கு எவ்வாறு பங்களிக்க முடியும் என்பதை நிரூபிக்கிறது.