தப்பிக்கும் காட்சிகளைப் புரிந்துகொள்வது
C++ இல் உள்ள எஸ்கேப் சீக்வென்ஸ்கள், சரங்களுக்குள் கட்டுப்பாட்டு செயல்பாடுகளைச் செய்யும் எழுத்துக்களை குறியீடாக தவறாகக் கருதாமல் உரையின் ஒரு பகுதியாக இருக்க அனுமதிக்கின்றன. தொடக்கநிலையாளர்களுக்கான ஒரு பொதுவான ஆபத்து என்னவென்றால், ஒரு நேரடி சரத்திற்குள் மேற்கோள்களைச் சேர்ப்பதில் உள்ள குழப்பம். எடுத்துக்காட்டாக, '\t எஸ்கேப் சீக்வென்ஸ்' ஐச் சுற்றியுள்ள மேற்கோள்கள் சரத்தை முன்கூட்டியே நிறுத்துவதால், பின்வரும் குறியீட்டின் வரியானது தொகுத்தல் பிழையை ஏற்படுத்தும்:
சரம் txt = 'இந்த கட்டுரை ஆராய்வது பற்றியது' \t எஸ்கேப் சீக்வென்ஸ்” உதாரணங்களின் உதவியுடன்.' ;C++ நிரலில் இதைச் சரிசெய்ய, பின்வரும் எழுத்துக்கு ஒரு சிறப்பு விளக்கம் உள்ளது என்பதை கம்பைலருக்கு அடையாளம் காட்ட, பின்சாய்வுக்கோடானது “\” ஐ எஸ்கேப் கேரக்டராகப் பயன்படுத்துவோம். இது எப்படி செய்யப்படுகிறது என்பது இங்கே:
சரம் txt = 'இந்த கட்டுரை\' பற்றி ஆராய்வது பற்றியது \\ t எஸ்கேப் சீக்வென்ஸ்\” உதாரணங்களின் உதவியுடன்.' ;
C++ இல் சிறப்பு எழுத்துக்கு (\t) டைவிங்
'\t' வரிசையானது ஒரு இடைவெளி கருவியை விட அதிகம். இது கர்சரை அடுத்த தாவல் நிறுத்தத்திற்கு மாற்றும் ஒரு தாவல் எழுத்தைக் குறிக்கிறது. டெர்மினல் பயன்பாடுகளில் நேர்த்தியாக வடிவமைக்கப்பட்ட உரை காட்சிகளை உருவாக்க இது மிகவும் எளிது. “\t” க்கு அப்பால், C++ ஆனது வெவ்வேறு நோக்கங்களுக்காக பல்வேறு தப்பிக்கும் தொடர்களை ஆதரிக்கிறது - எடுத்துக்காட்டாக, “\n” ஒரு புதிய வரியை உருவாக்குகிறது. இருப்பினும், இந்த கட்டுரையில், C++ இல் உள்ள “\t” தப்பிக்கும் வரிசையை அதன் நோக்கம் மற்றும் பயன்பாட்டை விளக்குவதற்கு எடுத்துக்காட்டுகளை வழங்குவதன் மூலம் கவனம் செலுத்துவோம். இது உங்கள் நிரலாக்க பணிகளில் கிடைமட்ட தாவலை திறம்பட பயன்படுத்துவதற்கான அறிவை உங்களுக்கு வழங்கும். C++ நிரலில் “\t” தப்பிக்கும் வரிசையின் செயல்பாட்டைப் புரிந்துகொள்ள எடுத்துக்காட்டுகளுக்குச் செல்லலாம்.
எடுத்துக்காட்டு 1:
பின்வரும் C++ குறியீடு உதாரணம், கன்சோலில் உரையை அச்சிடப் பயன்படும் எளிய நிரலை உள்ளடக்கியது. பின்வரும் குறியீட்டைப் பார்க்கவும், பின்னர் அதை விளக்குவோம்:
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
கூட் << 'இது உரையின் முதல் வரி.' << endl ;
கூட் << 'இது உரையின் இரண்டாவது வரி. \t ' ;
கூட் << 'இந்த வரியைத் தொடர்ந்து ஏ \\ தொடரிலிருந்து தப்பிக்க முடியாது.' ;
திரும்ப 0 ;
}
குறியீட்டின் ஒவ்வொரு பகுதியின் விவரம் இங்கே:
பெயர்வெளி std ஐப் பயன்படுத்துதல்; – இந்தக் குறியீடு, நிலையான நூலகத்தில் சேர்க்கப்பட்டுள்ள பெயர்களை 'std::' என்ற முன்னொட்டு இல்லாமல் பயன்படுத்த அனுமதிக்கிறது. எடுத்துக்காட்டாக, 'std::cout' என்பதற்குப் பதிலாக 'cout' என்று எழுதலாம்.
முழு எண்ணாக () {- இது ஒவ்வொரு C++ நிரலுக்கும் முக்கிய செயல்பாட்டின் அறிவிப்பு மற்றும் நுழைவு புள்ளியாகும். 'முக்கிய' க்கு முன் 'int' பொதுவாக செயல்பாடு முழு எண் மதிப்பை வழங்குகிறது என்பதைக் குறிக்கிறது.
cout << “இது உரையின் முதல் வரி.”<
cout << “இது உரையின் இரண்டாவது வரி.\t”; – இங்கே, நிரல் மற்றொரு சரத்தை வெளியிடுகிறது, இது 'இது உரையின் இரண்டாவது வரி.\t'. இறுதியில் '\t' ஐக் கவனியுங்கள். கன்சோலில் அச்சிடப்படும் போது, அது உரைக்குப் பிறகு கிடைமட்ட தாவல் இடத்தைச் சேர்க்கிறது.
cout << “இந்த வரியைத் தொடர்ந்து \\t தப்பிக்கும் வரிசை உள்ளது.”; – இந்த வரியில், நிரல் 'இந்த வரியைத் தொடர்ந்து \t தப்பிக்கும் வரிசை உள்ளது' என்று அச்சிடுகிறது. '\\t' தப்பிக்கும் வரிசையானது வெளியீட்டில் '\t' ஐச் சேர்க்கப் பயன்படுகிறது, ஏனெனில் '\' என்பது மற்றொரு பின்சாய்வு மூலம் தப்பிக்கப்படுவதால், கிடைமட்ட தாவலுக்குப் பதிலாக '\t' தானே அச்சிடப்படும்.
திரும்ப 0; – இது முக்கிய செயல்பாட்டின் முடிவைக் குறிக்கிறது மற்றும் நிரலின் வெற்றிகரமான செயல்பாட்டைக் குறிக்கும் பூஜ்ஜியத்தை வழங்குகிறது. இந்த நிரல் இயங்கும் போது, வெளியீடு இப்படி இருக்கும்:
எடுத்துக்காட்டு 2:
இப்போது, மற்றொரு உதாரணத்தைப் பார்த்து, '\t' தப்பிக்கும் எழுத்துகளின் மாயத்தைப் பார்ப்போம். எடுத்துக்காட்டு ஒரு எளிய C++ நிரலாகும், இது நிலையான உள்ளீடு-வெளியீட்டு ஸ்ட்ரீம் நூலகத்தை உள்ளடக்கியது மற்றும் நிலையான பெயர்வெளியைப் பயன்படுத்துகிறது. கன்சோலில் பெயர்கள் மற்றும் அவற்றுடன் தொடர்புடைய நகரம் மற்றும் நாடு ஆகியவற்றின் வடிவமைக்கப்பட்ட அட்டவணையை அச்சிட நிரல் வடிவமைக்கப்பட்டுள்ளது.
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
கூட் << 'பெயர் \t | \t நகரம் \t | \t நாடு' << endl ;
கூட் << '------------------------------------------' << endl ;
கூட் << 'ஆலிஸ் \t | \t பெய்ஜிங் \t | \t சீனா' << endl ;
கூட் << 'பாப் \t | \t ஆஸ்டின் \t | \t அமெரிக்கா' << endl ;
கூட் << 'கேத் \t | \t பாரிஸ் \t | \t பிரான்ஸ்' << endl ;
கூட் << 'டேவிட் \t | \t டர்பன் \t | \t தென் ஆப்பிரிக்கா' << endl ;
கூட் << '------------------------------------------' << endl ;
திரும்ப 0 ;
}
குறியீட்டின் முறிவு இங்கே:
மீண்டும், #
பெயர்வெளி std ஐப் பயன்படுத்துதல்; - இது 'std' பெயர்வெளியில் இருந்து நிறுவனங்களை 'std::' உடன் முன்னொட்டு இல்லாமல் பயன்படுத்த அனுமதிக்கிறது.
தி முழு எண்ணாக () { ஒவ்வொரு C++ நிரலின் நுழைவுப் புள்ளியாகும். நீங்கள் நிரலை இயக்கும்போது, இங்கிருந்து செயல்படுத்தல் தொடங்குகிறது.
முக்கிய செயல்பாட்டிற்குள், எங்களிடம் பின்வருபவை உள்ளன:
cout << “பெயர்\t|\tCity\t|\tCountry”<
cout << “——————————————-“<
அடுத்த நான்கு கோட்டுகள் ஒவ்வொன்றும் அட்டவணையின் ஒரு வரிசையை அச்சிடுகின்றன. இந்த வரிகள் தாவல்களுடன் ஒரே வடிவமைப்பைப் பின்பற்றுகின்றன மற்றும் அட்டவணை வெளியீட்டை உருவாக்கும் பகுதியாகும். தரவுகளின் ஒவ்வொரு வரிக்குப் பிறகு, அடுத்த வரிக்குச் செல்ல “endl” பயன்படுத்தப்படுகிறது. அட்டவணையின் தரவின் முடிவைக் குறிக்க கடைசி கவுட் வரி மீண்டும் பிரிப்பான் வரியை அச்சிடுகிறது.
திரும்ப 0;:- இந்த வரி நிரலின் வெற்றிகரமான செயல்பாட்டைக் குறிக்கிறது. வருவாய் மதிப்பு 0 வெற்றியைக் குறிக்கிறது.
இந்த நிரல் தொகுக்கப்பட்டு இயக்கப்படும் போது, செங்குத்து பட்டைகள் (|) மற்றும் தாவல்களால் பிரிக்கப்பட்ட நெடுவரிசைகளில் நேர்த்தியாக சீரமைக்கப்பட்ட தனிநபர்களின் பெயர்கள், நகரங்கள் மற்றும் நாடுகளுடன் கன்சோலில் ஒரு அட்டவணையாக வெளியீடு தோன்றும். பின்வரும் வெளியீட்டைப் பார்க்கவும்:
குறிப்பு: கன்சோலில் உள்ள உரையின் உண்மையான சீரமைப்பு உங்கள் கன்சோல் அல்லது டெர்மினலில் உள்ள தாவல் அமைப்புகளின் அகலத்தைப் பொறுத்தது என்பதை நினைவில் கொள்ளுங்கள், இதன் விளைவாக வெவ்வேறு கணினிகளில் அட்டவணைத் தோற்றங்கள் மாறுபடலாம்.
எடுத்துக்காட்டு 3:
இந்த எளிய ஆனால் சுவாரஸ்யமான C++ நிரல் திரையில் வைர வடிவத்தை அச்சிடுவதற்கு “\t” தாவல் தப்பிக்கும் காட்சிகளைப் பயன்படுத்துகிறது. இந்த குறியீடு 'வைரம்' மாறியின் அடிப்படையில் வைர அளவை அளவிடுகிறது, இது அளவைக் குறிப்பிடுகிறது மற்றும் வைரத்தின் மையத்திலிருந்து அதன் மேல் அல்லது கீழ் வரையிலான கோடுகளின் எண்ணிக்கையைக் குறிக்கிறது. பின்வரும் குறியீட்டை சரிபார்க்கவும்:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக வைரம் = 3 ;
க்கான ( முழு எண்ணாக நான் = 1 ; நான் <= வைரம் ; ++ நான் ) {
க்கான ( முழு எண்ணாக ஜே = 0 ; ஜே < வைரம் - நான் ; ++ ஜே ) {
கூட் << ' \t ' ;
}
க்கான ( முழு எண்ணாக ஜே = 0 ; ஜே < 2 * நான் - 1 ; ++ ஜே ) {
கூட் << '* \t ' ; }
கூட் << endl ;
}
க்கான ( முழு எண்ணாக நான் = வைரம் - 1 ; நான் >= 1 ; -- நான் ) {
க்கான ( முழு எண்ணாக ஜே = 0 ; ஜே < வைரம் - நான் ; ++ ஜே ) {
கூட் << ' \t ' ;
}
க்கான ( முழு எண்ணாக ஜே = 0 ; ஜே < 2 * நான் - 1 ; ++ ஜே ) {
கூட் << '* \t ' ; }
கூட் << endl ;
}
திரும்ப 0 ;
}
நீங்கள் பார்க்க முடியும் என, இந்த நிரல் இரண்டு பகுதிகளைக் கொண்டுள்ளது: ஒன்று வைரத்தின் மேல் பாதியை அச்சிடுகிறது, மற்றொன்று கீழ் பாதியை அச்சிடுகிறது. வைரத்தின் மேல் பாதியானது, உள்தள்ளலை உருவாக்க, குறைந்த எண்ணிக்கையிலான தாவல்களை முதலில் வெளியிடுவதன் மூலம் அச்சிடப்படுகிறது, அதைத் தொடர்ந்து தாவல்களால் பிரிக்கப்பட்ட '*' நட்சத்திரங்களின் எண்ணிக்கை அதிகரிக்கும். இது முதல் 'for' லூப்பில் கையாளப்படுகிறது.
கீழ் பாதியும் இதேபோல் அச்சிடப்பட்டுள்ளது, ஆனால் சுழல்கள் தலைகீழாகச் செயல்படுவதால் நட்சத்திரக் குறியீடுகளின் எண்ணிக்கையைக் குறைத்து மீண்டும் உள்தள்ளலை அதிகரிக்கவும், இது வைரத்தின் கீழ் பாதியை உருவாக்குகிறது. இது இரண்டாவது 'for' லூப்பில் கையாளப்படுகிறது.
“டயமண்ட்= 3” உடன் நிரலை இயக்கும் போது, வெளியீடு தாவல் எழுத்துக்களின் காரணமாக திரையில் மையமாக இருக்கும் ஒரு வைரம் போல் தெரிகிறது. இந்த குறிப்பிட்ட நிரலின் வெளியீட்டைப் பார்க்கவும்:
தாவல் அகலங்கள் மாறுபடும் என்பதால், நீங்கள் பயன்படுத்தும் கன்சோல் அல்லது முனையத்தைப் பொறுத்து உண்மையான தோற்றம் மாறுபடலாம் என்பதை நினைவில் கொள்ளவும்.
முடிவுரை
C++ இல் உள்ள எஸ்கேப் சீக்வென்ஸ்கள் ஒரு நிலையான வெளியீட்டு சாளரத்தில் உடனடியாகக் காட்ட முடியாத எழுத்துக்களைக் குறிக்கும் சக்திவாய்ந்த கருவியாகும். இந்த வரிசைகளில், '\t' ஆல் குறிக்கப்படும் கிடைமட்ட தாவல், உரையில் கட்டுப்படுத்தப்பட்ட கிடைமட்ட இடைவெளிகளைச் சேர்ப்பதற்கு மிகவும் பயனுள்ளதாக இருக்கும். “\t” ஐப் பயன்படுத்தி, புரோகிராமர்கள் தங்கள் உரை வெளியீட்டை சீரமைக்கலாம், வாசிப்புத்திறனை மேம்படுத்தலாம் மற்றும் தரவை முறையாக கட்டமைக்கலாம். இந்த எழுத்து விசைப்பலகையில் 'டேப்' விசையை அழுத்தி, கர்சரை அடுத்த தாவல் நிலைக்கு நகர்த்துவதைப் பின்பற்றுகிறது. இந்தக் கட்டுரையில், C++ மொழியில் “\t” தப்பிக்கும் வரிசையின் செயல்பாட்டை ஆராய்ந்தோம், அதன் நடத்தையை விளக்குவதற்கு நேரடியான மற்றும் நடைமுறை எடுத்துக்காட்டுகளுடன் அதன் பயன்பாட்டை முன்னிலைப்படுத்துகிறோம்.