எடுத்துக்காட்டு 1:
இந்த சூழ்நிலையில், நாம் சரங்கள் மற்றும் உள்ளீடு அல்லது வெளியீட்டு தரவுகளுடன் வேலை செய்ய வேண்டும், எனவே 'iostream' மற்றும் 'string' தலைப்பு கோப்புகள் வழங்கப்படுகின்றன. எனவே, இந்த தலைப்பு கோப்புகள் இங்கே சேர்க்கப்பட வேண்டும். அதன்பிறகு, இந்த 'std' ஐ இனி ஒவ்வொரு செயல்பாட்டிலும் தனித்தனியாக எங்கள் குறியீட்டில் சேர்க்க வேண்டியதில்லை, ஏனெனில் 'பயன்படுத்துதல்' முக்கிய வார்த்தையின் உதவியுடன் 'namespace std' ஐ ஏற்கனவே சேர்த்துள்ளோம். இங்கே, 'முக்கிய()' செயல்பாடு பின்னர் அழைக்கப்படுகிறது. பின்னர், 'originalString' என பெயரிடப்பட்ட 'ஸ்ட்ரிங்' மாறி சில சரம் மூலம் துவக்கப்படுகிறது. பின்னர், C++ உடன் 'word' என்ற மற்றொரு 'ஸ்ட்ரிங்' மாறியை துவக்குகிறோம்.
இப்போது, இதன் அடியில், 'கவுட்' ஐப் பயன்படுத்தி, அந்த அசல் சரத்தை அச்சிடுகிறோம். இதற்குப் பிறகு, 'int Result' ஐ அறிவித்து, 'originalString' இல் 'வார்த்தை' உள்ளதா இல்லையா என்பதைச் சரிபார்க்க 'contains()' செயல்பாட்டை வைக்கிறோம். அதற்குக் கீழே “if” என்று வைக்கிறோம். 'முடிவு' என்பதை 'if' க்கு அனுப்புகிறோம். அசல் சரத்தில் சப்ஸ்ட்ரிங் இருந்தால், அது 'if' க்குப் பிறகு நாம் சேர்த்த அறிக்கையை வழங்குகிறது. சரத்தில் சப்ஸ்ட்ரிங் இல்லை என்றால், 'வேறு' என்பதற்குப் பிறகு வழங்கப்படும் அறிக்கை ரெண்டர் செய்யப்படும்.
குறியீடு 1:
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
சரம் அசல் சரம் = 'எனக்கு C++ புரோகிராமிங் பிடிக்கும்' ;
சரம் வார்த்தை = 'சி++' ;
கூட் << 'சரம் =' << அசல் சரம் << endl << endl ;
முழு எண்ணாக விளைவாக = அசல் சரம். கொண்டுள்ளது ( சொல் ) ;
என்றால் ( விளைவாக )
{
கூட் << 'சரத்தில் காணப்படும் வார்த்தை =' << சொல் << endl ;
}
வேறு
{
கூட் << 'சரத்தில் வார்த்தை கிடைக்கவில்லை' << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவு, அசல் சரத்தில் நாம் கண்டெடுக்கும் சப்ஸ்ட்ரிங் () செயல்பாட்டின் உதவியுடன் அசல் சரத்திற்குள் இருப்பதைக் காட்டுகிறது, மேலும் அது இங்கே காட்டப்படும்.
எடுத்துக்காட்டு 2:
“iostream” மற்றும் “string” ஆகியவை இந்தக் குறியீட்டில் நாம் இறக்குமதி செய்த தலைப்புக் கோப்புகள். 'std' பெயர்வெளியும் சேர்க்கப்பட்டுள்ளது. பின்னர், முக்கிய() இங்கே அழைக்கப்படுகிறது. அடுத்து, சில சரம் தரவைச் சேர்ப்பதன் மூலம் 'str_1' எனப்படும் 'ஸ்ட்ரிங்' மாறியை துவக்குவோம். இனி, 'str_2' எனப்படும் 'ஸ்ட்ரிங்' மாறியை 'ரெயின்' மூலம் துவக்குவோம்.
இதற்கு கீழே, 'cout' செயல்பாட்டைப் பயன்படுத்தி அசல் சரத்தை அச்சிடுகிறோம். “str_1” இல் “str_2” உள்ளதா இல்லையா என்பதைத் தீர்மானிக்க, “int Outcome” ஐ அறிவித்து, இங்கு contains() முறையைச் செருகுவோம். கீழே, நாம் 'if' ஐ வைத்து, 'if' க்கு 'முடிவு' ஐ அனுப்புகிறோம். அசல் சரத்தில் சப்ஸ்ட்ரிங் இருந்தால் 'if' ரெண்டர் செய்யப்பட்ட பிறகு 'cout' அறிக்கையைச் சேர்ப்போம். இல்லையெனில், 'வேறு' என்பதற்குப் பிறகு வரும் 'கவுட்' அறிக்கை வழங்கப்பட்டுள்ளது.
குறியீடு 2:
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
சரம் str_1 = 'வெளியில் வானிலை குளிர்ச்சியாக இருக்கிறது' ;
சரம் str_2 = 'மழை' ;
கூட் << 'சரம் =' << str_1 << endl << endl ;
முழு எண்ணாக விளைவு = str_1. கொண்டுள்ளது ( str_2 ) ;
என்றால் ( விளைவு )
{
கூட் << 'சரத்தில் காணப்படும் வார்த்தை =' << str_2 << endl ;
}
வேறு
{
கூட் << 'சரத்தில் வார்த்தை கிடைக்கவில்லை' << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
இதன் மூலம் நாம் அசல் சரத்தில் கண்டெய்னிங்ஸ்() செயல்பாட்டைப் பயன்படுத்தி கண்டுபிடிக்கும் சப்ஸ்ட்ரிங் அசல் சரத்திற்குள் காணப்படவில்லை, அதன் விளைவாக இங்கே ரெண்டர் செய்யப்படுகிறது.
எடுத்துக்காட்டு 3:
இந்தக் குறியீட்டில் உள்ள “iostream” மற்றும் “string” தலைப்புக் கோப்புகளை நாங்கள் இறக்குமதி செய்கிறோம். பிறகு, இதற்குக் கீழே, நாம் “namespace std” ஐப் பயன்படுத்துகிறோம். பின்னர், முக்கிய() இங்கே அழைக்கப்பட்டது. இப்போது, 'சரம்' தரவு வகையின் இரண்டு மாறிகளை முறையே 'myString_1' மற்றும் 'myString_2' என்ற பெயர்களில் துவக்குகிறோம், மேலும் 'myString_1' மாறிக்கு சப்ஸ்ட்ரிங் கண்டுபிடிக்க விரும்பும் அசல் சரத்தை ஒதுக்குகிறோம் மற்றும் சப்ஸ்ட்ரிங் ஒதுக்கப்படும். 'myString_2' மாறிக்கு.
இதற்குப் பிறகு, 'cout' அறிக்கையில் 'myString_1' ஐ வைத்து, 'if' ஐ வைப்பதன் மூலம் அசல் சரத்தை காண்பிப்போம், அதில் கொடுக்கப்பட்ட சரத்தில் சப்ஸ்ட்ரிங் உள்ளதா என்பதைச் சரிபார்க்கும் 'contains()' முறையைப் பயன்படுத்துகிறோம். அசல் சரத்தில் சப்ஸ்ட்ரிங் இருந்தால், 'கவுட்' உதவியுடன், முடிவை நாங்கள் வழங்குகிறோம்.
நாங்கள் இரண்டு 'கவுட்' அறிக்கைகளை வைக்கிறோம், அதில் ஒன்று 'if' க்குப் பிறகு வைக்கப்படும், மற்றொன்று 'மற்றது' பகுதிக்குப் பிறகு சேர்க்கப்படும். அசல் சரத்தில் சப்ஸ்ட்ரிங் இருந்தால், 'if' க்குப் பிறகு 'cout' ரெண்டர் செய்யப்படும். சப்ஸ்ட்ரிங் கிடைக்கவில்லை என்றால் அல்லது அசல் சரத்தில் சப்ஸ்ட்ரிங் இல்லை என்றால், 'வேறு' என்பதற்குப் பிறகு 'கவுட்' ரெண்டர் செய்யப்படும்.
குறியீடு 3:
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
சரம் myString_1 = 'ஹாய்! ஹலோ வேர்ல்ட்' ;
சரம் myString_2 = 'வணக்கம்' ;
கூட் << 'முழுமையான சரம்' << myString_1 << endl ;
என்றால் ( myString_1. கொண்டுள்ளது ( myString_2 ) ) {
கூட் << 'சரம் கண்டுபிடிக்கப்பட்டது =' << myString_2 << endl ;
}
வேறு {
கூட் << 'சரம் இங்கே காணப்படவில்லை' << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவு, அசல் சரத்திற்குள் நாம் தேடும் சப்ஸ்ட்ரிங், contains() முறையைப் பயன்படுத்தி, அசல் சரத்திற்குள் அமைந்துள்ளது என்பதை நிரூபிக்கிறது, அது இங்கே காட்டப்பட்டுள்ளது.
எடுத்துக்காட்டு 4:
இந்த குறியீட்டில் 'iostream' மற்றும் 'string' தலைப்பு கோப்புகள் இறக்குமதி செய்யப்படுகின்றன. 'namespace std' ஐப் பயன்படுத்திய பிறகு, முக்கிய() செயல்பாடு இங்கே அழைக்கப்படுகிறது. 'ஸ்ட்ரிங்' தரவு வகையின் இரண்டு மாறிகளின் துவக்கங்கள் முறையே 's_1' மற்றும் 's_2' என்று பெயரிடப்பட்டுள்ளன. சப்ஸ்ட்ரிங்கைக் கண்டறிய விரும்பும் அசல் சரம் இப்போது “s_1” மாறிக்கு ஒதுக்கப்பட்டுள்ளது, மேலும் சப்ஸ்ட்ரிங் “s_2” மாறிக்கு வழங்கப்படுகிறது. அசல் சரம் பின்னர் 's_1' ஐ 'cout' அறிக்கையில் செருகுவதன் மூலம் காண்பிக்கப்படும்.
அடுத்து, சப்ளை செய்யப்பட்ட சரத்தில் சப்ஸ்ட்ரிங் உள்ளதா என்பதைத் தீர்மானிக்க, 'if' பிரிவைச் சேர்க்கிறோம். அசல் சரத்தில் சப்ஸ்ட்ரிங் இருந்தால் 'cout' ஐப் பயன்படுத்தி வெளியீட்டை வழங்குவோம். இரண்டு 'கவுட்' அறிக்கைகள் சேர்க்கப்படுகின்றன, ஒன்று 'if' க்குப் பிறகு மற்றும் மற்றொன்று குறியீட்டின் 'மற்ற' பகுதிக்குப் பிறகு. அசல் சரத்தில் சப்ஸ்ட்ரிங் இருந்தால், 'if' ஐத் தொடர்ந்து 'cout' ரெண்டர் செய்யப்படும். இல்லையெனில், அசல் சரத்தில் துணைச்சரத்தை அமைக்க முடியாவிட்டால், 'else' ஐத் தொடர்ந்து 'cout' ரெண்டர் செய்யப்படும்.
குறியீடு 4:
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
சரம் s_1 = 'ஹாய்! நான் ஜாக் இங்கே இருக்கிறேன்'' ;
சரம் s_2 = 'பீட்டர்' ;
கூட் << 'முழுமையான சரம் =' << s_1 << endl ;
என்றால் ( s_1. கொண்டுள்ளது ( s_2 ) ) {
கூட் << 'சரம் கண்டுபிடிக்கப்பட்டது =' << s_2 << endl ;
}
வேறு {
கூட் << 'சரம் கிடைக்கவில்லை =' << s_2 << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவிலிருந்து பார்க்கும்போது, மூல வாசகத்தில் உள்ளடங்கிய () முறையைப் பயன்படுத்தி நாம் தேடிய சப்ஸ்ட்ரிங் குறியீட்டில் காணப்படவில்லை.
எடுத்துக்காட்டு 5:
இங்கே, 'பூஸ்ட்' நூலகத்தைப் பயன்படுத்தி, சரத்தில் சப்ஸ்ட்ரிங் உள்ளதா இல்லையா என்பதைக் கண்டுபிடிப்போம். இந்த 'பூஸ்ட்' முறையில், நாங்கள் கொண்டுள்ளது() செயல்பாட்டையும் பயன்படுத்துகிறோம். எனவே, இந்தக் குறியீட்டில் 'iostream' மற்றும் 'string' தலைப்புக் கோப்புகளுடன் 'boost/algorithm/string.hpp' தலைப்புக் கோப்பையும் சேர்த்துக் கொள்கிறோம். நாம் 'std' ஐ வைத்து, இங்கே முக்கிய() முறையைப் பயன்படுத்துகிறோம்.
பின்னர், 'ஸ்ட்ரிங்' தரவு வகையின் 'ஸ்ட்ரிங் டேட்டா1' மற்றும் 'ஸ்ட்ரிங்டேட்டா2' மாறிகளை அறிவித்து, சரம் தரவை இங்கே துவக்குவோம். 'bool' தரவு வகையின் 'c_result' மாறியானது 'boost::algorithm::contains()' உடன் துவக்கப்பட்டது, மேலும் 'StringData1' மற்றும் 'StringData2' ஐ இந்தச் செயல்பாட்டிற்கு அனுப்புவோம். இது அசல் சரத்தில் உள்ள துணைச்சரத்தையும் கண்டுபிடித்து, பூலியன் முடிவை “c_result” மாறியில் சேமிக்கிறது.
இப்போது, கீழே உள்ள “if” இல் “c_result==1” ஐ வைக்கிறோம். “c_result” இன் பூலியன் மதிப்பு “1” எனில், “if” க்குப் பின் உள்ள அறிக்கை காட்டப்படும். இல்லையெனில், அது 'வேறு' பகுதியை நோக்கி நகர்ந்து, 'if' க்குப் பிறகு இருக்கும் அறிக்கையைத் தவிர்த்து, 'வேறு' பகுதியின் அறிக்கையை வழங்கும்.
குறியீடு 5:
##
# அடங்கும்
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
சரம் StringData1 = 'எனது முதல் திட்டம்' ;
சரம் StringData2 = 'முதல்' ;
bool c_result = ஊக்கம் :: அல்காரிதம் :: கொண்டுள்ளது ( StringData1 , StringData2 ) ;
என்றால் ( c_ முடிவு == 1 )
{
கூட் << 'சரம்' << ''' << StringData1 << ''' << 'கொண்டுள்ளது' << StringData2 << endl ;
}
வேறு
{
கூட் << 'கொடுக்கப்பட்ட வார்த்தை சரத்தில் இல்லை.' ;
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவில் நாம் காணக்கூடிய அசல் சரத்தில் சப்ஸ்ட்ரிங் இப்போது காணப்படுகிறது.
முடிவுரை
C++ மொழியால் வழங்கப்பட்ட உள்ளடக்கங்கள்() முறையை விரிவாக ஆராய்ந்தோம். “C+++ 23” இல் மட்டுமே contains() செயல்பாடு கிடைக்கும் என்பதையும் குறிப்பிட்டோம். அசல் சரத்தில் உள்ள சப்ஸ்ட்ரிங்கைக் கண்டறிவதில், கன்டெயின்ஸ்() செயல்பாடு உதவுகிறதா அல்லது சரத்தில் சப்ஸ்ட்ரிங் உள்ளதா இல்லையா என்பதைச் சரிபார்க்க உதவுகிறதா என்பதை ஆராய்ந்து, அதற்கேற்ப முடிவை வழங்கினோம்.