డైనమిక్ శ్రేణిగా పనిచేసే డేటా శ్రేణిని నిల్వ చేయడానికి C ++ యొక్క ఉపయోగకరమైన కంటైనర్ తరగతి వెక్టర్. రన్ టైమ్‌లో ఆబ్జెక్ట్‌లోని ఎలిమెంట్‌ను జోడించడం లేదా తీసివేయడం ద్వారా వెక్టర్ ఆబ్జెక్ట్ సైజును పెంచవచ్చు లేదా తగ్గించవచ్చు. వెక్టర్ ఆబ్జెక్ట్ యొక్క నిర్దిష్ట మూలకం ముందు ఒకటి లేదా అంతకంటే ఎక్కువ కొత్త ఎలిమెంట్‌లను జోడించడానికి ఇన్సర్ట్ () ఫంక్షన్ ఉపయోగించబడుతుంది. ఇది వెక్టర్ వస్తువు పరిమాణాన్ని డైనమిక్‌గా పెంచుతుంది. ఈ ఫంక్షన్ యొక్క విభిన్న వాక్యనిర్మాణం మరియు ఉపయోగాలు ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి.
వాక్యనిర్మాణం:
వెక్టర్ యొక్క ఇన్సర్ట్ () ఫంక్షన్‌ను వివిధ ప్రయోజనాల కోసం వివిధ మార్గాల్లో ఉపయోగించవచ్చు. ఈ ఫంక్షన్ యొక్క మూడు వేర్వేరు వాక్యనిర్మాణాలు క్రింద పేర్కొనబడ్డాయి.
iterator ఇన్సర్ట్(const_iterator స్థానం,కానిస్టేట్విలువ_ రకం&విలువ);
స్థాన వాదన ద్వారా పేర్కొన్న వెక్టర్ మూలకం యొక్క స్థానానికి ముందు విలువ వాదన విలువను చొప్పించడానికి పై ఇన్సర్ట్ () ఫంక్షన్ ఉపయోగించబడుతుంది. ఇది వెక్టర్ యొక్క కొత్తగా చేర్చబడిన మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది.
iterator ఇన్సర్ట్(iterator స్థానం, size_type n,కానిస్టేట్విలువ_ రకం&విలువ);
పైన పేర్కొన్న ఇన్సర్ట్ () ఫంక్షన్ ఇంతకు ముందు పేర్కొన్న ఇన్సర్ట్ () ఫంక్షన్ లాగానే పనిచేస్తుంది, కానీ అదే విలువను వెక్టర్ ఆబ్జెక్ట్‌లో అనేకసార్లు ఇన్సర్ట్ చేస్తుంది.
iterator ఇన్సర్ట్(const_iterator స్థానం, ముందుగా InputIterator, చివరిగా InputIterator);
పొజిషన్ ఆర్గ్యుమెంట్ ద్వారా పేర్కొన్న వెక్టర్ ఎలిమెంట్ స్థానానికి ముందు మూలకాల పరిధిని ఇన్సర్ట్ చేయడానికి పై ఇన్సర్ట్ () ఫంక్షన్ పని చేస్తుంది. ఇది మునుపటి రెండు ఇన్సర్ట్ () ఫంక్షన్ల వంటి వెక్టర్ యొక్క కొత్తగా చేర్చబడిన ఎలిమెంట్‌లను సూచించే ఇటరేటర్‌ను అందిస్తుంది.
ముందస్తు అవసరం:
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేయడానికి ముందు, మీరు సిస్టమ్‌లో g ++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ను సృష్టించడానికి C ++ సోర్స్ కోడ్‌ను కంపైల్ చేయడానికి అవసరమైన ఎక్స్‌టెన్షన్‌లను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, C ++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి విజువల్ స్టూడియో కోడ్ అప్లికేషన్ ఉపయోగించబడింది. వెక్టర్‌లోకి మూలకం (ల) చొప్పించడానికి ఇన్సర్ట్ () ఫంక్షన్ యొక్క వివిధ ఉపయోగాలు క్రింద చూపబడ్డాయి.
ఉదాహరణ -1: ఒకే మూలకాన్ని చొప్పించడం
ఇన్సర్ట్ () ఫంక్షన్‌ను ఉపయోగించి ఒకే మూలకాన్ని చొప్పించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. కోడ్‌లో 5 ఫ్లోట్ నంబర్‌ల వెక్టర్ ప్రకటించబడింది. ప్రారంభ () ఫంక్షన్ ఉపయోగించి వెక్టర్ ప్రారంభంలో ఒక సంఖ్యను చొప్పించడానికి మొదటి ఇన్సర్ట్ () ఫంక్షన్ ఉపయోగించబడింది. రెండవ ఇన్సర్ట్ () ఫంక్షన్, వెక్టర్ ప్రారంభంలో ఒక సంఖ్యను ఇటరేటర్ వేరియబుల్ ఉపయోగించి ఇన్సర్ట్ చేయడానికి ఉపయోగించబడింది. మూడవ ఇన్సర్ట్ () ఫంక్షన్ వెక్టర్ యొక్క నాల్గవ స్థానంలో ఒక సంఖ్యను చొప్పించాలి.
// అవసరమైన లైబ్రరీలను చేర్చండి
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
// వెక్టర్‌ని ప్రదర్శించండి
శూన్యంప్రదర్శన(వెక్టర్<తేలుతాయి>సంఖ్యలు)
{
// లూప్ ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం(దానంతట అదేఅతను=సంఖ్యలు.ప్రారంభించండి();అతను!=సంఖ్యలు.ముగింపు() ;అతను++)
ఖరీదు << *అతను<< '';
// కొత్త లైన్ జోడించండి
ఖరీదు << ' n';
}
intప్రధాన()
{
// వెక్టర్‌ను ప్రారంభించండి
వెక్టర్<తేలుతాయి>ధర= { 78.56,34.07,2. 3,నాలుగు ఐదు,61.08,29.3 };
ఖరీదు << 'అసలు వెక్టర్:';
ప్రదర్శన(ధర);
// ప్రారంభాన్ని ఉపయోగించి ముందు భాగంలో సంఖ్యను చొప్పించండి ()
దానంతట అదేiterator=ధర.చొప్పించు(ధర.ప్రారంభించండి(),42.67);
ఖరీదు << 'మొదటి చొప్పించిన తర్వాత వెక్టర్:';
ప్రదర్శన(ధర);
// ఇట్రేటర్‌ని ఉపయోగించి ముందు భాగంలో నంబర్‌ను చొప్పించండి
ధర.చొప్పించు(ఇట్రేటర్,30.76);
ఖరీదు << 'రెండవ చొప్పించిన తర్వాత వెక్టర్:';
ప్రదర్శన(ధర);
// ఒక పూర్ణాంక వేరియబుల్‌ను ప్రారంభించండి
intస్థానం= 3;
// నిర్దిష్ట స్థానంలో నంబర్‌ను చొప్పించండి
iterator=ధర.చొప్పించు(ధర.ప్రారంభించండి() +స్థానం,52.56);
ఖరీదు << 'మూడో ఇన్సర్ట్ తర్వాత వెక్టర్:';
ప్రదర్శన(ధర);
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టర్ యొక్క విలువలు అవుట్‌పుట్‌లో నాలుగు సార్లు ముద్రించబడ్డాయి.
ఉదాహరణ -2: ఒకే మూలకాన్ని అనేకసార్లు చొప్పించడం
మూడు మూలకాలతో ఇన్సర్ట్ () ఫంక్షన్‌ని ఉపయోగించి వెక్టర్‌లో ఒకే మూలకాన్ని అనేకసార్లు చొప్పించడానికి కింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. కోడ్‌లో 8 పూర్ణాంక సంఖ్యల వెక్టర్ ప్రకటించబడింది. కోడ్ యొక్క ఇన్సర్ట్ () ఫంక్షన్‌ను అమలు చేసిన తర్వాత వెక్టర్ చివరిలో 50 సంఖ్య 5 సార్లు చేర్చబడుతుంది. ఇక్కడ, వెక్టర్ చివర మూలకాలను చొప్పించడానికి ముగింపు () ఫంక్షన్ ఉపయోగించబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
// వెక్టర్‌ని ప్రదర్శించండి
శూన్యంప్రదర్శన(వెక్టర్<int>సంఖ్యలు)
{
// లూప్ ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం(దానంతట అదేఅతను=సంఖ్యలు.ప్రారంభించండి();అతను!=సంఖ్యలు.ముగింపు() ;అతను++)
ఖరీదు << *అతను<< '';
// కొత్త లైన్ జోడించండి
ఖరీదు << ' n';
}
intప్రధాన()
{
// వెక్టర్‌ను ప్రారంభించండి
వెక్టర్<int>intArray{7,5,12,4,నాలుగు ఐదు,3,64,10};
ఖరీదు << 'అసలు వెక్టర్:';
ప్రదర్శన(intArray);
// వెక్టర్ చివరిలో ఒకే సంఖ్యను అనేకసార్లు చొప్పించండి
intArray.చొప్పించు(intArray.ముగింపు(),5,యాభై);
ఖరీదు << ఒకే సంఖ్యను 5 సార్లు చేర్చిన తర్వాత వెక్టర్: ';
ప్రదర్శన(intArray);
ఖరీదు << ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టర్ యొక్క విలువలు అవుట్‌పుట్‌లో రెండుసార్లు ముద్రించబడ్డాయి.
ఉదాహరణ -3: మూలకాల పరిధిని చొప్పించడం
వెక్టర్ నుండి మరొక వెక్టర్ చివరి వరకు అన్ని ఎలిమెంట్‌లను ఇన్సర్ట్ చేయడానికి కింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. ఇక్కడ, ఇన్సర్ట్ () ఫంక్షన్ మూడు పారామితులను కలిగి ఉంది. చొప్పించే స్థానం మొదటి పరామితిలో సెట్ చేయబడింది. రెండవ వెక్టర్ యొక్క ప్రారంభ మరియు ముగింపు ఇట్రేటర్లు ఇన్సర్ట్ () ఫంక్షన్ యొక్క రెండవ మరియు మూడవ వాదనలో సెట్ చేయబడ్డాయి.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
// ఫంక్షన్ నమూనాను నిర్వచించండి
శూన్యంప్రదర్శన(వెక్టర్<స్ట్రింగ్>జాబితా);
intప్రధాన()
{
// మొదటి స్ట్రింగ్ వెక్టర్‌ని ప్రకటించండి
వెక్టర్<స్ట్రింగ్>జాబితా 1{'html','css','జావాస్క్రిప్ట్','బూట్స్ట్రాప్'};
// రెండవ స్ట్రింగ్ వెక్టర్‌ని ప్రకటించండి
వెక్టర్<స్ట్రింగ్>జాబితా 2{'php','జావా','కొండచిలువ','బాష్','పెర్ల్'};
ఖరీదు<<'జాబితా విలువలు 1:';
ప్రదర్శన(జాబితా 1);
ఖరీదు<<'జాబితా విలువలు 2:';
ప్రదర్శన(జాబితా 2);
// జాబితా 1 ప్రారంభంలో జాబితా 2 యొక్క విలువలను చొప్పించండి
జాబితా 1.చొప్పించు(జాబితా 1.ప్రారంభించండి(), జాబితా 2.ప్రారంభించండి(), జాబితా 2.ముగింపు());
ఖరీదు<<జాబితా 2 చేర్చిన తర్వాత జాబితా 1 యొక్క విలువలు: ';
ప్రదర్శన(జాబితా 1);
తిరిగి 0;
}
// వెక్టర్‌ని ప్రదర్శించండి
శూన్యంప్రదర్శన(వెక్టర్<స్ట్రింగ్>జాబితా)
{
// లూప్ ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం(దానంతట అదేఅతను=జాబితాప్రారంభించండి();అతను!=జాబితాముగింపు() ;అతను++)
ఖరీదు << *అతను<< '';
// కొత్త లైన్ జోడించండి
ఖరీదు << ' n';
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టర్ యొక్క విలువలు అవుట్‌పుట్‌లో మూడు సార్లు ముద్రించబడ్డాయి.
ముగింపు:
ఇన్సర్ట్ () ఫంక్షన్ ఉపయోగించి వెక్టర్ యొక్క ఏ స్థితిలోనైనా ఒకటి లేదా అంతకంటే ఎక్కువ ఎలిమెంట్‌లను ఇన్సర్ట్ చేసే మార్గాలు బహుళ ఉదాహరణలను ఉపయోగించి ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి. ఈ ట్యుటోరియల్ చదివిన తర్వాత C ++ కోడర్ వెక్టర్ యొక్క ఇన్సర్ట్ () ఫంక్షన్‌ను సరిగ్గా ఉపయోగిస్తుందని నేను ఆశిస్తున్నాను.