C++ நிரலாக்கத்தில் ஒரு சரத்தை மாற்றுவதற்கான நுட்பங்கள்
நாங்கள் உருவாக்கும் குறியீடு விவரக்குறிப்புகளைப் பொறுத்து, C++ நிரலாக்கத்தில் சரம் தலைகீழாகச் செயல்படுத்த பல நுட்பங்கள் உள்ளன. இந்த நுட்பங்கள்:
- 'தலைகீழ் ()' முறையைப் பயன்படுத்துதல்
- 'strev()' முறையைப் பயன்படுத்துதல்
- 'For' லூப்பைப் பயன்படுத்துதல்
- 'while' லூப்பைப் பயன்படுத்துதல்
- கட்டமைப்பாளரைப் பயன்படுத்துதல்
எடுத்துக்காட்டு 1:
முதலில், 'அல்காரிதம்', 'ஐயோஸ்ட்ரீம்' மற்றும் 'ஸ்ட்ரிங்' ஆகிய மூன்று தனித்துவமான தலைப்புக் கோப்புகளை இறக்குமதி செய்கிறோம். இந்த தலைப்புக் கோப்புகளை நாம் சேர்க்க வேண்டும், எனவே அவற்றில் வரையறுக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்துவோம். “அல்காரிதம்” தலைப்புக் கோப்பில் நமக்குக் கிடைக்கக்கூடிய கண்டறிதல், வரிசைப்படுத்துதல், எண்ணுதல், மாற்றுதல் போன்ற பல உள்ளமைக்கப்பட்ட செயல்பாடுகள் உள்ளன.
பின்னர், 'iostream' தரவை உள்ளிடுவதற்கு அல்லது வெளியிடுவதற்கான செயல்பாடுகளை வழங்குகிறது, மேலும் சரம் தரவுகளுடன் பணிபுரியும் போது தேவையான செயல்பாடுகளை வழங்குவதால் 'ஸ்ட்ரிங்' தலைப்பு கோப்பு சேர்க்கப்பட்டுள்ளது. இந்த தலைப்புக் கோப்புகளின் கீழ், “std” பெயர்வெளியைச் சேர்க்கிறோம். இங்கே, நாம் 'முதன்மை()' செயல்பாட்டை அழைக்கிறோம்.
பின்னர், 'ஸ்ட்ரிங்' தரவு வகையை வைத்து, சில சரம் தரவுகளுடன் 'originalStr' ஐ துவக்குவோம். பின்னர், அந்த சரத்தை அச்சிடுகிறோம். இதற்குப் பிறகு, சரத்தைத் தலைகீழாக மாற்ற உதவும் “ரிவர்ஸ்()” முறையைப் பயன்படுத்துகிறோம். இந்த “தலைகீழ்()” முறையில், “originalStr” மாறியுடன் “begin()” மற்றும் “end()” ஐ சேர்க்கிறோம். இப்போது, 'தலைகீழ்()' முறையைப் பயன்படுத்திய பிறகு நமக்குக் கிடைக்கும் இந்த தலைகீழ் சரத்தையும் அச்சிடுகிறோம்.
குறியீடு 1:
#அடங்கும் <அல்காரிதம்>
# அடங்கும்
#அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
சரம் அசல்Str = 'C++ நிரலாக்கத்தில் சரம் தலைகீழ்' ;
கூட் << 'அசல் சரம்!' << endl ;
கூட் << அசல்Str << endl << endl ;
தலைகீழ் ( அசல்Str. தொடங்கும் ( ) , அசல்Str. முடிவு ( ) ) ;
கூட் << 'தலைகீழ் சரம்!' << endl ;
கூட் << அசல்Str ;
திரும்ப 0 ;
}
வெளியீடு:
எங்கள் குறியீட்டில் “ரிவர்ஸ்()” முறையைப் பயன்படுத்திய பிறகு நாம் பெறும் தலைகீழ் சரம் இப்போது அசல் சரத்துடன் ரெண்டர் செய்யப்படுகிறது.
எடுத்துக்காட்டு 2:
முதலில் தலைப்புக் கோப்புகளைச் சேர்த்து, பின்னர் “namespace std” ஐ வைப்போம். பின்னர், “main()” முறையில், “Char” தரவு வகையை “Org_str” மாறி பெயருடன் வைப்பதன் மூலம் எழுத்து வரிசையை துவக்கி, நாம் தலைகீழாக மாற்ற விரும்பும் சரத்தை இங்கே தட்டச்சு செய்கிறோம். பின்னர், இந்த 'Org_str' ஐ 'cout' உதவியுடன் வழங்குகிறோம்.
இதன் அடியில், சரத்தை மாற்றியமைக்க “strrev()” முறையைப் பயன்படுத்துகிறோம் மற்றும் இந்தச் செயல்பாட்டின் அளவுருவாக “Org_str” ஐ அனுப்புவோம். இப்போது, சரம் இங்கே தலைகீழாக உள்ளது. இதற்குப் பிறகு, 'கவுட்' உதவியுடன் தலைகீழ் சரத்தையும் நாங்கள் வழங்குகிறோம்.
குறியீடு 2:
# அடங்கும்# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
கரி Org_str [ ] = 'ஸ்ட்ரிங் ரிவர்ஸ் புரோகிராம்' ;
கூட் << Org_str << endl << endl ;
strev ( Org_str ) ;
கூட் << 'தலைகீழ் சரம்' << endl ;
கூட் << Org_str ;
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, எங்கள் குறியீட்டில் உள்ள “strrev()” முறையைப் பயன்படுத்தி நாம் பெற்ற அசல் மற்றும் தலைகீழ் சரங்கள் வழங்கப்படுகின்றன.
எடுத்துக்காட்டு 3:
இந்த வழக்கில், 'பெயர்வெளி std' சேர்க்கப்படுவதற்கு முன் தலைப்பு கோப்புகள் சேர்க்கப்படும். பின்னர், 'main()' செயல்படுத்தப்பட்டு, 'myOrgStr' என்ற பெயருடன் சரம் மாறி சேர்க்கப்பட்டு, சரம் தரவுடன் துவக்கவும்.
இதற்குப் பிறகு, 'int' மாறி 'a' ஐயும் அறிவித்து, 'cout' ஐப் பயன்படுத்தி 'myOrgStr' சரத்தை வழங்குவோம். இதற்குக் கீழே, 'for' லூப்பைப் பயன்படுத்துகிறோம், அங்கு 'a' மாறியை 'myOrgStr.length() - 1' உடன் துவக்கி, பின்னர் 'a >= 0' என்று ஒரு நிபந்தனையை வைத்து அதை 'a இன் மதிப்பில் குறைப்போம். ”. இது எங்கள் சரத்தைத் தலைகீழாக மாற்றி, அதை “myOrgStr[a]” இல் சேமித்து, “cout” க்குள் “myOrgStr[a]” ஐ வைக்கும்போது அதைக் காண்பிக்கும்.
குறியீடு 3:
# அடங்கும்#அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
சரம் myOrgStr = 'ஹலோ வேர்ல்ட்!' ;
முழு எண்ணாக அ ;
கூட் << myOrgStr << endl << endl ;
கூட் << 'தலைகீழ் சரம்' <= 0 ; அ -- )
{
கூட் << myOrgStr [ அ ] ;
}
திரும்ப 0 ;
}
வெளியீடு:
இது 'for' லூப் முறையைப் பயன்படுத்தி எங்கள் குறியீடு வழியாகப் பெற்ற அசல் மற்றும் தலைகீழ் சரங்களை ரெண்டர் செய்கிறது.
எடுத்துக்காட்டு 4:
இங்கே, 'bits/stdc++.h' தலைப்புக் கோப்பை இறக்குமதி செய்கிறோம், எனவே இந்த தலைப்புக் கோப்பு அனைத்து செயல்பாட்டின் வரையறைகளையும் கொண்டிருப்பதால் மற்ற தலைப்புக் கோப்புகளை இறக்குமதி செய்ய வேண்டியதில்லை. பின்னர், நாம் 'namespace std' என தட்டச்சு செய்கிறோம். இங்கே, 'Rev()' என்ற பெயரில் ஒரு செயல்பாட்டை உருவாக்குகிறோம், அதில் இந்த செயல்பாட்டின் வாதமாக 'ஸ்ட்ரிங்& myString' ஐ அனுப்புகிறோம். சரத்தை தலைகீழாக மாற்ற இந்த செயல்பாட்டை உருவாக்குகிறோம்.
இந்தச் செயல்பாட்டில், “int” தரவு வகையின் “S_len” மாறியை வைத்து, இதனுடன் “myString” ஐ வைத்து “length()” செயல்பாட்டின் மூலம் துவக்குவோம். பின்னர், எங்களிடம் மற்றொரு மாறி உள்ளது, அது 'int' தரவு வகையின் 'இல்லை' மற்றும் அதை 'S_len-1' மூலம் துவக்கவும்.
இதன் அடியில், மேலும் ஒரு மாறி துவக்கப்படுகிறது, இது 'int' தரவு வகையின் 'a' என்று பெயரிடப்பட்டது. இங்கே, நாம் “while()” லூப்பைப் பயன்படுத்துகிறோம் மற்றும் நிபந்தனையாக “a <= no” ஐச் சேர்க்கிறோம். பின்னர், 'swap()' முறையைப் பயன்படுத்துகிறோம். இந்த 'swap()' முறை சரம் தரவை மாற்ற உதவுகிறது, பின்னர் 'no -1' உடன் 'no' ஐ துவக்குகிறது. நாங்கள் 'a' ஐ 'a+1' உடன் துவக்குகிறோம்.
நாம் இங்கே 'main()' ஐ அழைக்கிறோம், அதில் 'myString' மாறியை சரம் தரவுடன் துவக்கி அந்த சரத்தை அச்சிடுவோம். இதற்குப் பிறகு, இந்த குறியீட்டில் நாம் உருவாக்கிய “Rev()” செயல்பாட்டை அழைக்கிறோம் மற்றும் இந்த செயல்பாட்டின் அளவுருவாக “myString” ஐ வைத்து, இது சரத்தை தலைகீழாக மாற்றுகிறது, பின்னர் தலைகீழ் சரத்தை காண்பிக்கும்.
குறியீடு 4:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வெற்றிடமானது ரெவ் ( லேசான கயிறு & myString )
{
முழு எண்ணாக S_len = myString. நீளம் ( ) ;
முழு எண்ணாக இல்லை = S_len - 1 ;
முழு எண்ணாக அ = 0 ;
போது ( அ <= இல்லை ) {
இடமாற்று ( myString [ அ ] ,மைஸ்ட்ரிங் [ இல்லை ] ) ;
இல்லை = இல்லை - 1 ;
அ = அ + 1 ;
}
}
முழு எண்ணாக முக்கிய ( )
{
சரம் myString = 'நான் நிரலாக்கத்தை விரும்புகிறேன்' ;
கூட் << myString << endl ;
கூட் << ' \n தலைகீழ் சரம்' << endl ;
ரெவ் ( myString ) ;
கூட் << myString ;
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, 'while()' loop மற்றும் 'swap()' முறையைப் பயன்படுத்தி, நமது குறியீட்டில் நாம் உருவாக்கிய செயல்பாட்டிற்குள் நாம் பெற்ற அசல் சரம் மற்றும் தலைகீழ் சரம் இரண்டையும் வழங்குகிறோம்.
எடுத்துக்காட்டு 5:
'bits/stdc++.h' தலைப்புக் கோப்பை அனைத்து செயல்பாட்டு வரையறைகளுடன் இறக்குமதி செய்கிறோம். எனவே, வேறு எந்த தலைப்புக் கோப்புகளையும் நாங்கள் இறக்குமதி செய்ய வேண்டியதில்லை. அடுத்து, நாம் “namespace std” ஐ உள்ளிட்டு “main()” ஐ இங்கே அழைக்கிறோம். பின்னர், எங்களிடம் “ஸ்ட்ரிங்” தரவு வகையின் மாறி “தரவு” உள்ளது மற்றும் அதை நாம் தலைகீழாக மாற்ற விரும்பும் சரத்துடன் துவக்கவும்.
இந்த அசல் சரத்தை மாற்றுவதற்கு முன், “டேட்டா” மாறியை “கவுட்” இல் வைப்பதன் மூலம் வழங்குவோம். இதன் கீழ், அதே 'ஸ்ட்ரிங்' தரவு வகையின் 'revStr' என்ற மற்றொரு மாறியை துவக்குகிறோம். பின்னர், 'rbegin()' மற்றும் 'rend()' ஆகியவற்றைப் பயன்படுத்துகிறோம், அவை இங்கே சரத்தை மாற்றியமைப்பதற்காக நாம் சேர்க்கும் தலைகீழ் மறு செய்கைகளாகும். தலைகீழ் சரம் இப்போது 'revStr' மாறியில் சேமிக்கப்பட்டுள்ளது, இது தலைகீழ் சரத்தை இங்கே அச்சிட 'cout' இல் வைக்கப்பட்டுள்ளது.
குறியீடு 5:
#சேர்க்கிறதுபயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
சரம் தரவு = 'சி++ சிறந்த நிரலாக்க மொழி' ;
கூட் << தகவல்கள் << endl << endl ;
சரம் revStr = லேசான கயிறு ( தகவல்கள். rbegin ( ) , தகவல்கள். செய்கிறது ( ) ) ;
கூட் << revStr << endl ;
திரும்ப 0 ;
}
வெளியீடு:
குறியீட்டில் நாம் சேர்த்த சரம் முதலில் இங்கே ரெண்டர் செய்யப்படுகிறது. பின், ரிவர்ஸ் இட்டரேட்டர்களைப் பயன்படுத்தி நாம் பெற்ற தலைகீழ் சரம் பின்வருவனவற்றில் காட்டப்படும்:
முடிவுரை
C++ நிரலாக்கத்தில் உள்ள “ஸ்ட்ரிங் ரிவர்ஸ்” கான்செப்ட் இந்தக் கட்டுரையில் விவாதிக்கப்படுகிறது, அங்கு சரத்தை மாற்றுவதற்கான பல நுட்பங்களை நாங்கள் ஆராய்ந்தோம். C++ இல் உள்ள சரத்தை தலைகீழாக மாற்ற உதவும் அனைத்து முறைகளையும் விரிவாக ஆராய்ந்து, எங்கள் C++ குறியீடுகளில் உள்ள சரத்தை மாற்றியமைத்தோம். இந்தக் கட்டுரையில், எங்கள் குறியீடுகளில் அசல் மற்றும் தலைகீழ் சரங்களைக் காட்டினோம்.