పరిచయం
వరుస శ్రేణి అనేది వరుస మెమరీ స్థానాల్లో ఒకే రకమైన వస్తువుల శ్రేణి. అర్రే పొడవు తగ్గించే ధాతువును పెంచదు. వెక్టర్ ఒక శ్రేణి లాంటిది, కానీ దాని పొడవును పెంచవచ్చు లేదా తగ్గించవచ్చు. కాబట్టి, ఒక వెక్టర్, శ్రేణి కంటే చాలా ఎక్కువ ఆపరేషన్లను కలిగి ఉంది.
సి ++ లో అనేక లైబ్రరీలు ఉన్నాయి, ఇవన్నీ సి ++ స్టాండర్డ్ లైబ్రరీని ఏర్పరుస్తాయి. ఈ లైబ్రరీలలో ఒకటి కంటైనర్ లైబ్రరీ. కంటైనర్ అనేది వస్తువుల సమాహారం, మరియు సేకరణలో కొన్ని ఆపరేషన్లు చేయవచ్చు. C ++ కంటైనర్‌లను రెండు సెట్లుగా విభజించవచ్చు: సీక్వెన్స్ కంటైనర్లు మరియు అసోసియేటివ్ కంటైనర్లు. సీక్వెన్స్ కంటైనర్లు వెక్టర్, అర్రే (గతంలో చర్చించిన అదే శ్రేణి కాదు), డెక్యూ, ఫార్వర్డ్_లిస్ట్ మరియు లిస్ట్. ఇవి విభిన్న సేకరణలు (శ్రేణి లాంటి డేటా నిర్మాణాలు), మరియు ప్రతి ఒక్కటి విభిన్న ట్రేడ్-ఆఫ్‌లను అందిస్తుంది.
వెక్టర్, అర్రే, డెక్యూ, ఫార్వార్డ్_లిస్ట్ లేదా లిస్ట్‌ని ఉపయోగించాలా వద్దా అని ఎలా నిర్ణయించుకోవాలో ఏదైనా ప్రోగ్రామర్ తెలుసుకోవాలి. ఒక ప్రోగ్రామర్‌కు సాధారణ శ్రేణికి సంబంధించిన వాటి కంటే ఎక్కువ ఆపరేషన్లు అవసరమయ్యే నిర్మాణం అవసరమైనప్పుడు, సాధారణ శ్రేణిని ఉపయోగించకూడదు.
టాస్క్ క్రమం మధ్యలో తరచుగా చొప్పించడం మరియు తొలగింపులను కలిగి ఉంటే, అప్పుడు జాబితా లేదా ఫార్వార్డ్_లిస్ట్ ఉపయోగించాలి. పని ప్రారంభంలో లేదా ముగింపులో తరచుగా చొప్పించడం మరియు తొలగింపులను కలిగి ఉంటే, అప్పుడు డెక్యూ ఉపయోగించాలి. ఈ విధమైన ఆపరేషన్లు అవసరం లేనప్పుడు వెక్టర్ ఉపయోగించాలి.
ఈ కథనం C ++ వెక్టర్‌ను ఎలా ఉపయోగించాలో మీకు చూపుతుంది. ఈ కథనాన్ని అర్థం చేసుకోవడానికి మీకు C ++ పాయింటర్‌లు, సూచనలు మరియు శ్రేణుల గురించి కొంత పరిజ్ఞానం అవసరం.
తరగతి మరియు వస్తువులు
క్లాస్ అనేది వేరియబుల్స్ మరియు ఫంక్షన్ల సమితి, ఇది కలిసి పనిచేస్తుంది, ఇక్కడ వేరియబుల్స్ కేటాయించిన విలువలు లేవు. వేరియబుల్స్‌కు విలువలు కేటాయించినప్పుడు, తరగతి ఒక వస్తువు అవుతుంది. ఒకే తరగతికి ఇచ్చిన విభిన్న విలువలు వేర్వేరు వస్తువులను కలిగిస్తాయి; అంటే, విభిన్న వస్తువులు ఒకే తరగతికి చెందినవి కానీ విభిన్న విలువలు కలిగి ఉంటాయి. తరగతి నుండి ఒక వస్తువును సృష్టించడం అనేది వస్తువును తక్షణం చేయడం అని కూడా అంటారు.
వెక్టర్ అనే పదం ఒక తరగతిని వివరిస్తుంది. వెక్టర్ నుండి సృష్టించబడిన వస్తువుకు ప్రోగ్రామర్ ఎంచుకున్న పేరు ఉంది.
తరగతికి చెందిన ఒక వస్తువును తరగతి నుండి తక్షణం అమలు చేయడానికి అవసరం. C ++ లో, ఆ ఫంక్షన్ క్లాస్ పేరు వలె అదే పేరును కలిగి ఉంటుంది. తరగతి నుండి సృష్టించబడిన (తక్షణం) వివిధ వస్తువులు ప్రోగ్రామర్ ద్వారా ప్రతి ఒక్కరికి ప్రత్యేకమైన పేర్లు ఇవ్వబడ్డాయి.
తరగతి నుండి వస్తువును సృష్టించడం అంటే వస్తువును నిర్మించడం; ఇది వస్తువును తక్షణం చేయడం అని కూడా అర్థం.
వెక్టర్ క్లాస్
వెక్టర్ క్లాస్ ఇప్పటికే నిర్వచించబడింది మరియు లైబ్రరీలో ఉంది. వెక్టర్ క్లాస్‌ని ఉపయోగించడానికి, ప్రోగ్రామర్ తప్పనిసరిగా కింది ప్రిప్రాసెసింగ్ డైరెక్టివ్‌తో ఫైల్‌లో వెక్టర్ హెడర్‌ని చేర్చాలి:
#చేర్చండిహెడర్ చేర్చబడిన తర్వాత, అన్ని వెక్టర్ ఫీచర్లు (డేటా మెంబర్‌లు మరియు మెంబర్ ఫంక్షన్‌లు) అందుబాటులోకి వస్తాయి. టెర్మినల్ (కన్సోల్) కు డేటాను అవుట్పుట్ చేయడానికి కౌంట్ ఆబ్జెక్ట్ ఉపయోగించడానికి, ఆబ్జెక్ట్ హెడర్ కూడా చేర్చబడాలి. వెక్టర్‌తో ప్రోగ్రామ్ రాయడానికి, కనిష్టంగా, కింది హెడర్‌లు తప్పక చేర్చబడాలి:
#చేర్చండి#చేర్చండి
వెక్టర్‌ని ఇన్‌స్టాంటింగ్ చేయడం
intఫూ[10];పైన ఫూ అనే పేరు మరియు మూలకాల సంఖ్యతో కూడిన శ్రేణి ప్రకటన ఉంది. ఇది పూర్ణాంకాల శ్రేణి. వెక్టర్ డిక్లరేషన్ కూడా ఇలాగే ఉంటుంది. వెక్టర్ కోసం, మూలకాల సంఖ్య ఐచ్ఛికం, ఎందుకంటే వెక్టర్ పొడవు పెరుగుతుంది లేదా తగ్గుతుంది.
ప్రోగ్రామ్‌లోని ఈ సమయంలో, వెక్టర్ క్లాస్ ఇప్పటికే లైబ్రరీలో నిర్వచించబడింది మరియు హెడర్ చేర్చబడింది. వెక్టర్ కింది విధంగా తక్షణం చేయవచ్చు:
గంటలు::వెక్టర్ <int>vtr(8);ఇక్కడ, వెక్టర్ అనేది ప్రత్యేక కన్స్ట్రక్టర్ ఫంక్షన్. వెక్టర్ కలిగి ఉండే డేటా రకం కోణం బ్రాకెట్లలో int. Vtr అనే పదం వెక్టర్ కోసం ప్రోగ్రామర్ ఎంచుకున్న పేరు. చివరగా, కుండలీకరణాలలో 8, వెక్టర్ కలిగి ఉండే పూర్ణాంకాల తాత్కాలిక సంఖ్య.
Std అనే పదం ప్రామాణిక నేమ్‌స్పేస్‌ని సూచిస్తుంది. ఈ సందర్భంలో ఈ పదాన్ని తప్పనిసరిగా డబుల్ కోలన్ అనుసరించాలి. ఎవరైనా తమ సొంత వెక్టర్ క్లాస్ లైబ్రరీని వ్రాసి ఉపయోగించుకోవచ్చు. అయితే, C ++ ఇప్పటికే వెక్టర్‌తో సహా ప్రామాణిక పేర్లతో ప్రామాణిక లైబ్రరీని కలిగి ఉంది. ప్రామాణిక పేరును ఉపయోగించడానికి, ప్రామాణిక పేరు తప్పనిసరిగా std :: ముందు ఉండాలి. ప్రామాణిక పేరు కోసం ప్రోగ్రామ్‌లో ప్రతిసారీ std :: టైప్ చేయడాన్ని నివారించడానికి, ప్రోగ్రామ్ ఫైల్ క్రింది విధంగా ప్రారంభమవుతుంది:
#చేర్చండి#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
ఫంక్షన్‌ని ఓవర్‌లోడ్ చేస్తోంది
రెండు లేదా అంతకంటే ఎక్కువ విభిన్న ఫంక్షన్ సంతకాలు ఒకే పేరును కలిగి ఉన్నప్పుడు, ఆ పేరు ఓవర్‌లోడ్ చేయబడిందని చెప్పబడింది. ఒక ఫంక్షన్‌ను పిలిచినప్పుడు, ఏ ఫంక్షన్ అమలు చేయబడుతుందో అనే సంఖ్య మరియు వాదనల రకం నిర్ణయిస్తుంది.
ఒక వెక్టర్ నిర్మాణం
వెక్టర్‌ని నిర్మించడం అంటే వెక్టర్ వస్తువును తక్షణం (సృష్టించడం). కన్స్ట్రక్టర్ ఫంక్షన్ క్రింది విధంగా ఓవర్‌లోడ్ చేయబడింది:
వెక్టర్ పేరు
ఇది సున్నా పొడవు మరియు T టైప్ యొక్క వెక్టర్‌ను సృష్టిస్తుంది, కింది ప్రకటన vtr పేరుతో ఫ్లోట్ రకం సున్నా పొడవు యొక్క వెక్టర్‌ను సృష్టిస్తుంది:
వెక్టర్<తేలుతాయి>vtr;వెక్టర్ పేరు (n)
ఇది టైప్ టి యొక్క n మూలకాలతో ఒక వెక్టర్‌ను సృష్టిస్తుంది, ఈ వెక్టర్ కోసం నాలుగు ఫ్లోట్ ఎలిమెంట్‌లతో ఒక స్టేట్‌మెంట్ క్రింది విధంగా ఉంది:
వెక్టర్<తేలుతాయి>vtr(4);వెక్టర్ పేరు (n, t)
ఇది t మూల్యానికి ప్రారంభించిన n మూలకాల యొక్క వెక్టర్‌ని సృష్టిస్తుంది. కింది స్టేట్‌మెంట్ 5 మూలకాల వెక్టర్‌ను సృష్టిస్తుంది, ఇక్కడ ప్రతి మూలకం విలువ 3.4 ఉంటుంది:
వెక్టర్<తేలుతాయి>vtr(5, 3.4);ప్రారంభంతో నిర్మాణం
కింది రెండు మార్గాలలో ఒకదానిలో ఒక వెక్టర్‌ను ఒకేసారి నిర్మించవచ్చు (సృష్టించవచ్చు) మరియు ప్రారంభించవచ్చు:
వెక్టర్<తేలుతాయి>vtr= {1.1, 2.2, 3.3, 4.4};లేదా
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వస్తువు పేరు తర్వాత కేవలం కుండలీకరణాలు లేవని గమనించండి. ఆబ్జెక్ట్ పేరు తర్వాత ఉపయోగించిన పేరెంటీస్‌లో ఇనిషియలైజర్ జాబితా ఉండాలి, కింది విధంగా:
వెక్టర్<తేలుతాయి>vtr({1.1, 2.2, 3.3, 4.4});ఇనిషియలైజర్ జాబితాతో తరువాత ఒక వెక్టర్ నిర్మించవచ్చు మరియు ప్రారంభించవచ్చు. ఈ సందర్భంలో, కుండలీకరణాలు ఉపయోగించబడవు:
వెక్టర్<తేలుతాయి>vtr;vtr= {1.1, 2.2, 3.3, 4.4};
వెక్టర్ V2 (V1)
ఇది కాపీ కన్స్ట్రక్టర్. ఇది వెక్టర్ V1 యొక్క కాపీగా వెక్టర్ V2 ని సృష్టిస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr1(5, 3.4);వెక్టర్<తేలుతాయి>vtr2(vtr1);
నిర్మాణ సమయంలో ఒక వెక్టర్ కేటాయించడం
నిర్మాణ సమయంలో, ఒక ఖాళీ వెక్టర్‌ను సృష్టించవచ్చు, మరొకటి దానికి కేటాయించబడుతుంది, కింది విధంగా:
వెక్టర్<తేలుతాయి>vtr1{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి>vtr2=vtr1;
రెండవ ప్రకటన దీనికి సమానం:
వెక్టర్<తేలుతాయి>vtr2= {1.1, 2.2, 3.3, 4.4};కానిస్టార్ వెక్టర్
కాన్స్టార్ వెక్టర్ అనేది వెక్టర్, దీని మూలకాలను మార్చలేము. ఈ వెక్టర్‌లోని విలువలు చదవడానికి మాత్రమే. సృష్టించినప్పుడు, వెక్టర్ క్రింది విధంగా కనిపిస్తుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};ఈ వెక్టర్ రకంలో, ఏ మూలకం జోడించబడదు లేదా తీసివేయబడదు. అంతేకాక, విలువను మార్చలేము.
ఐటరేటర్‌తో నిర్మాణం
ఒక డేటా రకం కోసం ఒక సాధారణ ప్రాతినిధ్యాన్ని టెంప్లేట్ అందిస్తుంది. ఇటరేటర్ ఒక కంటైనర్ విలువలు ద్వారా స్కానింగ్ యొక్క సాధారణ ప్రాతినిధ్యాన్ని అందిస్తుంది. ఇటరేటర్‌తో వెక్టర్ సృష్టించడానికి వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
టెంప్లేట్<తరగతి ఇన్పుట్ఇట్రేటర్>వెక్టర్(మొదట ఇన్పుట్ఇట్రేటర్,ఇన్పుట్ఇట్రేటర్ చివరిది,కానిస్టేట్కేటాయించేవాడు& =కేటాయించేవాడు());
పేర్కొన్న కేటాయింపుదారుని ఉపయోగించి ఇది శ్రేణికి (మొదటి, చివరి) వెక్టర్‌ని నిర్మిస్తుంది, తర్వాత ఈ ఆర్టికల్‌లో చర్చించబడుతుంది.
ఒక వెక్టర్‌ను నాశనం చేయడం
ఒక వెక్టర్‌ని నాశనం చేయడానికి, అది పరిధిని దాటిపోవడానికి అనుమతించండి మరియు స్వయంచాలకంగా నిర్వహించబడుతుంది.
వెక్టర్ సామర్థ్యం
size_type సామర్థ్యం () const noexcept
తిరిగి కేటాయించాల్సిన అవసరం లేకుండా వెక్టర్ కలిగి ఉన్న మొత్తం మూలకాల సంఖ్య సామర్థ్య సభ్యుల ఫంక్షన్ ద్వారా తిరిగి ఇవ్వబడుతుంది. దీని కోసం కోడ్ విభాగం క్రింది విధంగా ఉంది:
వెక్టర్<తేలుతాయి>vtr(4);intఒకదానిపై=vtr.సామర్థ్యం();
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్ 4.
రిజర్వ్ (n)
మెమరీ స్థలం ఎల్లప్పుడూ ఉచితంగా అందుబాటులో ఉండదు. అదనపు స్థలాన్ని ముందుగానే రిజర్వ్ చేసుకోవచ్చు. కింది కోడ్ విభాగాన్ని పరిగణించండి:
వెక్టర్<తేలుతాయి>vtr(4);vtr.రిజర్వ్(6);
ఖరీదు<<vtr.సామర్థ్యం() << ' n';
అవుట్పుట్ 6. కాబట్టి, రిజర్వ్ చేయబడిన అదనపు స్థలం 6 - 4 = 2 మూలకాలు. ఫంక్షన్ శూన్యతను అందిస్తుంది.
పరిమాణం () const noexcept
ఇది వెక్టర్‌లోని మూలకాల సంఖ్యను అందిస్తుంది. కింది కోడ్ ఈ ఫంక్షన్‌ను వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr(4);తేలుతాయిలు=vtr.పరిమాణం();
ఖరీదు<<లు<< ' n';
అవుట్పుట్ 4.
కుదించు_కు_ (
రిజర్వ్ () ఫంక్షన్‌తో వెక్టర్‌కు అదనపు సామర్థ్యాన్ని ఇచ్చిన తర్వాత, వెక్టర్‌ను దాని అసలు పరిమాణానికి సరిపోయేలా సైజ్ చేయవచ్చు. కింది కోడ్ దీనిని వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr(4);vtr.రిజర్వ్(6);
vtr.కుదించు_కు();
intలు=vtr.పరిమాణం();
ఖరీదు<<లు<< ' n';
అవుట్పుట్ 4 మరియు 6 కాదు. ఫంక్షన్ శూన్యంగా తిరిగి వస్తుంది.
పునizeపరిమాణం (sz), పరిమాణాన్ని (sz, c)
ఇది వెక్టర్ పరిమాణాన్ని మారుస్తుంది. ఒకవేళ కొత్త సైజు పాత సైజు కంటే చిన్నగా ఉంటే, చివర ఉన్న ఎలిమెంట్స్ చెరిపివేయబడతాయి. క్రొత్త పరిమాణం పొడవుగా ఉంటే, చివరికి కొంత డిఫాల్ట్ విలువ జోడించబడుతుంది. నిర్దిష్ట విలువను జోడించడానికి, రెండు ఆర్గ్యుమెంట్‌లతో పునizeపరిమాణం () ఫంక్షన్‌ని ఉపయోగించండి. కింది కోడ్ సెగ్మెంట్ ఈ రెండు ఫంక్షన్ల వినియోగాన్ని వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr1{1.1, 2.2, 3.3, 4.4};vtr1.పరిమాణం మార్చండి(2);
ఖరీదు<< 'Vtr1 యొక్క కొత్త పరిమాణం:' <<vtr1.పరిమాణం() << ' n';
వెక్టర్<తేలుతాయి>vtr2{1.1, 2.2};
vtr2.పరిమాణం మార్చండి(4, 8.8);
ఖరీదు<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';
అవుట్పుట్ క్రింది విధంగా ఉంది:
Vtr1 యొక్క కొత్త పరిమాణం: 2vtr2: 1.1 2.2 8.8 8.8
విధులు శూన్యం.
ఖాళీ () కానిస్టెప్ట్
వెక్టర్‌లో మూలకాలు లేనట్లయితే ఈ ఫంక్షన్ 1 కోసం నిజం మరియు వెక్టర్ ఖాళీగా ఉంటే తప్పు కోసం 0 ని అందిస్తుంది. ఫ్లోటర్ వంటి నిర్దిష్ట రకం డేటా కోసం వెక్టర్ 4 స్థానాలను కలిగి ఉంటే, ఎలాంటి ఫ్లోట్ విలువ లేకుండా, అప్పుడు ఆ వెక్టర్ ఖాళీగా ఉండదు. కింది కోడ్ దీనిని వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr;ఖరీదు<<vtr.ఖాళీ() << ' n';
వెక్టర్<తేలుతాయి>vt(4);
ఖరీదు<<అందువలనఖాళీ() << ' n';
వెక్టర్<తేలుతాయి>v(4,3.5);
ఖరీదు<<v.ఖాళీ() << ' n';
అవుట్పుట్ క్రింది విధంగా ఉంది:
10
0
వెక్టర్ ఎలిమెంట్ యాక్సెస్
ఒక వెక్టర్‌ను శ్రేణి వలె ఉప-స్క్రిప్ట్ చేయవచ్చు (ఇండెక్స్ చేయబడింది). సూచిక లెక్కింపు సున్నా నుండి ప్రారంభమవుతుంది.
వెక్టర్ పేరు [i]
ఆపరేషన్ వెక్టర్ నేమ్ [i] i వద్ద మూలకానికి సూచనను అందిస్తుందివవెక్టర్ యొక్క సూచిక. పై వెక్టర్ కోసం కింది కోడ్ 3.3 అవుట్‌పుట్‌లు:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr[2];
ఖరీదు<<fl<< ' n';
vectorName [i] const
వెక్టర్ స్థిరమైన వెక్టర్ అయినప్పుడు వెక్టర్ నేమ్ [i] కి బదులుగా ఆపరేషన్ వెక్టర్ నేమ్ [i] const అమలు చేయబడుతుంది. ఈ ఆపరేషన్ కింది కోడ్‌లో ఉపయోగించబడుతుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr[2];
ఖరీదు<<fl<< ' n';
వ్యక్తీకరణ i కి స్థిరమైన సూచనను అందిస్తుందివవెక్టర్ యొక్క మూలకం.
సబ్‌స్క్రిప్ట్‌తో విలువను కేటాయించడం
కింది విధంగా నిరంతర వెక్టర్‌కు విలువను కేటాయించవచ్చు:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};vtr[2] = 8.8;
ఖరీదు<<vtr[2] << ' n';
అవుట్పుట్ 8.8.
vectorName.at (i)
vectorName.at (i) vectorName [i] లాగా ఉంటుంది, అయితే vectorName.at (i) మరింత విశ్వసనీయమైనది. ఈ వెక్టర్ ఎలా ఉపయోగించాలో కింది కోడ్ చూపుతుంది:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr.వద్ద(2);
ఖరీదు<<fl<< ' n';
వద్ద()వెక్టర్ మెంబర్ఫంక్షన్.
vectorName.at (i) const
vectorName.at (i) const అనేది vectorName [i] const లాంటిది, కానీ vectorName.at (i) const మరింత విశ్వసనీయమైనది. vectorName.at (i) const అనేది vectorName.at (i) కు బదులుగా ఒక వెక్టర్ స్థిరమైన వెక్టర్‌గా ఉన్నప్పుడు అమలు చేయబడుతుంది. ఈ వెక్టర్ కింది కోడ్‌లో ఉపయోగించబడుతుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr.వద్ద(2);
ఖరీదు<<fl<< ' n';
వద్ద() కానిస్టేట్వెక్టర్ మెంబర్ఫంక్షన్.
వద్ద () ఫంక్షన్‌తో విలువను కేటాయించడం
At () ఫంక్షన్‌తో నాన్-కాన్‌స్టెంట్ వెక్టర్‌కు ఒక విలువను ఈ క్రింది విధంగా కేటాయించవచ్చు:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};vtr.వద్ద(2) = 8.8;
ఖరీదు<<vtr[2] << ' n';
అవుట్పుట్ 8.8.
సబ్-స్క్రిప్టింగ్‌తో సమస్య
సబ్-స్క్రిప్టింగ్ (ఇండెక్సింగ్) తో సమస్య ఏమిటంటే, ఇండెక్స్ పరిధికి మించి ఉంటే, సున్నా తిరిగి ఇవ్వబడవచ్చు లేదా రన్-టైమ్‌లో లోపం జారీ చేయబడవచ్చు.
ముందు ()
ఇది మూలకాన్ని తీసివేయకుండా వెక్టర్ యొక్క మొదటి మూలకానికి సూచనను అందిస్తుంది. కింది కోడ్ యొక్క అవుట్పుట్ 1.1.
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr.ముందు();
ఖరీదు<<fl<< ' n';
వెక్టర్ నుండి మూలకం తీసివేయబడలేదు.
ముందు () const
వెక్టర్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఫ్రంట్ () కి బదులుగా ఫ్రంట్ () కానిస్ట్రక్షన్ అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr.ముందు();
ఖరీదు<<fl<< ' n';
స్థిరమైన సూచన తిరిగి ఇవ్వబడుతుంది. వెక్టర్ నుండి మూలకం తీసివేయబడలేదు.
తిరిగి ()
ఇది మూలకాన్ని తీసివేయకుండా వెక్టర్ యొక్క చివరి మూలకానికి సూచనను అందిస్తుంది. కింది కోడ్ యొక్క అవుట్పుట్ 4.4.
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr.తిరిగి();
ఖరీదు<<fl<< ' n';
తిరిగి () కానిస్టేట్
వెక్టర్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ బ్యాక్ () కాస్ట్ బదులుగా () కు బదులుగా అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};తేలుతాయిfl=vtr.తిరిగి();
ఖరీదు<<fl<< ' n';
స్థిరమైన సూచన తిరిగి ఇవ్వబడుతుంది. వెక్టర్ నుండి మూలకం తీసివేయబడలేదు.
వెక్టర్ డేటా యాక్సెస్
డేటా () తప్ప; డేటా () const noexcept;
వీటిలో ఏవైనా [డేటా (), డేటా () + పరిమాణం ()) చెల్లుబాటు అయ్యే రేంజ్ వంటి పాయింటర్‌ను అందిస్తుంది.
ఇది తరువాత వ్యాసంలో మరింత వివరంగా వివరించబడుతుంది.
తిరిగి వచ్చే వస్తువులు మరియు వెక్టర్
ఇటరేటర్ ఒక పాయింటర్ లాంటిది కానీ పాయింటర్ కంటే ఎక్కువ కార్యాచరణను కలిగి ఉంటుంది.
ప్రారంభం () తప్ప
కింది కోడ్ విభాగంలో వలె, వెక్టర్ యొక్క మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::iteratoriter=vtr.ప్రారంభించండి();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 1.1. ఇటరేటర్‌ను అందుకున్న డిక్లరేషన్ ప్రకటించబడిందని గమనించండి. పాయింటర్ డిఫరెన్స్ చేయబడిన విధంగానే విలువను పొందడానికి రిటర్న్ ఎక్స్‌ప్రెషన్‌లో ఇటరేటర్ డిఫరెన్స్ చేయబడింది.
start () const noexcept;
వెక్టర్ యొక్క మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది. వెక్టర్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ ప్రారంభం () కాన్స్ట్ ప్రారంభానికి బదులుగా అమలు చేయబడుతుంది (). ఈ పరిస్థితిలో, వెక్టర్‌లోని సంబంధిత మూలకాన్ని సవరించలేము. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::const_iteratoriter=vtr.ప్రారంభించండి();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 1.1. తిరిగి ఇచ్చిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం ఇట్రేటర్‌కు బదులుగా const_iterator ఈసారి ఉపయోగించబడిందని గమనించండి.
ముగింపు () తప్ప
వెక్టర్ యొక్క చివరి మూలకం కంటే వెంటనే సూచించే ఇటరేటర్‌ను అందిస్తుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::iteratoriter=vtr.ముగింపు();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 0, ఇది అర్థరహితం, ఎందుకంటే చివరి మూలకాన్ని మించిన కాంక్రీట్ మూలకం లేదు.
ముగింపు () const noexcept
వెక్టర్ యొక్క చివరి మూలకం కంటే వెంటనే సూచించే ఇటరేటర్‌ను అందిస్తుంది. వెక్టర్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ ఎండ్ () కాన్స్ట్ అనేది ఎండ్ () కి బదులుగా అమలు చేయబడుతుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::const_iteratoriter=vtr.ముగింపు();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 0. గమనిక_ఇటరేటర్ తిరిగి ఇవ్వబడిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం ఇట్రేటర్‌కు బదులుగా ఈసారి ఉపయోగించబడిందని గమనించండి.
రివర్స్ ఇట్రేషన్
మొదటి మూలకానికి ముందు చివరి నుండి చివరి వరకు ఇట్రేటర్ ఉండే ఇటరేటర్ ఉండే అవకాశం ఉంది.
rbegin () తప్ప
కింది కోడ్ విభాగంలో వలె, వెక్టర్ యొక్క చివరి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::reverse_iteratorవెనుక=vtr.ప్రారంభించండి();
ఖరీదు<< *వెనుక<< ' n';
అవుట్పుట్ 4.4.
రివర్స్ ఇట్రేటర్‌ను అందుకున్న డిక్లరేషన్ ప్రకటించబడిందని గమనించండి. పాయింటర్ డిఫరెన్స్ చేయబడిన విధంగానే విలువను పొందడానికి రిటర్న్ ఎక్స్‌ప్రెషన్‌లో ఇటరేటర్ డిఫరెన్స్ చేయబడింది.
rbegin () const noexcept;
వెక్టర్ యొక్క చివరి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది. వెక్టర్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, rbegin () కు బదులుగా rbegin () const అనే వ్యక్తీకరణ అమలు చేయబడుతుంది. ఈ పరిస్థితిలో, వెక్టర్‌లోని సంబంధిత మూలకాన్ని సవరించలేము. ఈ ఫీచర్ కింది కోడ్‌లో ఉపయోగించబడుతుంది:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::const_reverse_iteratorవెనుక=vtr.ప్రారంభించండి();
ఖరీదు<< *వెనుక<< ' n';
అవుట్పుట్ 4.4.
రిటర్న్ చేయబడిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం రివర్స్_ఇటరేటర్‌కు బదులుగా ఈసారి const_reverse_iterator ఉపయోగించబడిందని గమనించండి.
రెండర్ () తప్ప
వెక్టర్ యొక్క మొదటి మూలకానికి ముందు సూచించే ఇటరేటర్‌ను అందిస్తుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::reverse_iteratorవెనుక=vtr.తయారీలను();
ఖరీదు<< *వెనుక<< ' n';
మొదటి మూలకం ముందు కాంక్రీట్ మూలకం లేనందున అవుట్పుట్ 0, ఇది అర్థరహితం.
రెండర్ () కానిస్టెప్ట్
వెక్టర్ యొక్క మొదటి మూలకానికి ముందు సూచించే ఇటరేటర్‌ను అందిస్తుంది. వెక్టర్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, రెండ్ () కు బదులుగా రెండర్ () కానిస్ట్రక్షన్ అనే ఎక్స్‌ప్రెషన్ అమలు చేయబడుతుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
కానిస్టేట్వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి> ::const_reverse_iteratorవెనుక=vtr.తయారీలను();
ఖరీదు<< *వెనుక<< ' n';
అవుట్పుట్ 0.
రిటర్న్ చేయబడిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం రివర్స్_ఇటరేటర్‌కు బదులుగా ఈసారి const_reverse_iterator ఉపయోగించబడిందని గమనించండి.
వెక్టర్ మాడిఫైయర్లు
వెక్టర్‌ని సవరించే మాడిఫైయర్ ఒక ఇటరేటర్‌ను తీసుకోవచ్చు లేదా తిరిగి ఇవ్వవచ్చు.
a. ఇంప్లాస్ (p, args)
టైప్ T యొక్క వస్తువును std :: ఫార్వర్డ్ (ఆర్గ్స్) తో నిర్మించారు ... p కి ముందు.
వివరాల కోసం - తర్వాత చూడండిచొప్పించు (iteratorPosition, value)
వెక్టర్ యొక్క ఇటరేటర్ స్థానంలో విలువ యొక్క కాపీని చొప్పించాడు. కాపీని ఉంచిన వెక్టర్‌లో ఇటరేటర్ (స్థానం) ని అందిస్తుంది. కింది కోడ్ విలువ ఎక్కడ ఉంచబడిందో చూపుతుంది:
వెక్టర్<int>vtr{10, ఇరవై, 30, 40};వెక్టర్<int> ::iteratoriter=vtr.ప్రారంభించండి();
++iter;
++iter;
vtr.చొప్పించు(iter, 25);
ఖరీదు<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3] << ' n';
అవుట్పుట్: 20 25 30.
పాయింటర్ లాగానే ఇటరేటర్ అధునాతనమైన (ఇంక్రిమెంట్) గమనించండి.
కింది కోడ్ వివరిస్తున్నట్లుగా ఒక ఇనిషియలైజర్ జాబితాను కూడా చేర్చవచ్చు:
వెక్టర్<int>vtr{10, ఇరవై, 30, 40};వెక్టర్<int> ::iteratoriter=vtr.ప్రారంభించండి();
++iter;
++iter;
vtr.చొప్పించు(iter, {25, 28});
ఖరీదు<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3]<< '' <<vtr[4] << ' n';
అవుట్పుట్: 20 25 28 30.
చెరిపివేయి (స్థానం)
ఇట్రేటర్ సూచించిన స్థానంలో మూలకాన్ని తీసివేస్తుంది, ఆపై ఇటరేటర్ స్థానాన్ని అందిస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
వెక్టర్<int>vtr{10, ఇరవై, 30, 40};వెక్టర్<int> ::iteratoriter=vtr.ప్రారంభించండి();
++iter;
++iter;
vtr.చెరిపివేయి(iter);
ఖరీదు<<vtr[0] << '' <<vtr[1] << '
' <<vtr[2]<< ' n';
అవుట్పుట్: 10 20 40
పుష్_బ్యాక్ (t), పుష్_బ్యాక్ (rv)
వెక్టర్ చివరిలో ఒకే మూలకాన్ని జోడించడానికి ఉపయోగిస్తారు. కింది విధంగా పుష్_బ్యాక్ (టి) ఉపయోగించండి:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};vtr.వెనుకకు నెట్టడం(5.5);
తేలుతాయిfl=vtr[4];
ఖరీదు<<fl<< ' n';
అవుట్పుట్ 5.5.
వెనుకకు నెట్టడం(rv): -తరువాత చూడండి.pop_back ()
చివరి మూలకాన్ని తిరిగి ఇవ్వకుండా తీసివేస్తుంది. వెక్టర్ పరిమాణం 1. తగ్గించబడింది. కింది కోడ్ దీనిని వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};vtr.పాప్_బ్యాక్();
తేలుతాయిలు=vtr.పరిమాణం();
ఖరీదు<<లు<< ' n';
అవుట్పుట్ 3.
a. swap (b)
కింది కోడ్ విభాగంలో వివరించిన విధంగా రెండు వెక్టర్లను మార్చుకోవచ్చు:
వెక్టర్<తేలుతాయి>vtr1{1.1, 2.2, 3.3, 4.4};వెక్టర్<తేలుతాయి>vtr2{10, ఇరవై};
vtr1.మార్పిడి(vtr2);
ఖరీదు<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'<<vtr1[2] <<''<<vtr1[3] << ' n';
ఖరీదు<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';
అవుట్పుట్:
vtr1: 10 ఇరవై 0 0vtr2: 1.1 2.2 3.3 4.4
అవసరమైతే, వెక్టర్ యొక్క పొడవు పెరిగినట్లు గమనించండి. అలాగే, భర్తీ చేయని విలువలు కొంత డిఫాల్ట్ విలువతో భర్తీ చేయబడతాయి.
స్పష్టమైన ()
వెక్టర్ నుండి అన్ని మూలకాలను తొలగిస్తుంది, కింది కోడ్ సెగ్మెంట్ వివరిస్తుంది:
వెక్టర్<తేలుతాయి>vtr{1.1, 2.2, 3.3, 4.4};vtr.స్పష్టమైన();
ఖరీదు<<vtr.పరిమాణం() << ' n';
అవుట్పుట్ 0.
వెక్టర్స్ కోసం సమానత్వం మరియు రిలేషనల్ ఆపరేటర్లు
== ఆపరేటర్
రెండు వెక్టర్‌లు ఒకే సైజును కలిగి ఉంటే మరియు సంబంధిత ఎలిమెంట్‌లు సమానంగా ఉంటే ట్రూ కోసం 1 ని అందిస్తుంది. లేకపోతే, అది తప్పు కోసం 0 ని అందిస్తుంది. ఉదాహరణకి:
వెక్టర్<int>యు{1, 2, 3};వెక్టర్<int>వి{4, 5, 6};
బూల్ bl=యు==వి;
ఖరీదు<<bl<< ' n';
అవుట్పుట్ 0.
ది! = ఆపరేటర్
రెండు వెక్టర్‌లకు ఒకే సైజు లేకపోతే మరియు/లేదా సంబంధిత ఎలిమెంట్‌లు సమానంగా లేనట్లయితే 1 ట్రూ కోసం రిటర్న్స్ ఇస్తుంది; లేకపోతే, అది తప్పు కోసం 0 ని అందిస్తుంది. ఉదాహరణకి:
వెక్టర్<int>యు{1, 2, 3};వెక్టర్<int>వి{4, 5, 6};
బూల్ bl=యు! =వి;
ఖరీదు<<bl<< ' n';
అవుట్పుట్ 1.
ది
మొదటి వెక్టర్ రెండవ వెక్టర్ యొక్క ప్రారంభ ఉపసమితి అయితే, రెండు సమాన భాగాల మూలకాలు ఒకే విధంగా మరియు ఒకే క్రమంలో ఉంటే, నిజానికి 1 ని అందిస్తుంది. రెండు వెక్టర్‌లు ఒకే సైజులో ఉండి, ఎడమ నుండి కుడికి కదులుతుంటే మరియు రెండవ వెక్టర్‌లోని సంబంధిత మూలకం కంటే తక్కువగా ఉండే మొదటి వెక్టర్‌లో ఒక మూలకం ఎదురైనట్లయితే, అప్పుడు 1 ఇప్పటికీ తిరిగి ఇవ్వబడుతుంది. లేకపోతే, తప్పుడు కోసం 0 తిరిగి ఇవ్వబడుతుంది. ఉదాహరణకి:
వెక్టర్<int>యు{3, 1, 1};వెక్టర్<int>వి{3, 2, 1};
బూల్ bl=యు<వి;
ఖరీదు<<bl<< ' n';
అవుట్పుట్ 1. > ఆపరేటర్ రిటర్న్స్! (యు ది<= Operator U ని అందిస్తుంది<= V, where U is the first vector and V is the second vector, according to the above definitions. > = ఆపరేటర్ రిటర్న్స్! (యు<= V), where U is the first vector and V is the second vector, according to the above definitions. వెక్టర్ అనేది సీక్వెన్స్ కంటైనర్ యొక్క ఉదాహరణ. వెక్టర్ అనేది సాధారణ శ్రేణి యొక్క మెరుగైన రూపం మరియు తరగతి నుండి తక్షణం అందించబడుతుంది. వెక్టర్స్ కింద వర్గీకరించబడిన పద్ధతులు ఉన్నాయి: నిర్మాణం మరియు కేటాయింపు, సామర్థ్యం, మూలకం యాక్సెస్, డేటా యాక్సెస్, ఇటరేటర్లు, మాడిఫైయర్లు మరియు సంఖ్యా ఓవర్‌లోడ్ ఆపరేటర్లు. జాబితా, ఫార్వర్డ్_లిస్ట్ మరియు శ్రేణి అని పిలువబడే ఇతర సీక్వెన్స్ కంటైనర్లు ఉన్నాయి. టాస్క్ క్రమం మధ్యలో తరచుగా చొప్పించడం మరియు తొలగింపులను కలిగి ఉంటే, అప్పుడు జాబితా లేదా ఫార్వార్డ్_లిస్ట్ ఉపయోగించాలి. పని ప్రారంభంలో లేదా ముగింపులో తరచుగా చొప్పించడం మరియు తొలగింపులను కలిగి ఉంటే, అప్పుడు డెక్యూ ఉపయోగించాలి. కాబట్టి, ఈ విధమైన కార్యకలాపాలు ముఖ్యమైనవి కానప్పుడు మాత్రమే వెక్టర్లను ఉపయోగించాలి.ముగింపు