అక్షర శ్రేణి మరియు స్ట్రింగ్ మధ్య వ్యత్యాసం
విషయము
సి ++ రెండింటికి మద్దతు ఇస్తుంది, అక్షర శ్రేణి మరియు స్ట్రింగ్, C ++ రెండింటినీ ఉపయోగించడంలో గణనీయమైన ప్రయోజనాలను కలిగి ఉంది. కానీ, అక్షర శ్రేణిలో పనిచేయలేకపోవడం తరగతి స్ట్రింగ్ అభివృద్ధిని పెంచుతుంది. అక్షర శ్రేణి మరియు స్ట్రింగ్ రెండూ అక్షరాల క్రమాన్ని కలిగి ఉంటాయి. అక్షర శ్రేణి మరియు స్ట్రింగ్ మధ్య ప్రాథమిక వ్యత్యాసం ఏమిటంటే “అక్షర శ్రేణి” ను ప్రామాణిక ఆపరేటర్లతో ఆపరేట్ చేయలేము, అయితే “స్ట్రింగ్” వస్తువులను ప్రామాణిక ఆపరేటర్లతో ఆపరేట్ చేయవచ్చు. అక్షర శ్రేణి మరియు స్ట్రింగ్ మధ్య ఇతర తేడాలను అధ్యయనం చేద్దాం.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- ముగింపు
పోలిక చార్ట్
| పోలిక కోసం ఆధారం | అక్షర శ్రేణి | స్ట్రింగ్ |
|---|---|---|
| ప్రాథమిక | అక్షర శ్రేణి అనేది అక్షర డేటా రకం యొక్క వేరియబుల్స్ సేకరణ. | స్ట్రింగ్ క్లాస్ మరియు స్ట్రింగ్ యొక్క వేరియబుల్స్ క్లాస్ "స్ట్రింగ్" యొక్క వస్తువు. |
| సింటాక్స్ | చార్ అర్రే_పేరు; | స్ట్రింగ్ స్ట్రింగ్_పేరు; |
| ఇండెక్సింగ్ | అక్షర శ్రేణిలోని ఒక వ్యక్తిగత అక్షరాన్ని శ్రేణిలోని దాని సూచిక ద్వారా యాక్సెస్ చేయవచ్చు. | స్ట్రింగ్లో నిర్దిష్ట అక్షరాన్ని "string_name.charAt (index)" ఫంక్షన్ ద్వారా యాక్సెస్ చేయవచ్చు. |
| సమాచార తరహా | అక్షర శ్రేణి డేటాటైప్‌ను నిర్వచించదు. | స్ట్రింగ్ C ++ లో డేటాటైప్‌ను నిర్వచిస్తుంది. |
| ఆపరేటర్స్ | C ++ లోని ఆపరేటర్లను అక్షర శ్రేణిలో వర్తించలేరు. | మీరు స్ట్రింగ్లో ప్రామాణిక C ++ ఆపరేటర్‌ను వర్తించవచ్చు. |
| సరిహద్దు | శ్రేణి సరిహద్దులు సులభంగా అధిగమించబడతాయి. | సరిహద్దులు అధిగమించవు. |
| యాక్సెస్ | వేగంగా ప్రాప్యత. | నెమ్మదిగా యాక్సెస్. |
అక్షర శ్రేణి యొక్క నిర్వచనం
అక్షర శ్రేణి “చార్” డేటాటైప్ యొక్క వేరియబుల్స్ యొక్క సేకరణ; ఇది ఒక డైమెన్షనల్ అర్రే లేదా రెండు డైమెన్షనల్ అర్రే కావచ్చు. దీనిని "శూన్య టెర్మినేటెడ్ స్ట్రింగ్" అని కూడా పిలుస్తారు. అక్షర శ్రేణి అనేది వరుస మెమరీ చిరునామాలలో నిల్వ చేయబడిన అక్షరాల క్రమం. అక్షర శ్రేణిలో, ఒక నిర్దిష్ట అక్షరాన్ని దాని సూచిక ద్వారా యాక్సెస్ చేయవచ్చు. “శూన్య అక్షరం” అక్షర శ్రేణిని ముగించింది ”.
అక్షర శ్రేణికి ఉదాహరణ తీసుకుందాం: -
చార్ పేరు = {A, j, a, y, 0}; లేదా చార్ పేరు = "అజయ్";
ఇక్కడ, “చార్” అనేది అక్షర డేటా రకం, “పేరు” అనేది అక్షర శ్రేణి యొక్క వేరియబుల్ పేరు. అక్షర శ్రేణిని ప్రారంభించడానికి నేను రెండు మార్గాలు చూపించాను. మొదటి పద్ధతిలో, శూన్యము స్పష్టంగా ప్రస్తావించబడింది మరియు రెండవ పద్ధతిలో, కంపైలర్ స్వయంచాలకంగా శూన్యతను చొప్పిస్తుంది.
స్ట్రింగ్ ముగింపు ఎల్లప్పుడూ శూన్య అక్షరం; ఇది అక్షర శ్రేణి యొక్క ముగింపు పాత్ర. అక్షర శ్రేణి అంతర్నిర్మిత డేటా రకం కాదు; మేము దానిని ప్రకటించడం ద్వారా అక్షర శ్రేణిని సృష్టిస్తాము. మీరు అక్షర శ్రేణిలో ప్రామాణిక ఆపరేటర్లను వర్తించలేరు. అక్షర శ్రేణిలో పనిచేయడానికి, (strlen (), strlwr (), strupr (), strcat ()) వంటి కొన్ని అంతర్నిర్మిత ఫంక్షన్ ఉన్నాయి. ప్రామాణిక ఆపరేటర్లను అక్షర శ్రేణికి అన్వయించలేము కాబట్టి, వారు ఏ వ్యక్తీకరణలోనూ పాల్గొనలేరు.
అక్షర శ్రేణికి అక్షర పాయింటర్‌ను కూడా సృష్టించవచ్చు.
దీన్ని ఉదాహరణతో అర్థం చేసుకుందాం.
చార్ s1 = "హలో"; చార్ s2 = "సర్"; s1 = s1 + s2; // లోపం ఆపరేటర్లను వర్తించదు s2 = s1; // లోపం అక్షర పాయింటర్ చార్ * s = "ఉదయం"; char * p; p = s; // కార్యకలాపాల వలన
పై ఉదాహరణలో, మేము రెండు అక్షరాల శ్రేణి s1, s2 మరియు రెండు అక్షరాల పాయింటర్లను s మరియు p గా ప్రకటించాము. అక్షర శ్రేణి s1 మరియు s2 ప్రారంభించబడ్డాయి, అక్షర శ్రేణిలో అదనంగా ఆపరేటర్ (+) లేదా అసైన్‌మెంట్ ఆపరేటర్ పనిచేయవు. కానీ అక్షర పాయింటర్‌ను మరొక అక్షర పాయింటర్‌కు కేటాయించవచ్చు.
అక్షర శ్రేణి ప్రారంభించిన తర్వాత దాన్ని మరో అక్షర సమితికి తిరిగి ప్రారంభించలేమని గుర్తుంచుకోండి. C ++ లోని స్ట్రింగ్‌తో పోలిస్తే అక్షర శ్రేణి లేదా శూన్యంగా ముగిసిన స్ట్రింగ్‌కు ప్రాప్యత వేగంగా ఉంటుంది.
స్ట్రింగ్ యొక్క నిర్వచనం
స్ట్రింగ్ అనేది C ++ యొక్క అంతర్నిర్మిత డేటా రకం కాదు. ఇది “స్ట్రింగ్” రకం క్లాస్ ఆబ్జెక్ట్. C ++ లో ఒక తరగతిని సృష్టించడం అనేది “రకాన్ని” సృష్టించినట్లే. తరగతి “స్ట్రింగ్” C ++ లైబ్రరీలో ఒక భాగం. ఇది మొత్తం పాత్ర లేదా అక్షర శ్రేణి యొక్క సమితిని కలిగి ఉంటుంది. ప్రామాణిక స్ట్రింగ్ క్లాస్ అభివృద్ధి వెనుక మూడు కారణాలు ఉన్నాయి.
- ప్రధమ “స్థిరత్వం”, అక్షర శ్రేణులు వాటి స్వంత డేటా రకాలు కావు.
- రెండవ “సౌలభ్యం”, మీరు అక్షర శ్రేణిలో ప్రామాణిక ఆపరేటర్లను ఉపయోగించలేరు.
- మూడో “భద్రత”, శ్రేణి సరిహద్దులు సులభంగా అధిగమించబడతాయి.
ఒక ఉదాహరణతో తీగలను అర్థం చేసుకుందాం.
స్ట్రింగ్ s1; s1 = "హలో"; స్ట్రింగ్ s2 ("గుడ్ మార్నింగ్"); స్ట్రింగ్ s3 = "హెన్నరీ"; స్ట్రింగ్ s4;
పై ప్రకటనలో, నాలుగు స్ట్రింగ్ వేరియబుల్ లేదా వస్తువులు (s1, s2, s3, s4) ప్రకటించబడ్డాయి. పై ప్రకటనలో, నేను స్ట్రింగ్ ప్రారంభించడానికి మూడు మార్గాలు చూపించాను. స్ట్రింగ్ s1 డిక్లేర్ చేయబడింది మరియు తరువాత విడిగా ప్రారంభించబడుతుంది. స్ట్రింగ్ s2 క్లాస్ “స్ట్రింగ్” యొక్క కన్స్ట్రక్టర్ చేత ప్రారంభించబడింది. స్ట్రింగ్ s3 సాధారణ డేటా రకం వలె దాని ప్రకటన సమయంలో ప్రారంభించబడుతుంది. మేము ప్రామాణిక ఆపరేటర్‌ను స్ట్రింగ్ వేరియబుల్స్‌కు అన్వయించవచ్చు.
s4 = s1; // ఒక స్ట్రింగ్ వస్తువును మరొకదానికి కేటాయించడం s4 = s1 + s2; // రెండు స్ట్రింగ్లను జోడించి, ఫలితాన్ని మూడవ స్ట్రింగ్లో నిల్వ చేస్తే (s3> s2) // రెండు తీగలను తీగలను s5 (s1) తో పోల్చడం; ఇప్పటికే ఉన్న స్ట్రింగ్ ఆబ్జెక్ట్‌ను ఉపయోగించి క్రొత్త స్ట్రింగ్ ఆబ్జెక్ట్‌ని సృష్టించడం
పై కోడ్‌లో, వివిధ ఆపరేటర్లు స్ట్రింగ్లో వర్తించబడతాయి మరియు వివిధ ఆపరేషన్లు నిర్వహిస్తారు. మొదటి స్టేట్మెంట్ ఒక స్ట్రింగ్ ఆబ్జెక్ట్‌ను మరొక స్ట్రింగ్ ఆబ్జెక్ట్‌కు కాపీ చేస్తుంది. రెండవ స్టేట్మెంట్లో, రెండు స్ట్రింగ్ ఒకదానితో ఒకటి మరియు మూడవ స్ట్రింగ్లో నిల్వ చేయబడతాయి. మూడవ ప్రకటనలో, రెండు స్ట్రింగ్ పోల్చబడుతుంది. నాల్గవ స్టేట్మెంట్లో, ఇప్పటికే ఉన్న స్ట్రింగ్ ఆబ్జెక్ట్ ఉపయోగించి కొత్త స్ట్రింగ్ ఆబ్జెక్ట్ సృష్టించబడుతుంది.
అక్షర శ్రేణి లేదా శూన్యంగా ముగిసిన స్ట్రింగ్‌తో పోలిస్తే స్ట్రింగ్‌కు ప్రాప్యత నెమ్మదిగా ఉంటుంది.
అక్షర శ్రేణి మరియు స్ట్రింగ్ మధ్య కీలక తేడాలు
- అక్షర శ్రేణి అనేది అక్షర డేటాటైప్ యొక్క వేరియబుల్స్ యొక్క సేకరణ. స్ట్రింగ్ అనేది తీగలను ప్రకటించడానికి తక్షణం ఇవ్వబడిన తరగతి.
- సూచిక విలువను ఉపయోగించి మీరు అక్షర శ్రేణి నుండి అక్షరాన్ని యాక్సెస్ చేయవచ్చు. మరోవైపు, మీరు స్ట్రింగ్లో ఒక నిర్దిష్ట అక్షరాన్ని యాక్సెస్ చేయాలనుకుంటే, మీరు దాన్ని ఫంక్షన్ స్ట్రింగ్_నామ్.చార్అట్ (ఇండెక్స్) ద్వారా యాక్సెస్ చేయవచ్చు.
- శ్రేణి డేటాటైప్ కానందున అదేవిధంగా అక్షరం కూడా డేటాటైప్ కాదు. మరోవైపు, స్ట్రింగ్ ఒక క్లాస్ రకంగా రిఫరెన్స్ రకంగా ఉన్నందున, స్ట్రింగ్ ఒక డేటా రకం అని చెప్పవచ్చు.
- మీరు అక్షర శ్రేణిలో ఏ ఆపరేటర్‌ను వర్తించలేరు, అయితే మీరు స్ట్రింగ్లో ఆపరేటర్లను దరఖాస్తు చేసుకోవచ్చు.
- శ్రేణి అక్షర శ్రేణి కావడం వలన స్థిర పొడవు ఉంటుంది మరియు దాని సరిహద్దులను సులభంగా అధిగమించవచ్చు. స్ట్రింగ్‌కు సరిహద్దులు లేవు.
- అర్రే ఎలిమెంట్స్ ఒక పరస్పర మెమరీ ప్రదేశంలో నిల్వ చేయబడతాయి, అందువల్ల స్ట్రింగ్ వేరియబుల్ కంటే వేగంగా యాక్సెస్ చేయవచ్చు.
ముగింపు:
అక్షర శ్రేణిలో పనిచేయలేకపోవడం ప్రామాణిక స్ట్రింగ్ క్లాస్ అభివృద్ధిని పెంచింది.
