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