வர்க்கம் மற்றும் பொருள்கள்
ஒரு வகுப்பு என்பது மாறிகள் மற்றும் செயல்பாடுகளின் தொகுப்பாகும்; மாறிகள் மதிப்புகள் ஒதுக்கப்படவில்லை. மாறிகள் மதிப்புகள் ஒதுக்கப்படும் போது, வர்க்கம் ஒரு பொருளாக மாறும். ஒரே வர்க்கத்திற்கு கொடுக்கப்படும் வெவ்வேறு மதிப்புகள் வெவ்வேறு பொருள்களை விளைவிக்கின்றன; அதாவது, வெவ்வேறு பொருள்கள் வெவ்வேறு மதிப்புகளுடன் ஒரே வர்க்கம். ஒரு வகுப்பிலிருந்து ஒரு பொருளை உருவாக்குவது அந்தப் பொருளை உடனடியாக நிறுவுவதாகக் கூறப்படுகிறது.
பெயர், சரம், ஒரு வர்க்கம். சரம் வகுப்பிலிருந்து உருவாக்கப்பட்ட ஒரு பொருள் ஒரு புரோகிராமர் தேர்ந்தெடுத்த பெயரைக் கொண்டுள்ளது.
வகுப்பிலிருந்து ஒரு பொருளை உடனடியாக வகுப்பதற்கு ஒரு செயல்பாடு தேவைப்படுகிறது. C ++ இல், அந்தச் செயல்பாட்டிற்கு வகுப்பின் பெயரின் அதே பெயர் உள்ளது. வகுப்பிலிருந்து உருவாக்கப்பட்ட (உடனடி) பொருள்கள் வெவ்வேறு பெயர்களைக் கொண்டுள்ளன, அவை புரோகிராமரால் வழங்கப்படுகின்றன.
ஒரு வகுப்பிலிருந்து ஒரு பொருளை உருவாக்குதல் என்பது பொருளை உருவாக்குவதாகும்; இது உடனடி என்று பொருள்.
சரம் வகுப்பைப் பயன்படுத்தும் ஒரு சி ++ நிரல், கோப்பின் மேற்புறத்தில் பின்வரும் வரிகளுடன் தொடங்குகிறது:
#சேர்க்கிறது#சேர்க்கிறது
நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;
முதல் வரி உள்ளீடு/வெளியீடு. இரண்டாவது வரி நிரல் சரம் வகுப்பின் அனைத்து அம்சங்களையும் பயன்படுத்த அனுமதிக்கிறது. மூன்றாவது வரி நிரலை நிலையான பெயர்வெளியில் உள்ள பெயர்களைப் பயன்படுத்த அனுமதிக்கிறது.
ஒரு செயல்பாட்டை ஓவர்லோட் செய்தல்
இரண்டு அல்லது அதற்கு மேற்பட்ட வெவ்வேறு செயல்பாட்டு கையொப்பங்கள் ஒரே பெயரைக் கொண்டிருக்கும் போது, அந்தப் பெயர் ஓவர்லோட் செய்யப்பட்டதாகக் கூறப்படுகிறது. ஒரு செயல்பாடு அழைக்கப்படும் போது, வாதங்களின் எண்ணிக்கை மற்றும் வகை, எந்த செயல்பாடு செயல்படுத்தப்படுகிறது என்பதை தீர்மானிக்கவும்.
கட்டுமானம்
லேசான கயிறு()
பின்வரும் அறிக்கை எந்த எழுத்தும் இல்லாமல் பூஜ்ஜிய நீளத்தின் சரத்தை உருவாக்குகிறது.
இது வர்க்கத்தின் (பொருள் வகை), சரத்தின் பெயருடன் தொடங்குகிறது. இதற்குப் பிறகு புரோகிராமரால் கொடுக்கப்பட்ட ஆப்ஜெக்ட் ஸ்ட்ரிங்கிற்கான பெயர். அசைன்மென்ட் ஆபரேட்டர் பின்வருமாறு; பின்னர் வெற்று அடைப்புக்குறிக்குள் கட்டமைப்பாளரின் பெயர். இங்கே, strCol என்பது அனைத்து தரவு உறுப்பினர்கள் (பண்புகள்) மற்றும் உறுப்பினர் செயல்பாடுகள் (முறைகள்) கொண்ட உடனடி பொருள்.
சரம் (str)
இது மேற்கூறியதைப் போன்றது, ஆனால் கட்டமைப்பாளரில் ஒரு சரம் நேரடி அல்லது அடையாளங்காட்டியை ஒரு வாதமாக எடுத்துக்கொள்கிறது. பின்வரும் அறிக்கை இதை விளக்குகிறது:
துவக்க பட்டியலுடன் கட்டுமானம்
பின்வரும் குறியீடு இதை விளக்குகிறது:
சரம் strCol=லேசான கயிறு({'நான்','','தி','அல்லது','v','மற்றும்','','மற்றும்','அல்லது','u',' 0'});சரம் உண்மையில் நான் உன்னை நேசிக்கிறேன். துவக்கப் பட்டியலின் முடிவில் உள்ள பூஜ்ய எழுத்தைக் கவனியுங்கள்.
சரம் (str, n)
இது மற்றொரு சரத்தின் முதல் n எழுத்துகளின் சரம் தொகுப்பை உருவாக்குகிறது. பின்வரும் குறியீடு இதை விளக்குகிறது:
கரிப[] = 'நான் உன்னை காதலிக்கிறேன்';சரம் strCol=லேசான கயிறு(ப, 6);
செலவு<<strCol<< ' n';
வெளியீடு ஐ லவ் யூ முதல் 6 கதாபாத்திரங்களுடன் நான் விரும்புகிறேன். நினைவில் கொள்ளுங்கள்: ஒற்றை இடம் ஒரு எழுத்து.
சரம் (str, pos, n)
இது n எழுத்துகளின் சரம் தொகுப்பை உருவாக்குகிறது, பூஜ்ஜிய அடிப்படையிலான அட்டவணைப்படுத்தப்பட்ட நிலையில் இருந்து தொடங்குகிறது, pos, மற்றொரு சரத்தின். பின்வரும் குறியீடு இதை விளக்குகிறது:
கரிப[] = 'நான் உன்னை காதலிக்கிறேன்';சரம் strCol=லேசான கயிறு(ப, 2, 4);
செலவு<<strCol<< ' n';
வெளியீடு, காதல்.
மேலே உள்ள இரண்டு நிகழ்வுகளுக்கு, சரத்தின் அளவை விட n அதிகமாக இருந்தால், out_of_range விதிவிலக்கு வீசப்படுகிறது - பிறகு பார்க்கவும்.
சரம் (n, 'c')
அனைத்து எழுத்துக்களும் ஒரே மாதிரியான n எழுத்துக்களின் தொகுப்பை உருவாக்குகிறது. கருதுங்கள்,
சரம் strCol=லேசான கயிறு(5,'மற்றும்');செலவு<<strCol<< ' n';
வெளியீடு, ஈஈஈ, 5 இ.
ஒரு சரத்தை ஒதுக்குதல்
இரண்டு சரங்களையும் அறிவித்த பிறகு, ஒரு சரத்தை பின்வருமாறு ஒதுக்கலாம்:
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');சரம் strCol2;
strCol2=strCol1;
செலவு<<strCol2<< ' n';
வெளியீடு, நான் உன்னை நேசிக்கிறேன்.
ஐடரேட்டர் மூலம் கட்டமைத்தல்
ஒரு இட்ரேட்டர் ஒரு தொகுப்பின் மதிப்புகள் மூலம், ஸ்கேனிங்கின் பொதுவான பிரதிநிதித்துவத்தை வழங்குகிறது. இட்ரேட்டருடன் ஒரு சரத்தை உருவாக்குவதற்கான தொடரியல்:
டெம்ப்ளேட்<வகுப்பு உள்ளீட்டாளர்>அடிப்படை_சரம்(உள்ளீட்டு இட்டரேட்டர் தொடங்குகிறது,உள்ளீடுஇடரேட்டர் முடிவு, கான்ஸ்ட்ஒதுக்கீடு செய்பவர்&
க்கு=ஒதுக்கீடு செய்பவர்());
இது வரம்புக்கு ஒரு தொடரை உருவாக்குகிறது [தொடங்கு, முடிவு) - பின்னர் விவரங்களைப் பார்க்கவும்.
ஒரு சரத்தை அழித்தல்
ஒரு சரத்தை அழிக்க, அது நோக்கம் இல்லாமல் போகட்டும்.
சரம் வகுப்பு உறுப்பு அணுகல்
ஒரு உடனடி சரம் பொருளை ஒரு வரிசை போல துணை-ஸ்கிரிப்ட் (அட்டவணைப்படுத்தப்பட்ட) செய்யலாம். குறியீட்டு எண்ணிக்கை பூஜ்ஜியத்திலிருந்து தொடங்குகிறது.
சரம் பெயர் [i]
செயல்பாட்டு சரம் பெயர் [i] i இல் எழுத்து (உறுப்பு) பற்றிய குறிப்பை வழங்குகிறதுவதுஎழுத்து சேகரிப்பின் குறியீடு. பின்வரும் குறியீடு வெளியீடுகள் v:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol[4];
செலவு<<சா<< ' n';
stringName [i] const
சரம் பொருள் ஒரு நிலையான பொருளாக இருக்கும்போது stringName [i] க்குப் பதிலாக stringName [i] const இயக்கப்படுகிறது. இது பின்வரும் குறியீட்டில் பயன்படுத்தப்படுகிறது:
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol[4];
செலவு<<சா<< ' n';
வெளிப்பாடு i க்கு ஒரு நிலையான குறிப்பை வழங்குகிறதுவதுசரம் பொருளின் உறுப்பு. சரத்தின் உறுப்புகள் எதையும் மாற்ற முடியாது.
துணை எழுத்துடன் ஒரு பாத்திரத்தை ஒதுக்குதல்
பின்வருமாறு, ஒரு எழுத்து அல்லாத நிலையான சரம் பொருளுக்கு ஒதுக்கப்படலாம்:
சரம் strCol=லேசான கயிறு('நான் அழைக்கிறேன்');strCol[2] = 'f';
செலவு<<strCol<< ' n';
வெளியீடு நான் விழும். 'C' 'f' ஆக மாற்றப்பட்டது.
stringName.at (i)
stringName.at (i) என்பது stringName [i] போன்றது, ஆனால் stringName.at (i) மிகவும் நம்பகமானது. பின்வரும் குறியீடு அதை எவ்வாறு பயன்படுத்த வேண்டும் என்பதைக் காட்டுகிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol.மணிக்கு(4);
செலவு<<சா<< ' n';
at () உண்மையில் ஒரு சரம் வகுப்பு உறுப்பினர் செயல்பாடு.
stringName.at (i) const
stringName.at (i) const என்பது stringName [i] const ஐப் போன்றது, ஆனால் stringName.at (i) const மிகவும் நம்பகமானது. stringName.at (i) const ஆனது stringName.at (i) க்கு பதிலாக string பொருள் ஒரு நிலையான சரம் பொருளாக இருக்கும்போது செயல்படுத்தப்படுகிறது. இது பின்வரும் குறியீட்டில் பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக:
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol.மணிக்கு(4);
செலவு<<சா<< ' n';
at () const உண்மையில் ஒரு சரம் வகுப்பு உறுப்பினர் செயல்பாடு.
At () செயல்பாட்டுடன் ஒரு மதிப்பை ஒதுக்குதல்
ஒரு (நிலையான) சரம் பொருளுக்கு ஒரு மதிப்பை ஒதுக்கலாம்.
சரம் strCol=லேசான கயிறு('நான் அழைக்கிறேன்');strCol.மணிக்கு(2) = 'f';
செலவு<<strCol<< ' n';
வெளியீடு நான் விழும்.
சப்-ஸ்கிரிப்டிங்கில் சிக்கல்
சப்-ஸ்கிரிப்டிங் (இன்டெக்ஸிங்) பிரச்சனை என்னவென்றால், இன்டெக்ஸ் வரம்பிற்கு வெளியே இருந்தால், தவறான முடிவு பெறப்படலாம் அல்லது ரன் டைமில் பிழை வழங்கப்படலாம்.
முன் ()
உறுப்பை அகற்றாமல், சரம் பொருளின் முதல் உறுப்புக்கான குறிப்பை இது வழங்குகிறது. பின்வரும் குறியீட்டின் வெளியீடு 'I' ஆகும்.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol.முன்();
செலவு<<சா<< ' n';
சரம் பொருளில் இருந்து எழுத்து நீக்கப்படவில்லை.
முன் () const
ஸ்ட்ரிங் ஆப்ஜெக்ட் கட்டுமானத்திற்கு முன்னால் கான்ஸ்ட்டால், முன் () கான்ஸ்ட்ரேஷன் என்பது ஃப்ரண்ட் () க்கு பதிலாக செயல்படுத்தப்படுகிறது. இது பின்வரும் குறியீட்டில் பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol.முன்();
செலவு<<சா<< ' n';
ஒரு நிலையான குறிப்பு திருப்பி அனுப்பப்பட்டது. சரம் பொருளில் இருந்து உறுப்பு அகற்றப்படவில்லை. நிலையான சரம் பொருளுக்கு எந்த எழுத்தையும் மாற்ற முடியாது.
மீண்டும்()
உறுப்பை அகற்றாமல், சரம் பொருளின் கடைசி உறுப்புக்கான குறிப்பை இது வழங்குகிறது. பின்வரும் குறியீட்டின் வெளியீடு 'u' ஆகும்.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol.மீண்டும்();
செலவு<<சா<< ' n';
பின் () const
ஸ்ட்ரிங் ஆப்ஜெக்ட் கட்டுமானத்திற்கு முன் கான்ஸ்டால், வெளிப்பாடு (() கான்ஸ்ட்டுக்குப் பதிலாக பின் இது பின்வரும் குறியீட்டில் பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');கரிசா=strCol.மீண்டும்();
செலவு<<சா<< ' n';
ஒரு நிலையான குறிப்பு திருப்பி அனுப்பப்பட்டது. சரம் பொருளில் இருந்து உறுப்பு அகற்றப்படவில்லை.
சரம் திறன்
size_type திறன் () const
மறு ஒதுக்கீடு தேவையில்லாமல் சரத்தின் மொத்த எழுத்துக்களின் எண்ணிக்கை, இந்த திறன் உறுப்பினர் செயல்பாட்டால் திருப்பித் தரப்படுகிறது. இதற்கான குறியீடு பிரிவு:
சரம் strCol=லேசான கயிறு();intஒன்றின் மீது=strCol.திறன்();
செலவு<<ஒன்றின் மீது<< ' n';
எனது கணினியில் வெளியீடு 15 ஆகும்.
இருப்பு (n)
நினைவக இடம் எப்போதும் இலவசக் கடையில் கிடைக்காது. கூடுதல் இடத்தை முன்கூட்டியே முன்பதிவு செய்யலாம். பின்வரும் குறியீட்டுப் பகுதியைக் கவனியுங்கள்:
சரம் strCol=லேசான கயிறு('காதல்');strCol.இருப்பு(6);
செலவு<<strCol.திறன்() << ' n';
எனது கணினியில் வெளியீடு 15 ஆகும்.
அளவு () const noexcept
இது சரத்தில் உள்ள எழுத்துக்களின் எண்ணிக்கையை வழங்குகிறது. பின்வரும் குறியீடு விளக்குகிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');intஒன்றின் மீது=strCol.அளவு();
செலவு<<ஒன்றின் மீது<< ' n';
வெளியீடு 10 ஆகும், இதில் nul, 0 எழுத்தை சேர்க்கவில்லை.
நீளம் () கான்ஸ்ட் தவிர
-அளவு போலவே().குறிப்பு:அளவு() <=திறன்().
பொருந்துவதற்கு ஏற்றவாறு சுருக்குதல்()
இடமாற்றத்தை ஏற்படுத்துவதன் மூலம் திறனை () அளவிற்கு () குறைக்க முடியும்; அது கட்டாயமில்லை. பின்வரும் குறியீடு இதை நிரூபிக்கிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol.இருப்பு(12);
strCol.பொருந்துவதற்கு ஏற்றவாறு சுருக்குதல்();
intகள்=strCol.அளவு();
செலவு<<கள்<< ' n';
வெளியீடு 10 மற்றும் 12 அல்லது 16 அல்ல. செயல்பாடு வெற்றிடத்தை அளிக்கிறது.
அளவை (sz), மறுஅளவிடு (sz, 'c')
இது சரத்தின் அளவை மாற்றுகிறது. புதிய அளவு பழைய அளவை விட சிறியதாக இருந்தால், இறுதியில் உள்ள உறுப்புகள் அழிக்கப்படும். புதிய அளவு நீளமாக இருந்தால், இறுதியில் சில இயல்புநிலை எழுத்து சேர்க்கப்படும். ஒரு குறிப்பிட்ட எழுத்தை சேர்க்க, மறுஅளவிடுதல் () செயல்பாட்டை இரண்டு வாதங்களுடன் பயன்படுத்தவும். பின்வரும் குறியீடு பிரிவு இரண்டு செயல்பாடுகளின் பயன்பாட்டை விளக்குகிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol.மறுஅளவிடு(6);
செலவு<< 'StrCol இன் புதிய அளவு:' <<strCol.அளவு() << ' n';
சரம் strCol1=லேசான கயிறு('நான் நேசிக்கிறேன்', 'மற்றும்');
strCol1.மறுஅளவிடு(12);
செலவு<< 'StrCol1 இன் புதிய அளவு:' <<strCol1.அளவு() << ' n';
வெளியீடு:
StrCol இன் புதிய அளவு: 6StrCol1: 12 இன் புதிய அளவு
செயல்பாடு வெற்றிடத்தைத் தருகிறது.
தெளிவான () தவிர
பின்வரும் குறியீட்டுப் பிரிவு விளக்குவது போல, சரத்திலிருந்து அனைத்து உறுப்புகளையும் நீக்குகிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol.தெளிவான();
செலவு<<strCol.அளவு() << ' n';
வெளியீடு 0. செயல்பாடு வெற்றிடத்தை அளிக்கிறது.
காலியாக () கான்ஸ்ட்
சரம் பொருளில் எழுத்து இல்லை என்றால் இது உண்மைக்கு 1 அல்லது சரம் பொருள் காலியாக இல்லை என்றால் பொய் என 0 க்குத் தரும். பின்வரும் குறியீடு இதை விளக்குகிறது:
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');செலவு<<strCol1.காலியாக() << ' n';
சரம் strCol2=லேசான கயிறு();
செலவு<<strCol2.காலியாக() << ' n';
வெளியீடு:
01
திருப்பி அனுப்பும் பொருட்கள் மற்றும் சரம் வகுப்பு
ஒரு இட்ரேட்டர் ஒரு சுட்டிக்காட்டி போன்றது ஆனால் சுட்டிக்காட்டியை விட அதிக செயல்பாட்டைக் கொண்டுள்ளது.
தொடக்கம் () தவிர
பின்வரும் குறியீட்டு பிரிவில் உள்ளதைப் போல, சரம் பொருளின் முதல் எழுத்தை (உறுப்பு) சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்iter=strCol.தொடங்க();
செலவு<< *iter<< ' n';
வெளியீடு 'I'. மறுசீரமைப்பைப் பெறும் அறிவிப்பு அறிவிக்கப்பட்டுள்ள விதத்தைக் கவனியுங்கள். ஒரு சுட்டிக்காட்டி மதிப்பிழக்கப்படுவதைப் போலவே, மதிப்பைப் பெறுவதற்கு, திரும்பப் பெறும் வெளிப்பாடாக மறுபெயரிடப்பட்டவர் குறிப்பிடப்படவில்லை.
தொடக்கம் () const noexcept;
சரம் பொருள் சேகரிப்பின் முதல் உறுப்பைச் சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது. பொருளின் கட்டுமானம் கான்ஸ்டால் முன்னதாக இருக்கும்போது, வெளிப்பாடு தொடங்கும் () தொடக்கத்திற்கு பதிலாக கான்ஸ்ட்ட் செய்யப்படுகிறது. இந்த நிபந்தனையின் கீழ், பொருளின் தொடர்புடைய உறுப்பை மாற்ற முடியாது. இது பின்வரும் குறியீட்டில் பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::const_iteratoriter=strCol.தொடங்க();
செலவு<< *iter<< ' n';
வெளியீடு 'I'. திருப்பி அனுப்பப்பட்ட இட்ரேட்டரைப் பெறுவதற்கு வெறும் இட்ரேட்டருக்குப் பதிலாக இம்முறை const_iterator பயன்படுத்தப்பட்டுள்ளது என்பதை நினைவில் கொள்க.
முடிவு () தவிர
சரம் பொருளின் கடைசி உறுப்புக்கு அப்பால் உடனடியாக சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது. பின்வரும் குறியீட்டுப் பகுதியைக் கவனியுங்கள்:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்iter=strCol.முடிவு();
செலவு<< *iter<< ' n';
கடைசி உறுப்புக்கு அப்பால் கான்கிரீட் உறுப்பு இல்லாததால், வெளியீடு பூஜ்யமானது.
முடிவு () const noexcept
சரம் பொருளின் கடைசி உறுப்புக்கு அப்பால் உடனடியாக சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது. சரம் பொருள் கட்டுமானம் கான்ஸ்டால் முன்னதாக இருக்கும்போது, வெளிப்பாடு (() கான்ஸ்ட்டுக்கு பதிலாக எண்ட் பின்வரும் குறியீட்டுப் பகுதியைக் கவனியுங்கள்:
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::const_iteratoriter=strCol.முடிவு();
செலவு<< *iter<< ' n';
வெளியீடு பூஜ்யமானது. திருப்பி அனுப்பப்பட்ட இட்ரேட்டரைப் பெறுவதற்கு வெறும் இட்ரேட்டருக்குப் பதிலாக இம்முறை const_iterator பயன்படுத்தப்பட்டுள்ளது என்பதை நினைவில் கொள்க.
தலைகீழ் திருப்புதல்
உண்மையான முடிவிலிருந்து முதல் உறுப்புக்கு சற்று முன்பு வரை திரும்பும் ஒரு இட்ரேட்டரை வைத்திருக்க முடியும்:
rbegin () தவிர
பின்வரும் குறியீட்டு பிரிவில் உள்ளதைப் போல, சரம் உடனடி பொருளின் கடைசி உறுப்பைச் சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::தலைகீழ்_அறிவிப்பான்iter=strCol.தொடங்கவும்();
செலவு<< *iter<< ' n';
வெளியீடு 'u' ஆகும். ரிவர்ஸ் இட்ரேட்டரைப் பெறும் அறிவிப்பு அறிவிக்கப்பட்டுள்ள விதத்தைக் கவனியுங்கள். ஒரு சுட்டிக்காட்டி மதிப்பிழக்கப்படுவதைப் போலவே, மதிப்பைப் பெறுவதற்கு, திரும்பப் பெறும் வெளிப்பாடாக மறுபெயரிடப்பட்டவர் குறிப்பிடப்படவில்லை.
rbegin () const noexcept;
சரம் பொருளின் கடைசி உறுப்பைச் சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது. பொருளின் கட்டுமானம் கான்ஸ்டால் முன்னதாக இருக்கும்போது, rbegin () க்கு பதிலாக rbegin () const என்ற வெளிப்பாடு செயல்படுத்தப்படுகிறது. இந்த நிபந்தனையின் கீழ், பொருளின் தொடர்புடைய உறுப்பை மாற்ற முடியாது. இந்த அம்சம் பின்வரும் குறியீட்டில் பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::const_reverse_iteratoriter=strCol.தொடங்கவும்();
செலவு<< *iter<< ' n';
வெளியீடு 'u' ஆகும். இந்த நேரத்தில் const_reverse_iterator பயன்படுத்தப்பட்டது என்பதை நினைவில் கொள்ளவும்.
வழங்க () தவிர
சரம் பொருளின் முதல் உறுப்புக்கு சற்று முன்னால் சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது. பின்வரும் குறியீட்டுப் பகுதியைக் கவனியுங்கள்:
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::தலைகீழ்_அறிவிப்பான்iter=strCol.செய்கிறது();
செலவு<< *iter<< ' n';
முதல் உறுப்புக்கு சற்று முன் கான்கிரீட் உறுப்பு இல்லாததால், வெளியீடு பூஜ்யமானது.
render () const noexcept
சரம் பொருளின் முதல் உறுப்புக்கு சற்று முன்னால் சுட்டிக்காட்டும் ஒரு ஐடரேட்டரை வழங்குகிறது. பொருள் கட்டுமானத்திற்கு முன்னால் கான்ஸ்டால், ரெண்ட் () க்கு பதிலாக ரெண்ட் () கான்ஸ்ட்ரேஷன் வெளிப்படும். பின்வரும் குறியீட்டுப் பகுதியைக் கவனியுங்கள்:
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::const_reverse_iteratoriter=strCol.செய்கிறது();
செலவு<< *iter<< ' n';
வெளியீடு பூஜ்யமானது. இந்த நேரத்தில் const_reverse_iterator பயன்படுத்தப்பட்டது என்பதை நினைவில் கொள்ளவும்.
சரம் மாற்றிகள்
ஸ்ட்ரிங் பொருளை மாற்றியமைக்கும் ஒரு மாற்றி, ஒரு இட்ரேட்டரை எடுக்கவோ அல்லது திரும்பவோ செய்யலாம்.
சேர்த்தல்
அடிப்படை_சரம்&ஆபரேட்டர்+ =(கான்ஸ்ட்அடிப்படை_சரம்&ப)வலது சரம் பொருளை இடது சரம் பொருளில் சேர்க்கிறது. உதாரணமாக:
சரம் strCol1=லேசான கயிறு('நான் நேசிக்கிறேன்');சரம் strCol2=லேசான கயிறு('நீ');
strCol1+ =strCol2;
செலவு<<strCol1<< ' n';
வெளியீடு ஐ லவ் யூ. StrCol1 += strCol2 strCol1 = strCol1 +strCol2 போன்றது என்பதை மறந்துவிடாதீர்கள்.
அடிப்படை_சரம் & ஆபரேட்டர்+= (const charT* s)
ஒரு சரம் பொருள் சேகரிப்பில் ஒரு சரத்தை நேரடியாகச் சேர்க்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('நான் நேசிக்கிறேன்');strCol+ = 'நீ';
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன்.
அடிப்படை_சரம் & ஆபரேட்டர்+= (charT c)
ஒரு பொருள் சரத்திற்கு ஒற்றை எழுத்தை சேர்க்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('நான் உன்னை விரும்புகிறேன்');strCol+ = 'u';
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன்.
அடிப்படை_சரம் & ஆபரேட்டர்+= (initializer_list)
ஒரு தொடக்கப் பட்டியலைச் சேர்க்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('நான் நேசிக்கிறேன்');strCol+ = {'','மற்றும்','அல்லது','u',' 0'};
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன். எழுத்துக்குறி தொடக்கப் பட்டியலின் முடிவில் n , 0 ஐ சேர்ப்பது எப்போதும் நல்லது.
அடிப்படை_சரம் & இணை
வாதம் சரம் பொருளை பிரதான சரத்து பொருளுக்குச் சேர்க்கிறது. உதாரணமாக:
சரம் strCol1=லேசான கயிறு('நான் நேசிக்கிறேன்');சரம் strCol2=லேசான கயிறு('நீ');
strCol1.இணைக்கவும்(strCol2);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன்.
அடிப்படை_சரம் & சேர்க்கை (const charT* s)
மெயின் ஸ்ட்ரிங்கில் ஒரு சரம் நேரடி வாதத்தை சேர்க்கிறது. உதாரணமாக
சரம் strCol=லேசான கயிறு('நான் நேசிக்கிறேன்');strCol=strCol.இணைக்கவும்('நீ');
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன்.
அடிப்படை_சரம் & சேர்த்தல் (initializer_list)
ஒரு வாதமாக இருக்கும் இனிஷினலைசர் பட்டியலை பிரதான சரத்தில் சேர்க்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('நான் நேசிக்கிறேன்');strCol=strCol.இணைக்கவும்({'','மற்றும்','அல்லது','u',' 0'});
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன். ஆரம்பநிலைப் பட்டியலின் முடிவில் nul, 0 எழுத்தை சேர்ப்பது எப்போதும் நல்லது.
அடிப்படை_சரம் & சேர்க்கை (size_type n, charT c)
அதே பாத்திரத்தின் n ஐ இணைக்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('தாவல்');strCol=strCol.இணைக்கவும்(2, 'அல்லது');
செலவு<<strCol<< ' n';
வெளியீடு: தடை.
அடிப்படை_சரம் & சேர்க்கை (const charT* s, size_type n)
ஒரு சரத்தின் முதல் n கூறுகளை பிரதான சரம் பொருளுக்குச் சேர்க்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('நான் நேசிக்கிறேன்');strCol=strCol.இணைக்கவும்('நீ அப்படி', 4);
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை நேசிக்கிறேன். எழுத்துக்களின் நீளத்தை விட n அதிகமாக இருந்தால், ஒரு நீளம்_பிறப்பு விதிவிலக்கு வீசப்படும்.
அடிப்படை_சரம் & இணை
குறியீட்டில் இருந்து n எழுத்துக்கள், முக்கிய சரத்திற்கு pos சேர்க்கிறது. உதாரணமாக:
சரம் strCol=லேசான கயிறு('நான் நேசிக்கிறேன்');strCol=strCol.இணைக்கவும்('நீ அப்படி', 2, 4);
செலவு<<strCol<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன். ஒரு விதிவிலக்கு இங்கே வீசப்படும், பின்னர் பார்க்கவும்.
ஒதுக்குதல்
அடிப்படை_சரம்&ஒதுக்க(கான்ஸ்ட்அடிப்படை_சரம்&ப)வாதம் சரம் பொருளை பிரதான சரத்திற்கு ஒதுக்குகிறது, அங்கு இருந்த எந்த உள்ளடக்கத்தையும் மாற்றுகிறது.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');சரம் strCol2=லேசான கயிறு('அவளுக்கு நான் வேண்டும்');
strCol1=strCol1.ஒதுக்க(strCol2);
செலவு<<strCol1<< ' n';
வெளியீடு: அவளுக்கு நான் தேவை.
அடிப்படை_சரம்&ஒதுக்க(கான்ஸ்ட்charT*கள்)முக்கிய சரத்திற்கு ஒரு சரம் நேரடி வாதத்தை ஒதுக்குகிறது, அங்குள்ள எந்த உள்ளடக்கத்தையும் மாற்றுகிறது.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol=strCol.ஒதுக்க('அவளுக்கு நான் வேண்டும்');
செலவு<<strCol<< ' n';
வெளியீடு: அவளுக்கு நான் தேவை.
அடிப்படை_சரம்&ஒதுக்க(initializer_list<charT>)முதன்மை சரத்திற்கு ஒரு தொடக்க பட்டியல் வாதத்தை ஒதுக்குகிறது,அங்கு இருந்த எந்த உள்ளடக்கத்தையும் மாற்றுகிறது.
[சிசி லாங்='சி'தப்பினார்='உண்மை'அகலம்='780']
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');
strCol=strCol.ஒதுக்க({'எஸ்','h','மற்றும்','','n','மற்றும்','மற்றும்','d','கள்','','ம்','மற்றும்',' 0'});
செலவு<<strCol<< ' n';
வெளியீடு: அவளுக்கு நான் தேவை. எழுத்துப் பட்டியலின் முடிவில் n = ஐ எப்போதும் சேர்ப்பது நல்லது.
அடிப்படை_சரம்&ஒதுக்க(கான்ஸ்ட்charT*கள்,size_type n)ஒரு சரம் நேரடி வாதத்தின் முதல் n எழுத்துக்களை பிரதான சரத்திற்கு ஒதுக்குகிறது, அங்கு இருந்த எந்த உள்ளடக்கத்தையும் மாற்றுகிறது.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol=strCol.ஒதுக்க('அவளுக்கு நான் வேண்டும்', 9);
செலவு<<strCol<< ' n';
வெளியீடு: அவளுக்கு தேவை.
அடிப்படை_சரம்&ஒதுக்க(size_type n,chart c)அதே எழுத்துகளின் n இன் வாதத்தை பிரதான சரத்திற்கு ஒதுக்குகிறது, அங்குள்ள எந்த உள்ளடக்கத்தையும் மாற்றுகிறது.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol=strCol.ஒதுக்க(4, 'மற்றும்');
செலவு<<strCol<< ' n';
வெளியீடு: eeee
அடிப்படை_சரம்&ஒதுக்க(கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos,size_type n=npos)
ஒரு சரம் பொருள் வாதத்தின் n எழுத்துக்களை, pos இலிருந்து தொடங்கி, பிரதான சரத்திற்கு, அங்குள்ள எந்த உள்ளடக்கத்தையும் மாற்றுகிறது.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol=strCol.ஒதுக்க('அவளுக்கு நான் வேண்டும்', 4, 5);
செலவு<<strCol<< ' n';
வெளியீடு: தேவைகள். ஒரு விதிவிலக்கு - பின்னர் பார்க்கவும்.
செருகும்
அடிப்படை_சரம்&செருக(size_type pos, கான்ஸ்ட்அடிப்படை_சரம்&ப)சரம் பொருள் வாதத்தை முக்கிய சரத்திற்கு, இன்டெக்ஸ், போஸில் செருகும்.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');சரம் strCol2=லேசான கயிறு('வெறுப்பு மற்றும்');
strCol1=strCol1.செருக(2,strCol2);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் உன்னை வெறுக்கிறேன், நேசிக்கிறேன். ஒரு விதிவிலக்கு - பின்னர் பார்க்கவும்.
அடிப்படை_சரம்&செருக(size_type pos1, கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos2,size_type n=npos)
ஸ்ட்ரிங் ஆப்ஜெக்ட் வாதத்தின் pos2 இலிருந்து, முக்கிய சரத்திற்கு, இன்டெக்ஸ், pos1 இல் n எழுத்துகளின் நீளத்தைச் செருகுகிறது.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');சரம் strCol2=லேசான கயிறு('வெறுப்பு, தேவை மற்றும் தேவை');
strCol1=strCol1.செருக(2,strCol2, 6, 9);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் உன்னை விரும்புகிறேன் மற்றும் விரும்புகிறேன்.
இட்ரேட்டர் செருகல் (const_iterator p, charT c)
வாதமாக இருக்கும் ஒரு குறிப்பிட்ட எழுத்தை மறுசீரமைப்பால் சுட்டிக்காட்டப்பட்ட நிலைக்குள் செருகுகிறது. புதிதாக செருகப்பட்ட கதாபாத்திரத்தின் நிலைக்கு ஒரு ஐடரேட்டரை வழங்குகிறது.
சரம் strCol=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்iter=strCol.தொடங்க();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்வலைப்பின்னல்=strCol.செருக(iter, 'd');
செலவு<< *வலைப்பின்னல்<< ' n';
செலவு<<strCol<< ' n';
வெளியீடு:
'D'
நான் உன்னை காதலித்தேன்
ஐடரேட்டர் செருகல் (const_iterator p, size_type n, charT c)
வாதத்தின் அதே தன்மையின் n ஐ செருகுநிரலால் சுட்டிக்காட்டப்பட்ட நிலைக்குச் செருகுகிறது. புதிதாக செருகப்பட்ட அதே எழுத்துக்களின் தொடக்க நிலைக்கு ஒரு ஐடரேட்டரை வழங்குகிறது.
சரம் strCol=லேசான கயிறு('நிலத்தில் உள்ள தாவல்.');அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்iter=strCol.தொடங்க();
++iter; ++iter; ++iter;
அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்வலைப்பின்னல்=strCol.செருக(iter, 2, 'அல்லது');
செலவு<< *வலைப்பின்னல்<< ' n';
செலவு<<strCol<< ' n';
வெளியீடு:
'அல்லது'
நிலத்தில் தடை.
அடிப்படை_சரம்&செருக(size_type pos, கான்ஸ்ட்charT*கள்)இன்டெக்ஸில் ஒரு வாதம் சரத்தை நேரடியாகச் செருகுகிறது, முக்கிய சரத்தில் pos.
சரம் strCol=லேசான கயிறு('நிலத்தில் உள்ள தாவல்.');strCol=strCol.செருக(3, 'ஓ');
செலவு<<strCol<< ' n';
வெளியீடு: நிலத்தில் தடை.
அடிப்படை_சரம்&செருக(size_type pos, கான்ஸ்ட்charT*கள்,size_type n)வாதம் சரத்தின் முதல் n எழுத்துக்களை, குறியீட்டில், முக்கிய சரத்தில் pos ஐச் சேர்க்கிறது.
சரம் strCol=லேசான கயிறு('நிலத்தில் உள்ள தாவல்.');strCol=strCol.செருக(3, 'ஓஓஓஓ', 2);
செலவு<<strCol<< ' n';
வெளியீடு: நிலத்தில் தடை.
மாற்றுதல்
அடிப்படை_சரம்&மாற்று(size_type pos1,அளவு_ வகை n1, கான்ஸ்ட்அடிப்படை_சரம்&ப))அட்டவணை, pos1 இலிருந்து பிரதான சரம் பொருளில் உள்ள n1 எழுத்துக்களை வாதம் சரம் பொருளுடன் மாற்றுகிறது.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');சரம் strCol2=லேசான கயிறு('உன்னை வெறுக்கிறேன்');
strCol1=strCol1.மாற்று(2, 4,strCol2);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் உன்னையும் உன்னையும் வெறுக்கிறேன். ஒரு விதிவிலக்கு - பின்னர் பார்க்கவும்.
அடிப்படை_சரம்&மாற்று(size_type pos1,அளவு_ வகை n1, கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos2,அளவு_ வகை n2=npos)
அட்டவணை, pos1 இலிருந்து முக்கிய சரம் பொருளில் உள்ள n1 எழுத்துக்களை இடமாற்றம் செய்கிறது.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');சரம் strCol2=லேசான கயிறு('நாங்கள் அவனையும் அவளையும் வெறுக்கிறோம்');
strCol1=strCol1.மாற்று(2, 4,strCol2, 3, 12);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் அவரையும் உங்களையும் வெறுக்கிறேன்.
அடிப்படை_சரம்&மாற்று(size_type pos1,அளவு_ வகை n1, கான்ஸ்ட்charT*கள்,அளவு_ வகை n2)
அட்டவணை, pos1 இலிருந்து முக்கிய சரம் பொருளில் உள்ள n1 எழுத்துக்களை நேரடி சர வாதத்தின் முதல் n2 எழுத்துகளுடன் மாற்றுகிறது.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol1=strCol1.மாற்று(2, 4, 'அவனையும் அவளையும் வெறு', 12);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் அவரையும் உங்களையும் வெறுக்கிறேன்.
அடிப்படை_சரம் & மாற்று (size_type pos, size_type n, const charT* s)
அட்டவணை, pos இலிருந்து முக்கிய சரம் பொருளில் உள்ள n எழுத்துக்களை நேரடி சரம் வாதத்துடன் மாற்றுகிறது.
சரம் strCol1=லேசான கயிறு('நான் உன்னை காதலிக்கிறேன்');strCol1=strCol1.மாற்று(2, 4, அவரை வெறுக்கவும் மற்றும்);
செலவு<<strCol1<< ' n';
வெளியீடு: நான் அவரையும் உங்களையும் வெறுக்கிறேன்.
அடிப்படை_சரம்&மாற்று(size_type pos1,அளவு_ வகை n1,அளவு_ வகை n2,chart c)அட்டவணை, pos1 இலிருந்து முக்கிய சரம் பொருளில் உள்ள n1 எழுத்துக்களை வாதத்தின் அதே தன்மையின் n2 உடன் மாற்றுகிறது.
சரம் strCol1=லேசான கயிறு('அங்கே ஒரு மோசமான மாத்திரை.');strCol1=strCol1.மாற்று(9, 3, 2, 'அல்லது');
செலவு<<strCol1<< ' n';
வெளியீடு: அங்கு ஒரு மோசமான தடை ..
ஐடரேட்டர் அழி (const_iterator p)
இட்ரேட்டரால் சுட்டிக்காட்டப்பட்ட நிலையில் ஒரு எழுத்தை நீக்குகிறது; பின்னர், இந்த கேரக்டர் (அல்லது முடிவு ()) க்கு அடுத்ததாக இருந்த பாத்திரத்தால் இப்போது ஆக்கிரமிக்கப்பட்ட இட்ரேட்டர் நிலையை அளிக்கிறது. பின்வரும் குறியீடு இதை விளக்குகிறது:
சரம் strCol=லேசான கயிறு('ஏ பி சி டி');அடிப்படை_சரம்<கரி> ::இட்ரேட்டர்iter=strCol.தொடங்க();
++iter; ++iter;
strCol.அழி(iter);
செலவு<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
வெளியீடு: a b d
அடிப்படை_சரம்&அழி(size_type pos= 0,size_type n=npos)குறியீட்டிலிருந்து n எழுத்துக்களை நீக்குகிறது, pos.
சரம் strCol=லேசான கயிறு('ஏ பி சி டி');strCol.அழி(1, 2);
செலவு<<strCol[0] << '' <<strCol[1] << ' n';
வெளியீடு: ஒரு டி
வெற்றிட புஷ்_பேக் (charT c)
சரத்தின் முடிவில் ஒற்றை எழுத்தை சேர்க்க:
சரம் strCol=லேசான கயிறு('ஏ பி சி டி');strCol.பின்னால் தள்ளு('5');
செலவு<<strCol<< ' n';
வெளியீடு: abcd5
வெற்றிட பாப்_பேக் ()
கடைசி எழுத்தை திரும்பப் பெறாமல் நீக்குகிறது. சரத்தின் அளவு 1 ஆல் குறைக்கப்படுகிறது.
சரம் strCol=லேசான கயிறு('ஏ பி சி டி இ');strCol.pop_back();
செலவு<<strCol<< ' n';
வெளியீடு: abcd
வெற்றிட இடமாற்றம் (அடிப்படை_சரம் & கள்)
இரண்டு சரம் பொருள்களின் இலக்கியங்களை மாற்றலாம்.
சரம் strCol1=லேசான கயிறு(<உதவி='பிந்தைய 69618 -__ DdeLink__781_3724385525'>க்கு>'ஏ பி சி டி இ');சரம் strCol2=லேசான கயிறு('1234567');
strCol1.இடமாற்றம்(strCol2);
செலவு<<strCol1<< ' n';
செலவு<<strCol2<< ' n';
வெளியீடு:
'1234567''ஏ பி சி டி இ'
சரம் செயல்பாடுகள்
const charT* c_str () const noexcept
சரத்தின் முதல் உறுப்புக்கு ஒரு சுட்டியை அளிக்கிறது. சுட்டியை அதிகரிக்க முடியும்.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('ஏ பி சி டி இ');கான்ஸ்ட் கரி*ப=strCol.c_str();
செலவு<< *ப<< ' n';
++ப;
செலவு<< *ப<< ' n';
வெளியீடு:
க்குb
தலைப்பில் உள்ள இரண்டாவது கான்ஸ்ட்டின் காரணமாக, நிரலில் எந்த எழுத்தையும் மாற்ற முடியாது. கட்டுமானம் கான்ஸ்ட்டால் முன்னெடுக்கப்பட்டது.
const charT* தரவு () const noexcept
சரத்தின் முதல் உறுப்புக்கு ஒரு சுட்டியை அளிக்கிறது. சுட்டியை அதிகரிக்க முடியும்.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('ஏ பி சி டி இ');கான்ஸ்ட் கரி*ப=strCol.தகவல்கள்();
செலவு<< *ப<< ' n';
++ப;
செலவு<< *ப<< ' n';
வெளியீடு:
க்குb
தலைப்பில் உள்ள இரண்டாவது கான்ஸ்ட்டின் காரணமாக, நிரலில் எந்த எழுத்தையும் மாற்ற முடியாது. கட்டுமானம் கான்ஸ்ட்டால் முன்னெடுக்கப்பட்டது.
அடிப்படை_வரி சப்ஸ்ட்ர் (size_type pos = 0, size_type n = npos) const
இன்டெக்ஸ், போஸிலிருந்து தொடங்கும் சப் ஸ்ட்ரிங்கிற்கு n எழுத்துகளின் சரம் பொருளை வழங்குகிறது.
கான்ஸ்ட்சரம் strCol=லேசான கயிறு('abcdefghij');கான்ஸ்ட்சரம் retStr=strCol.துணை(2, 4);
செலவு<<retStr<< ' n';
வெளியீடு: cdef
கண்டுபிடிக்க () உறுப்பினர் செயல்பாடுகள்
size_type கண்டுபிடிப்பு (const basic_string & str, size_type pos = 0) const noexcept
குறியீட்டிலிருந்து தொடங்கும் ஒரு துணை-சரம் பொருளைப் பார்க்கிறது, pos. கண்டுபிடிக்கப்பட்டால், பிரதான சரத்தின் துணை சரம் தொடக்கத்தை வழங்கும்.
சரம் strCol=லேசான கயிறு('நாங்கள் உலகம்!');சரம் strCol1=லேசான கயிறு('தி');
intஒன்றின் மீது=strCol.கண்டுபிடிக்க(strCol1, 2);
செலவு<<ஒன்றின் மீது<< ' n';
வெளியீடு:
அட்டவணை: 7கிடைக்கவில்லை -1, கொடுக்கிறது.
size_type கண்டுபிடிப்பு (const charT* s, size_type pos = 0) const
இன்டெக்ஸ், பிஓஎஸ்ஸிலிருந்து ஆரம்பத்தில் ஒரு சரம் சரமாகத் தெரிகிறது. கண்டுபிடிக்கப்பட்டால், பிரதான சரத்தின் துணை சரம் தொடக்கத்தை வழங்கும்.
சரம் strCol=லேசான கயிறு('நாங்கள் உலகம்!');intஒன்றின் மீது=strCol.கண்டுபிடிக்க('உள்ளன', 0);
செலவு<<ஒன்றின் மீது<< ' n';
Pos = 0 இயல்புநிலை என்பதால், வாதத்தில் 0 தவிர்க்கப்பட்டிருக்கலாம்.
வெளியீடு: 3
கிடைக்கவில்லை -1, கொடுக்கிறது.
size_type கண்டுபிடிப்பு (const charT* s, size_type pos, size_type n) const
இன்டெக்ஸ், பிஓஎஸ்ஸிலிருந்து ஆரம்பத்தில் ஒரு சரம் சரத்தின் முதல் n எழுத்துக்களைத் தேடுகிறது. கண்டுபிடிக்கப்பட்டால், பிரதான சரத்தின் துணை சரம் தொடக்கத்தை வழங்கும்.
சரம் strCol=லேசான கயிறு('மிகப்பெரிய பையன்');intஒன்றின் மீது=strCol.கண்டுபிடிக்க('பெரிய', 1, 3);
செலவு<<ஒன்றின் மீது<< ' n';
வெளியீடு: 4
கிடைக்கவில்லை -1, கொடுக்கிறது.
size_type கண்டுபிடிப்பு (charT c, size_type pos = 0) const
குறியீட்டில் இருந்து பாத்திரம், c தொடங்கி, pos. கண்டுபிடிக்கப்பட்டால், பிரதான சரத்தின் துணை சரம் தொடக்கத்தை வழங்கும். காணவில்லை என்றால், வருமானம் -1.
சரம் strCol=லேசான கயிறு('நாங்கள் உலகம்!');intஒன்றின் மீது=strCol.கண்டுபிடிக்க('உடன்');
செலவு<<ஒன்றின் மீது<< ' n';
வெளியீடு: -1
பின்வரும் தலைகீழ் கண்டுபிடிப்பு () உறுப்பினர் செயல்பாடுகள் உள்ளன:
size_typ rfind(கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos=npos) கான்ஸ்ட்தவிர;size_typ rfind(கான்ஸ்ட்charT*கள்,size_type pos=npos) கான்ஸ்ட்;
size_typ rfind(கான்ஸ்ட்charT*கள்,size_type pos,size_type n) கான்ஸ்ட்;
size_typ rfind(chart c,size_type pos=npos) கான்ஸ்ட்;
ஒப்பீட்டு உறுப்பினர் செயல்பாடுகள்
int compare (const அடிப்படை_string & str) const noexcept
வாதம் சரம் பொருளை முக்கிய சரம் பொருளுடன் ஒப்பிடுகிறது. வாதத்திற்கு முன் முக்கிய சரம் ஏற்பட்டால் (அகராதியில்) அது நேர்மறை எண்ணை அளிக்கும். பிரதான சரத்திற்குப் பிறகு அது ஏற்பட்டால், அது எதிர்மறை எண்ணை அளிக்கும். இரண்டு சரங்களும் ஒரே மாதிரியாக இருந்தால், அது பூஜ்ஜியத்தை அளிக்கிறது.
சரம் strCol1=லேசான கயிறு('கூட்டம்');சரம் strCol2=லேசான கயிறு('மக்கள்');
intஒன்றின் மீது=strCol1.ஒப்பிடுக(strCol2);
செலவு<<ஒன்றின் மீது<< ' n';
வெளியீடு: -13
int ஒப்பீடு (const charT* s) const
மேலே உள்ளதைப் போலவே, ஆனால் வாதம் ஒரு சரம் நேரடி.
சரம் strCol1=லேசான கயிறு('மக்கள்');intஒன்றின் மீது=strCol1.ஒப்பிடுக('மக்கள்');
செலவு<<ஒன்றின் மீது<< ' n';
வெளியீடு: 0
சரம் ஆபரேட்டர்கள்
இந்த ஆபரேட்டர்கள் சரம் பொருள்களுக்குப் பொருந்தும் மற்றும் சரம் இலக்கியங்களுக்கு அவசியமில்லை.
+
இரண்டு சரம் பொருள்களை இணைத்து, இணைப்பைத் தருகிறது.
சரம் strCol1=லேசான கயிறு('நடனம்');சரம் strCol2=லேசான கயிறு(' நிலவு');
சரம் strCol=strCol1+strCol2;
செலவு<<strCol<< ' n';
வெளியீடு: நிலவில் நடனம்.
==
சரம் பொருள்கள் ஒரே மாதிரியாக இருந்தால் உண்மைக்கு 1 ஐ வழங்குகிறது; பொய் என்றால் பூஜ்யம், அவை இல்லையென்றால்.
சரம் strCol1=லேசான கயிறு('நடனம்');சரம் strCol2=லேசான கயிறு(' நிலவில்');
பூல் பிஎல்=strCol1==strCol2;
செலவு<<bl<< ' n';
வெளியீடு: 0
! =
சரம் பொருள்கள் ஒரே மாதிரியாக இல்லாவிட்டால் 1 -ஐயும், இருந்தால் பூஜ்ஜியத்தையும் தரும்.
சரம் strCol1=லேசான கயிறு('நடனம்');சரம் strCol2=லேசான கயிறு(' நிலவில்');
பூல் பிஎல்=strCol1! =strCol2;
செலவு<<bl<< ' n';
வெளியீடு: 1
<
இடது ஓபராண்ட் அகராதியின் படி வலது ஓபராண்டை விட குறைவாக இருந்தால் அல்லது அது இல்லையென்றால் பூஜ்ஜியத்தை 1 என அளிக்கிறது.
சரம் strCol1=லேசான கயிறு('நடனம்');சரம் strCol2=லேசான கயிறு(' நிலவில்');
பூல் பிஎல்=strCol1<strCol2;
செலவு<<bl<< ' n';
வெளியீடு: 0
C ++ இல் உள்ள சாதாரண எழுத்துகளுக்கு, ஏறுவரிசையில், பெரிய எழுத்துக்களுக்கு முன் எண்கள் வரும், அவை சிறிய எழுத்துக்களுக்கு முன் வரும். விண்வெளி எழுத்து பூஜ்ஜியத்திற்கு முன் வருகிறது மற்றும் அவை அனைத்தும்.
சி ++ முக்கிய சரம் எழுத்து வகைகள்
கரி
சார் வகை அசல் சி ++ வகை மற்றும் பொதுவாக 8 பிட்களில் ஒரு பாத்திரத்தை சேமித்து வைக்கும்.
char16_t
இது 16 பிட்களில் ஒரு பாத்திரத்தை சேமிக்கிறது.
char32_t
இது 32 பிட்களில் ஒரு பாத்திரத்தை சேமிக்கிறது.
wchar_t
char16_t மற்றும் char32_t ஆகியவை பரந்த எழுத்துக்கள். wchar_t என்பது ஒரு பரந்த தன்மையாகும், இது தனியுரிமை மற்றும் செயல்படுத்தல்-வரையறுக்கப்பட்டுள்ளது.
இந்த வகைகள் பண்புகள் என்று அழைக்கப்படுகின்றன. இருப்பினும், சி ++ அவர்களை தொழில்நுட்ப ரீதியாக, பண்புகளின் சிறப்பு என குறிப்பிடுகிறது. இந்த கட்டுரை கரி வகையை மையமாகக் கொண்டுள்ளது. மற்ற வகைகளுக்கான அணுகுமுறை சற்று வித்தியாசமானது - பிறகு பார்க்கவும்.
பிற சரம் செயல்பாட்டு உறுப்பினர் செயல்பாடுகள்
பிற சரம் செயல்பாடுகளின் கையொப்பங்கள்:
அளவு_ வகை முதல்_ கண்டுபிடிப்பு(கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos= 0) கான்ஸ்ட்தவிர;அளவு_ வகை முதல்_ கண்டுபிடிப்பு(கான்ஸ்ட்charT*கள்,size_type pos,size_type n) கான்ஸ்ட்;
அளவு_ வகை முதல்_ கண்டுபிடிப்பு(கான்ஸ்ட்charT*கள்,size_type pos= 0) கான்ஸ்ட்;
அளவு_ வகை முதல்_ கண்டுபிடிப்பு(chart c,size_type pos= 0) கான்ஸ்ட்;
அளவு_ வகை கண்டுபிடிப்பு_கடந்த_(கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos=npos) கான்ஸ்ட்தவிர;
அளவு_ வகை கண்டுபிடிப்பு_கடந்த_(கான்ஸ்ட்charT*கள்,size_type pos,size_type n) கான்ஸ்ட்;
அளவு_ வகை கண்டுபிடிப்பு_கடந்த_(கான்ஸ்ட்charT*கள்,size_type pos=npos) கான்ஸ்ட்;
அளவு_ வகை கண்டுபிடிப்பு_கடந்த_(chart c,size_type pos=npos) கான்ஸ்ட்;
size_type கண்டுபிடி_ முதலில்_அல்ல(கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos= 0) கான்ஸ்ட்தவிர;
size_type கண்டுபிடி_ முதலில்_அல்ல(கான்ஸ்ட்charT*கள்,size_type pos,size_type n) கான்ஸ்ட்;
size_type கண்டுபிடி_ முதலில்_அல்ல(கான்ஸ்ட்charT*கள்,size_type pos= 0) கான்ஸ்ட்;
size_type கண்டுபிடி_ முதலில்_அல்ல(chart c,size_type pos= 0) கான்ஸ்ட்;
size_type கண்டுபிடிப்பு_கடந்த_இல்லாது(கான்ஸ்ட்அடிப்படை_சரம்&ப,size_type pos=npos) கான்ஸ்ட்தவிர;
size_type கண்டுபிடிப்பு_கடந்த_இல்லாது(கான்ஸ்ட்charT*கள்,size_type pos,size_type n) கான்ஸ்ட்;
size_type கண்டுபிடிப்பு_கடந்த_இல்லாது(கான்ஸ்ட்charT*கள்,size_type pos=npos) கான்ஸ்ட்;
size_type கண்டுபிடிப்பு_கடந்த_இல்லாது(chart c,size_type pos=npos) கான்ஸ்ட்;
முடிவுரை
சி ++ சரம் எழுத்துகள் மற்றும் சரம் பொருள்களைக் கொண்டுள்ளது. சரம் பொருளின் வரிசை வரிசைகளின் வரிசையைப் போலவே, வரிசையாக எழுத்துக்களின் தொகுப்பைக் கொண்டுள்ளது. சரம் சேகரிப்புக்கும் வரிசைக்கும் உள்ள வித்தியாசம் என்னவென்றால், சரம் சேகரிப்பு நீளமாக வளரலாம் அல்லது நீளத்தில் சுருங்கலாம். ஒரு சரம் பொருள் ஒரு சரம் வகுப்பிலிருந்து நிறுவப்பட்டது (கட்டப்பட்டது). சரம் பொருள் என்பது உறுப்பினர் செயல்பாடுகளைக் கொண்ட ஒரு தரவு அமைப்பு ஆகும். உறுப்பினர் செயல்பாடுகளை பொருள் கட்டுமானம், உறுப்பு அணுகல், சரம் திறன், இட்ரேட்டர் வாதங்கள் மற்றும் திரும்பும் வகைகள் மற்றும் சரம் மாற்றிகள் கொண்ட சரம் உறுப்பினர் செயல்பாடுகள் ஆகிய தலைப்புகளின் கீழ் வகைப்படுத்தலாம். சரம் சமத்துவம் மற்றும் தொடர்புடைய ஆபரேட்டர்களும் உள்ளன.