Arrays and Strings (Lecture 05)-3ZgDx-0oGQQ

 C ++  ప్రోగ్రామింగ్ లో మాడ్యూల్ 3 కు స్వాగతం.
 ఈ మాడ్యూల్ లో శ్రేణుల మరియు స్ట్రింగ్స్ గురించి చర్చిస్తాము.
 సి ప్రోగ్రామ్ మరియు సి ++ ప్రోగ్రామ్ మధ్య ప్రాథమిక తేడాలు ఏమిటో మాడ్యూల్ 2 లో చూశాము.
 మేము అదే గమనికను కొనసాగిస్తాము.
 ఈ మాడ్యూల్‌లో, శ్రేణుల వాడకాన్ని అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము, ముఖ్యంగా సి మరియు సి ++ లలో.
 సి ++ లో మేము వెక్టర్ అని పిలువబడే ఒక ప్రాథమిక భావనను ప్రవేశపెడతాము, ఇది శ్రేణుల వలె ఉంటుంది, కానీ చాలా శక్తివంతమైనది మరియు సి లో స్ట్రింగ్ ఎలా ఉపయోగించాలో చూడటానికి ప్రయత్నిస్తాము మరియు దీనికి విరుద్ధంగా సి ++ లో స్ట్రింగ్ రకం ఎలా పనిచేస్తుందో చూడటానికి ప్రయత్నిస్తాము.
 కాబట్టి, ఇవి మనం కవర్ చేసే అంశాలు.
 ప్రారంభించడానికి, మేము రెండు ప్రోగ్రామ్‌లను ఒకేసారి చూపించాము, రెండూ.
 IO హెడర్‌లో తేడా తప్ప అవి సరిగ్గా ఒకే విధంగా ఉంటాయి.
 కాబట్టి, C వలె శ్రేణి యొక్క ప్రాథమిక ఉపయోగం C ++ లో సరిగ్గా అదే సంజ్ఞామానం మరియు అదే అర్థంతో ఉపయోగించవచ్చు.
 కాబట్టి, మొదటి సందేశం ఆరెస్ (శ్రేణులు) ను మీరు C ++ లో ఉపయోగించినట్లే C ++ లో ఉపయోగించవచ్చు.
 నాకు తెలుసు
 అందువల్ల, మేము ఇక్కడ వేర్వేరు శ్రేణి మూలకాల కోసం కొన్ని విలువలను పేర్కొంటున్నాము మరియు వాటిని ముద్రించాము, printf ను ఉపయోగించడం లేదా కౌట్ ఉపయోగించడం మాత్రమే తేడా.
 ఇప్పుడు, సి లోని ప్రధాన సమస్యలలో ఒకటి, మీరందరూ ఎదుర్కొన్న శ్రేణులను (శ్రేణులను) ఉపయోగించడం పరంగా, నేను సి లో శ్రేణి (శ్రేణి) ను ఉపయోగించాలనుకున్నప్పుడు, నేను తెలుసుకోవాలి; నేను శ్రేణి యొక్క పరిమాణాన్ని పేర్కొనాలి, అనగా ప్రోగ్రామ్ లేదా ప్రోగ్రామ్ రాసే సమయంలో, శ్రేణిలో ఇప్పటికే ఉన్న గరిష్ట సంఖ్యల సంఖ్య. సంకలనం సమయంలో నిర్దిష్టంగా ఉండండి.
 అందువల్ల, నాకు పరిమాణం తెలియకపోతే, నేను అమలు చేసే ఏ సందర్భంలోనైనా ప్రోగ్రామ్‌లో నడుస్తున్న దానికంటే ఎక్కువగా ఉండే పరిమాణాన్ని నేను అందించాలి.
 ఈ పరిస్థితిని నిర్వహించడానికి ఖచ్చితంగా రెండు మార్గాలు ఉన్నాయి.
 ఒకటి, నేను నిర్వచించాను, పెద్ద శ్రేణిని ప్రకటించాను మరియు అది చేయవచ్చు; ఇది హార్డ్ కోడెడ్ కావచ్చు, ప్రోగ్రామ్‌లో పరిమాణం హార్డ్ కోడ్ చేయవచ్చు లేదా మానిఫెస్ట్ స్థిరాంకం మరియు ఇతర కేసును ఉపయోగించి ఆకారాన్ని కొంతవరకు మృదువుగా కోడ్ చేయవచ్చు. సి ప్రోగ్రామింగ్‌లో మీరు ఇంతకు ముందు చూసిన, మీరు మాలోక్‌ను ఉపయోగిస్తారు డైనమిక్‌గా స్థలాన్ని కేటాయించండి మరియు రన్ టైమ్‌లో శ్రేణిని కేటాయించండి, ఆపై మీరు దాన్ని ఉపయోగిస్తారు మరియు మీరు malloc ఉపయోగిస్తే దాన్ని ఉపయోగిస్తున్నప్పుడు, మీరు ఆ శ్రేణిని ఉపయోగించినప్పుడు దాన్ని ఖాళీ చేయడాన్ని కూడా గుర్తుంచుకోవాలి.
 కాబట్టి, మనం సి నుండి సి ++ కి ఎలా వలసపోతామో చూద్దాం.
 కాబట్టి, ఇది ఎడమ వైపున సి ఉదాహరణను మాత్రమే చూపుతోంది.
 మేము హార్డ్ కాలమ్ యొక్క పరిమాణాన్ని కుడి కాలమ్‌కు కోడ్ చేస్తాము, ఇది మేము అదే పని చేస్తున్నాము, ఇప్పుడు మీకు మానిఫెస్ట్ స్థిరమైన MAX ఉంది, దీనికి 100 విలువ ఇవ్వబడింది మరియు మేము ఆ MAX ఉపయోగిస్తున్నాము.
 మానిఫెస్ట్ స్థిరాంకాలను ఉపయోగించడం యొక్క ప్రయోజనం 10 వేర్వేరు శ్రేణుల వరకు ఉంటుంది, పరిమాణం 100 వరకు పేర్కొనబడుతుంది.
 ఇప్పుడు, నేను వారందరికీ హార్డ్ కోడ్ ఇస్తే మరియు కొంత సమయం తరువాత నేను ఆ పరిమాణాలన్నింటినీ 100 నుండి 1000 కి మార్చవలసి వస్తే, 10 ప్రదేశాలలో నేను వెళ్లి వాటిని సవరించాల్సి ఉంటుంది మరియు నేను అవన్నీ చేయాలనుకుంటున్నాను , కానీ నేను హాష్‌ను నిర్వచించినట్లయితే లేదా మానిఫెస్ట్ స్థిరాంకాన్ని ఉపయోగిస్తే, నేను ఒక ప్రదేశానికి మాత్రమే మార్పులు చేయగలను, నిర్వచనాలను MAX 100 నుండి 1000 కి మార్చగలను మరియు అవన్నీ మారుతాయి.
 అందువల్ల, సి మెరుగైన ప్రోగ్రామింగ్ ప్రాక్టీస్‌ను కలిగి ఉంది, దీనిలో మానిఫెస్ట్ స్థిరంగా ఉపయోగిస్తుంది మరియు హార్డ్ కోడ్ విలువను కాదు, మీకు ఇది ఇప్పటికే తెలుసు.
 ఇప్పుడు, మీరు కుడి కాలమ్‌లో సి మరియు సి ++ ల మధ్య ఒకే స్థానాన్ని చూపిస్తారు, ఇప్పుడు మీకు సి ++ ప్రోగ్రామ్ ఉంది.
 ఖచ్చితంగా, హాష్‌ను శ్రేణి పరిమాణం, MAX శ్రేణి పరిమాణం MAX అని 100 గా నిర్వచించవచ్చు, కాని మనం ఇక్కడ చూపించేది ప్రధాన శీర్షిక తర్వాత ఉన్న పంక్తిపై కేంద్రీకృతమై ఉంది.
 మేము వెక్టర్‌ను కార్నర్ బ్రాకెట్ Int (int) లో వ్రాస్తున్నాము, ఆపై శ్రేణి పేరు మరియు బ్రాకెట్లలో, మేము మాక్స్ పరిమాణాన్ని చూపుతాము.
 వెక్టర్ అనేది సి ++ కు కొత్త పరిచయం.
 ఇది అవ్యక్త రకం కాదు; దయచేసి దీన్ని అంతర్నిర్మిత రకంగా పరిగణించవద్దు.
 ఇది సి ++ ప్రామాణిక లైబ్రరీ అందించిన విషయం.
 కాబట్టి, మీరు మీ దృష్టిని # జాబితాలో అగ్రస్థానానికి తరలిస్తే, మీరు # ను కనుగొంటారు, # జ్ఞానం ఉంది.
 కాబట్టి, ప్రామాణిక లైబ్రరీ హెడర్ ఒక వెక్టర్, ఇది వెక్టర్ రకానికి అవసరమైన అన్ని డిక్లరేషన్ నిర్వచనాలను కలిగి ఉంటుంది మరియు మీరు దీన్ని ఈ విధంగా ఉపయోగించవచ్చు; దీని అర్థం అన్ని సందర్భాల్లో వెక్టర్‌కు వెక్టర్ ఇష్టపడేది.
 కాబట్టి, మీరు 'ఫర్' లూప్‌లోనే దృష్టి పెట్టండి, శ్రేణి మూలకాలు ఎలా ప్రాప్యత చేయబడుతున్నాయో మీరు చూస్తారు.
 ఎడమ వైపున, ఇది బాగా తెలిసిన అర్రే Int arr [MAX].
 మేము దానిని కుడి వైపున arr [i] గా వ్రాస్తాము, ఇది శ్రేణి మూలకాలను యాక్సెస్ చేయడానికి అదే ఇండెక్సింగ్ సంజ్ఞామానాన్ని ఉపయోగించే వెక్టర్.
 కాబట్టి, యాక్సెస్ సంజ్ఞామానం పరంగా వెక్టర్ యాక్సెస్ ఒకటే మరియు ఇది సాంప్రదాయ శ్రేణితో చదవడం లేదా వ్రాయడం ఉపయోగించడం యొక్క ఫలితం, కానీ దాని పరిమాణం కంపైల్ సమయంలో తప్పనిసరిగా నిర్ణయించబడదు.
 ఇప్పుడు, ఈ ఉదాహరణలో స్థిరమైన ప్రారంభ పరిమాణం MAX తో వెక్టర్ ఎలా ఉపయోగించాలో చూపించాము.
 కాబట్టి, మేము వెక్టర్ అని చెప్పినప్పుడు మరియు కార్నర్ బ్రాకెట్ Int (int) లోపల, మూలలో బ్రాకెట్‌లో, శ్రేణితో తయారైన మూలకం యొక్క రకాన్ని మేము అందిస్తున్నాము, దీనిని మేము C. అని పిలుస్తాము. ఇది మూలలో బ్రాకెట్లలోని వెక్టర్‌గా మరియు చదరపు బ్రాకెట్లలోని గరిష్ట పరిమాణంగా మేము ఇక్కడ అందించేది, మేము దానిని పారామితిగా అర్ర్ పాస్ తర్వాత పేరు పెడతాము.
 కాబట్టి, ఇది కేవలం గుర్తించదగిన వ్యత్యాసం, ఇప్పుడే దీనిని వ్రాయడం, శ్రేణులను ప్రకటించడం యొక్క ప్రత్యేక సంజ్ఞామానం వలె అంగీకరించండి మరియు మీరు మిగిలిన ప్రోగ్రామ్‌ను మరచిపోగలరని మీరు పూర్తి చేసిన తర్వాత, మీరు ప్రత్యేకంగా మీరు వెక్టర్‌ను ఉపయోగించవచ్చు వాటిని శ్రేణులుగా ఉపయోగించడం కొనసాగించవచ్చు.
 ఇప్పుడు దానితో, మీరు ఎక్కడ ప్రయోజనం పొందుతారో మీకు చూపిస్తాను.
 ఇప్పుడు, శ్రేణి ఎంత పెద్దదిగా ఉంటుందో మీకు తెలియని ఏకపక్ష-పరిమాణ శ్రేణులను ఉపయోగించే మరొక విధానంపై మేము దృష్టి కేంద్రీకరించాము, ప్రోగ్రామ్ (ప్రోగ్రామ్) వినియోగదారు అమలు చేసినప్పుడు మాత్రమే మీకు తెలుస్తుంది.
 కాబట్టి, వినియోగదారు బహుశా శ్రేణి యొక్క పరిమాణాన్ని, వినియోగదారు కోరుకునే మూలకాల సంఖ్యను అందిస్తారు.
 కాబట్టి, సి ప్రోగ్రామ్‌లో, మొదట మనం వినియోగదారుని అడుగుతున్న ఎడమ వైపు చూడండి; ఎన్ని అంశాలు ఉన్నాయి, మరియు వినియోగదారు గణన విలువను అందిస్తుంది మరియు మీరు దీన్ని సి లో చేయవలసి వస్తే, అది చూపిన విధంగా మాలోక్ ఉపయోగించి శ్రేణి (శ్రేణి) ను డైనమిక్‌గా కేటాయించాలి మరియు అదే ముందుకు సాగండి.
 వాస్తవానికి మీరు మాలోక్‌లో చాలా క్లిష్టమైన రూపాన్ని వ్రాయవలసి ఉంటుంది, ఎందుకంటే మీకు ఎంత మెమరీ అవసరమో మీరు నిజంగా చెప్పాల్సిన అవసరం ఉంది, మాలోక్ (మాలోక్) మీకు శూన్యమైన స్టార్ పాయింటర్ (పాయింటర్) ను తిరిగి ఇస్తుంది. ) నక్షత్రం.
 సి ప్రోగ్రామింగ్ యొక్క అన్ని సూక్ష్మ నైపుణ్యాలు ఉన్నాయి; ఇప్పుడు అదే మార్గాన్ని మీ దృష్టిని కుడి వైపుకు మార్చండి.
 ఇప్పుడు, మేము వేరియబుల్ ను డిక్లేర్ చేస్తున్నాము, ఎందుకంటే వేరియబుల్ యొక్క వెక్టర్ అర్ర్ మరియు మేము ఇంతకు ముందు చూపించిన వాటికి భిన్నంగా, దయచేసి గమనించండి, మేము ఏ MAX పరిమాణాన్ని దాటము.
 కాబట్టి, మేము MAX పరిమాణాన్ని దాటకపోతే, మనకు డిఫాల్ట్ పరిమాణం యొక్క వెక్టర్ లభిస్తుంది, C ++ ప్రామాణిక లైబ్రరీలో కొన్ని డిఫాల్ట్ పరిమాణాలు పరిష్కరించబడవు, కానీ కొన్ని డిఫాల్ట్ సైజు శ్రేణి ఉంటుంది, కానీ మేము అనుసరిస్తున్న పంక్తి సంజ్ఞామానం మీకు తెలియనిదాన్ని రాయండి.
 మేము arr.resize () ను వ్రాస్తున్నాము, దీనిని వెక్టర్ రకం యొక్క సభ్యుల ఫంక్షన్ ఆకారంగా పిలుస్తాము.
 ఇది ఏమిటంటే, ఈ పున ize పరిమాణం ఫంక్షన్‌లో, మనం వేరియబుల్ కౌంట్ గుండా వెళుతున్నప్పుడు ఒక విలువను దాటితే, వెక్టర్ మూలకాల సంఖ్య సంఖ్యను పున ize పరిమాణం చేస్తుంది.
 కాబట్టి, వెక్టర్ సృష్టించబడిన డిఫాల్ట్ పరిమాణం 10 అని అనుకుందాం, మరియు ఇప్పుడు రన్ టైమ్‌లో యూజర్‌కు ఇన్పుట్ కోసం 100 లెక్కింపు ఇవ్వబడుతుంది, వచ్చినప్పుడు. .Rize () పూర్తయితే విలువ 100 గా దాటిపోతుంది మరియు వెక్టర్ అసలు పది మూలకాల నుండి వంద మూలకాలకు మారుతుంది.
 కాబట్టి, ఆకారం వెక్టర్ సంఖ్యకు లేదా ఆ మూలకం యొక్క వెక్టర్ ఆస్తిగా చాలా సులభంగా ఉపయోగించబడుతుంది.
 కాబట్టి, దీనితో మీరు ఈ మల్లాక్‌ను ఉపయోగించడం నుండి బయటపడతారు మరియు సంక్లిష్ట అవగాహన మరియు ఆ స్థలాన్ని ఖాళీ చేయడానికి దాన్ని గుర్తుంచుకోండి.
 మేము వెక్టర్‌ను ఉపయోగించుకోవచ్చు మరియు సి ++ ప్రోగ్రామ్ (ప్రోగ్రామ్) లో శ్రేణులను ఉపయోగించే వాటిని ఉపయోగించుకోవచ్చు ఎందుకంటే వెక్టర్ కంటైనర్‌లోని అదే యంత్రాంగం కంటే చాలా ఎక్కువ. సౌకర్యవంతమైన మరియు కాంపాక్ట్.
 తరువాత, మీరు ఎలా ఉన్నారో తీసుకుందాం, వైర్ హ్యాండిల్ చూడండి; మొత్తం సంఖ్యలు మరియు తేలియాడే పాయింట్ సంఖ్యల మధ్య వ్యత్యాసం ఉన్న 2 సంఖ్యా రకాలు కాకుండా, మనకు అవసరమయ్యే తదుపరి విస్తృతంగా ఉపయోగించబడే మరియు అవసరమైన రకం లేదా విలువ మన తీగలేనని ముందుగానే తెలుస్తుంది) మనం ఎక్కడ మాట్లాడుతున్నామో దానితో వ్యవహరించాల్సిన అవసరం ఉంది అక్షరాల క్రమం గురించి, మరియు మన దగ్గర ఉన్నదాని గురించి; మేము సి లో పనిచేస్తుంటే, ఇప్పుడు మనకు సి స్ట్రింగ్ ఉంది.
 సి స్ట్రింగ్ వలె డిఫాల్ట్ రకాన్ని కలిగి లేదు, కానీ దీనికి స్ట్రింగ్.హెచ్ ప్రామాణిక లైబ్రరీ హెడర్ ఉంది, ఇది స్ట్రెలెన్, స్ట్రెలెన్, స్ట్ర్క్పి, స్ట్ర్కాట్ మొదలైన అనేక రకాల స్ట్రింగ్ ఫంక్షన్లను అనుమతిస్తుంది (ఫంక్షన్) మరియు దానితో సి స్ట్రింగ్ ( స్ట్రింగ్) కేవలం అక్షరాల శ్రేణి, ఇది NULL చేత ముగించబడిందని మేము చెబుతున్నాము, అంటే మీరు శ్రేణిని ఎడమ నుండి కుడికి మార్చినట్లయితే స్కాన్ చేసేటప్పుడు, మీరు మొదట శూన్య అక్షరాల వద్దకు వచ్చే వరకు మీకు స్ట్రింగ్ ఉందని భావిస్తూనే ఉంటారు. ASCII విలువ 0 ఉన్న అక్షరాలు; దయచేసి ఈ NULL తరువాత శ్రేణిలో, ఇంకా చాలా ఇతర అక్షరాలు మిగిలి ఉండవచ్చు, కానీ అవి స్ట్రింగ్‌లో భాగంగా పరిగణించబడవు.
 ఇప్పుడు, ఈ సమావేశంతో మనం స్ట్రింగ్ (స్ట్రింగ్) నుండి స్ట్రింగ్ (స్ట్రింగ్) ఫంక్షన్ ఉపయోగిస్తే.
 H హెడర్ అప్పుడు మీరు అందరికీ తెలిసినందున మీరు వివిధ రకాల స్ట్రింగ్ ఆపరేషన్లను పొందగలుగుతారు.
 దీనికి విరుద్ధంగా, C ++ ఇప్పుడు C ++ ప్రామాణిక లైబ్రరీలో స్ట్రింగ్ రకాన్ని పరిచయం చేసింది.
 మేము వెక్టర్ గురించి మాట్లాడేటప్పుడు ఇదే.
 కాబట్టి, స్ట్రింగ్ కూడా అంతర్నిర్మిత రకం కాదు, కానీ ఇది ప్రామాణిక లైబ్రరీ ద్వారా జతచేయబడిన రకం మరియు మీరు C ++ ప్రామాణిక లైబ్రరీ యొక్క స్ట్రింగ్‌ను స్ట్రింగ్ చేయడానికి స్ట్రింగ్ పొందాలి. హెడర్ ఉపయోగించాలి మరియు అది అదనపు వ్యక్తీకరణగా స్ట్రింగ్‌ను వ్రాయడం మరియు ఘనీభవించడం వంటి కొన్ని అద్భుతమైన ప్రవర్తనలను కలిగి ఉంది.
 అందువల్ల, మేము వాటిని వివరిస్తాము.
 సి ప్రోగ్రామ్ మరియు సి ++ ప్రోగ్రామ్ మధ్య సరళమైన సమాంతరం ఉంది.
 ఈ ప్రోగ్రామ్ హలో వరల్డ్ ప్రోగ్రామ్‌లో నిర్వచించబడిన రెండు తీగలతో మొదలవుతుంది మరియు మొదటి స్ట్రింగ్ తర్వాత రెండవ స్ట్రింగ్‌ను మార్చాలనుకుంటున్నాము.
 అందువల్ల, మేము వాటిని మొదటి స్ట్రింగ్ తరువాత రెండవ స్ట్రింగ్ తో మాత్రమే అనుసరించాలనుకుంటున్నాము మరియు ఒక చిన్న స్ట్రింగ్ ను సృష్టించండి.
 కాబట్టి, మీరు సి లో చేయవలసి వస్తే, ఎడమ వైపున మీరు ఏమి చేయాలో చూడవచ్చు, అప్పుడు మీకు శ్రేణి అవసరం, చిన్న స్ట్రింగ్ (స్ట్రింగ్) కలిగి ఉండటానికి, మాకు ఇది అవసరం (స్ట్రింగ్) , మీరు మొదట స్ట్రింగ్ (స్ట్రింగ్) ను str1 str కు కాపీ చేసి, ఆపై మీరు ఇప్పటికే str2 ను కాపీ చేసారు.
 కాబట్టి, అది ఆ తర్వాతే వస్తుంది, కాబట్టి మొదట హలో ఆ తర్వాత ఖాళీగా str కు కాపీ చేయబడుతుంది మరియు తరువాత ప్రపంచానికి సంక్షిప్త స్ట్రాచీ (strcpy) మరియు strcat రచనలు లభిస్తాయి మరియు మీరు దానిని ముద్రించవచ్చు.
 దీనికి విరుద్ధంగా, C ++ లో మీకు స్ట్రింగ్ హెడర్‌లో స్ట్రింగ్ రకం ఉంది.
 అందువల్ల, మీరు స్ట్రింగ్ హెడర్‌లను కలిగి ఉంటారు, మీరు వాటిని ఇకపై ప్రకటించరు, ఎందుకంటే మీరు వాటిని స్ట్రింగ్ (స్ట్రింగ్) గా ప్రకటిస్తారు, ఇది ఆ హెడర్‌లో ఇచ్చిన రకం పేరు; దయచేసి ఈ పేరు అన్ని తక్కువ సందర్భాల్లో ఉందని గమనించండి, ఆపై మీకు స్ట్రింగ్ వేరియబుల్, పేరు str1 ఉంది మరియు మీరు దానిని స్థిరమైన స్ట్రింగ్ (హలో) ఖాళీ లేదా ప్రపంచంతో ప్రారంభించండి.
 చాలా ఆసక్తికరమైన విషయాలు ఏమిటంటే, మీరు దానిని కుదించవలసి వచ్చినప్పుడు మీరు నిజంగా మొదటి స్ట్రింగ్‌ను కాపీ చేసి, ఆపై స్థిరత్వం చేయనవసరం లేదు, నేను str1 కు str2 ని జోడిస్తున్నానని మీరు చెప్పగలరు.
 కాబట్టి, మేము str1 + str2 అని చెప్తాము, కాబట్టి నాకు వేరియబుల్ x 3 విలువ ఉంటే చాలా ఇష్టం, వేరియబుల్ y యొక్క విలువ 5.
 I x ప్లస్ y అంటే 3 ప్లస్ 5, అంటే 8.
 అందువల్ల ఇది పూర్ణాంకం.
 ఇది స్ట్రింగ్ రకానికి స్ట్రింగ్ (స్ట్రింగ్) ను జోడించడం మాదిరిగానే ఉంటుంది, ఇది ఒక సంగ్రహణ ఆపరేషన్ అవుతుంది మరియు మేము C ++ లో అద్భుతమైన శక్తిని చూస్తాము, ఇది ఆపరేటర్లను మీరు వివరించాలనుకున్నదానిని మీ స్వంత మార్గంలో నిర్వచించటానికి మిమ్మల్ని అనుమతిస్తుంది.
 ఉదాహరణకు, మీరు దీర్ఘచతురస్రాల కోసం బీజగణితం రాయడానికి దీనిని ఉపయోగించవచ్చు, మీకు రెండు దీర్ఘచతురస్రాలు ఉండవచ్చు, మీకు ఒక దీర్ఘచతురస్ర రకం ఉంటే మరియు మీరు ఒక దీర్ఘచతురస్రాన్ని ప్రాథమికంగా చేయడానికి రెండు దీర్ఘచతురస్రాల మొత్తాన్ని నిర్వచించవచ్చు.కాబట్టి ఈ దీర్ఘచతురస్రం యొక్క యూనియన్ ఏర్పడుతుంది ఈ దీర్ఘచతురస్రాలు మరియు మొదలైన రెండు పెద్ద దీర్ఘచతురస్రాలను కలిగి ఉంటుంది.
 కాబట్టి, స్ట్రింగ్ పరంగా, ఈ లక్షణం C ++ లో లభిస్తుంది, కాబట్టి తీగలతో వ్యవహరించడం చాలా సులభం అవుతుంది.
 C లో ప్రత్యేకంగా గమనించండి, C లో, ఫలిత పరిమాణం ఏమిటో మీరు నిజంగా తెలుసుకోవాలి? కాబట్టి, మీరు మళ్ళీ వేరియబుల్ str కోసం ఒక శ్రేణిని విస్తృతంగా నిర్వచించవచ్చు ఎందుకంటే ఇది str పరిమాణంలో సరిపోకపోతే స్ట్రాపీ, స్ట్రాకాట్ తరువాత C ++ లో విఫలమవుతుంది.
 మీరు దీన్ని చేసినప్పుడు, మీరు వీటిలో దేనినీ ఇబ్బంది పెట్టవలసిన అవసరం లేదు. వేరియబుల్ స్ట్రింగ్‌ను ఒక రకమైన స్ట్రింగ్‌గా ప్రకటించండి మరియు మీరు దాన్ని str1 + str2 యొక్క గణనతో ప్రారంభించండి.
 పైలర్ పరిమాణాన్ని స్వయంచాలకంగా నిర్వహించడానికి భయపడుతుంది మరియు మీకు ఏకకాలంలో ఉండేంత పెద్ద స్ట్రింగ్ ఇస్తుంది.
 కాబట్టి, తీగలను నిర్వహించడం చాలా సులభం.
 అలాగే, వైర్లను కనెక్ట్ చేయడం లేదా వైర్ల సంగ్రహణ కోసం అదనపు ఆపరేటర్లను ఉపయోగించడం వంటివి నిజంగా ముగియవు, మీరు అనేక ఇతర ఆపరేషన్లు చేయవచ్చు.
 స్తవానికి, మీకు సి స్టాండర్డ్ లైబ్రరీలో ఉన్న స్ట్రింగ్ డాట్ హెచ్ ఫంక్షన్ అవసరం లేదు మరియు మీరు స్ట్రింగ్ (స్ట్రింగ్) కాపీ చేసే స్థానంలో అసైన్‌మెంట్‌లను ఉపయోగించవచ్చు, అన్ని తులనాత్మక ఆపరేటర్లు మీరు ఉపయోగించగలది స్ట్రింగ్‌ను ఉపయోగించటానికి బదులుగా కనీసం సమానమైన దానికంటే ఎక్కువ.
 స్టాంప్‌ను ఉపయోగించడం చాలా క్లిష్టమైన పని అని మాకు తెలుసు; ఇది రెండు తీగలను తీసుకుంటుంది; కార్డ్ స్టాక్ పాయింటర్లు మరియు రెండు స్ట్రింగ్‌లు మీకు -1 లేదా 0 గా ఉండే విలువను ఇస్తాయి లేదా +1 కావచ్చు, ఏ స్ట్రింగ్ పెద్దది లేదా సమానంగా ఉంటుందో దానిపై ఆధారపడి ఉంటుంది. తీగలను సమానంగా ఉంటే సంభవిస్తుంది.
 ఇప్పుడు, మీరు C ++ లో స్ట్రింగ్ రకంతో లేరు, మీరు వీటిలో దేనినైనా పొందాల్సిన అవసరం లేదు.
 మీరు పూర్ణాంకాలు లేదా తేలియాడే పాయింట్ సంఖ్యలను పోల్చిన విధంగానే పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు మరియు తీగలను పోల్చవచ్చు.
 కాబట్టి, ఇది సి ++ యొక్క చాలా బలమైన లక్షణం మరియు ఇది చాలా అనుకూలమైన పద్ధతి, ముఖ్యంగా స్ట్రింగ్ కోసం.
 అందువల్ల, సి ++ గురించి లోతైన అవగాహన లేకుండా, మీరు స్ట్రింగ్ మాత్రమే ఉపయోగించడం ప్రారంభించవచ్చు మరియు మీ అన్ని ప్రోగ్రామ్‌లను తెలివిగా మరియు సులభంగా వ్రాయవచ్చు.
 ఈ మాడ్యూల్‌లో మనం చూపించాము - మనం శ్రేణులతో ఎలా పని చేయవచ్చు, వెక్టర్ వాస్తవానికి శ్రేణులను వేరియబుల్ పరిమాణానికి ఎలా సులభతరం చేస్తుంది మరియు స్ట్రింగ్ రకాలను ఉపయోగిస్తుంది C ++ లో తీగలను చాలా సులభంగా ఎలా నిర్వహించాలి.
 ప్రామాణిక లైబ్రరీ.