శ్రేణి బహుళ డేటాను నిల్వ చేయడానికి ఉపయోగించబడుతుంది మరియు రన్ సమయంలో శ్రేణి యొక్క మూలకాల సంఖ్యను మార్చలేరు. డైనమిక్ అర్రే వలె పనిచేసే వెక్టార్‌ని ఉపయోగించడం ద్వారా ఈ సమస్యను పరిష్కరించవచ్చు. వెక్టార్ నుండి మూలకాన్ని జోడించడానికి మరియు తీసివేయడానికి వెక్టర్ క్లాస్‌లో విభిన్న విధులు ఉన్నాయి. వెక్టార్ యొక్క పరిమాణాన్ని తగ్గించే రన్ సమయంలో వెక్టర్ నుండి ఒకటి లేదా అంతకంటే ఎక్కువ మూలకాలను తొలగించడానికి erase() ఫంక్షన్ ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ యొక్క ఉపయోగాలు ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి.
సింటాక్స్:
ఈ ఫంక్షన్ యొక్క రెండు రకాల సింటాక్స్ క్రింద ఇవ్వబడ్డాయి.
ఇటరేటర్ ఎరేస్ ( పునరావృత స్థానం ) ;
వెక్టార్ నుండి ఒకే మూలకాన్ని తీసివేయడానికి పైన ఉన్న ఎరేస్() ఫంక్షన్ ఉపయోగించబడుతుంది మరియు ఇది ఒక ఇటరేటర్‌ను అందిస్తుంది మరియు ఇది చివరిగా తొలగించబడిన మూలకం ద్వారా వచ్చిన మూలకాన్ని సూచిస్తుంది.
ఇటరేటర్ ఎరేస్ ( ఇటరేటర్ ప్రారంభ_స్థానం, పునరావృత్తి ముగింపు_స్థానం ) ;
ఈ ఫంక్షన్ యొక్క మొదటి మరియు రెండవ ఆర్గ్యుమెంట్‌లలో పేర్కొన్న స్థానం ఆధారంగా వెక్టార్ నుండి బహుళ మూలకాలను తీసివేయడానికి ఎగువ ఎరేజ్() ఫంక్షన్ ఉపయోగించబడుతుంది.
ముందస్తు అవసరం:
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేసే ముందు, మీరు సిస్టమ్‌లో g++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ని సృష్టించడానికి C++ సోర్స్ కోడ్‌ను కంపైల్ చేయడానికి అవసరమైన పొడిగింపులను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, విజువల్ స్టూడియో కోడ్ అప్లికేషన్ C++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి ఉపయోగించబడింది. వెక్టార్‌లో మూలకం(ల)ను చొప్పించడానికి ఎరేస్() ఫంక్షన్ యొక్క వివిధ ఉపయోగాలు క్రింద చూపబడ్డాయి.
ఉదాహరణ-1: మొదటి మూలకం మూలకాన్ని తీసివేయండి
వెక్టార్ ప్రారంభం నుండి మూలకాన్ని తీసివేయడానికి క్రింది కోడ్‌తో C++ ఫైల్‌ను సృష్టించండి. కోడ్‌లో స్ట్రింగ్ విలువల వెక్టర్ ఉపయోగించబడింది. వెక్టర్ యొక్క విలువలు వెక్టర్ నుండి మొదటి మూలకాన్ని తొలగించే ముందు మరియు తర్వాత ఒక పరామితితో erase() ఫంక్షన్‌ని ఉపయోగించి ముద్రించబడ్డాయి.
//అవసరమైన లైబ్రరీలను చేర్చండి#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
//వెక్టార్ విలువలను ప్రదర్శించండి
శూన్యం డిస్ప్లే_వెక్టర్ ( వెక్టర్ < స్ట్రింగ్ > పండ్లు )
{
//కౌంటర్‌ని ప్రారంభించండి
int కౌంటర్ = 1 ;
//లూప్ ఉపయోగించి వెక్టర్ యొక్క మూలకాలను పునరావృతం చేయండి మరియు ముద్రించండి
కోసం ( దానంతట అదే అతను = పండ్లు. ప్రారంభం ( ) ; అతను ! = పండ్లు. ముగింపు ( ) ; అతను ++ )
{
//మూలకాలు చివరి మూలకం కాదా అని తనిఖీ చేయండి
ఉంటే ( కౌంటర్ ! = పండ్లు. పరిమాణం ( ) )
కోట్ << * అతను << ',' ;
లేకపోతే
కోట్ << * అతను ;
//కౌంటర్‌ను 1 పెంచండి
కౌంటర్ ++ ;
}
కోట్ << endl ;
}
int ప్రధాన ( శూన్యం ) {
//స్ట్రింగ్ డేటా యొక్క వెక్టర్‌ను ప్రకటించండి
వెక్టర్ < స్ట్రింగ్ > పండ్లు = { 'నారింజ' , 'అరటి' , 'మామిడి' , 'జాక్ ఫ్రూట్' , లిచీ } ;
//వెక్టార్ యొక్క ప్రస్తుత విలువలను ముద్రించండి
కోట్ << 'తొలగించే ముందు వెక్టర్ విలువలు:' << endl ;
డిస్ప్లే_వెక్టర్ ( పండ్లు ) ;
//వెక్టార్ నుండి మొదటి మూలకాన్ని తీసివేయండి
పండ్లు. తుడిచివేయండి ( పండ్లు. ప్రారంభం ( ) ) ;
//తొలగించిన తర్వాత వెక్టర్ యొక్క ప్రస్తుత విలువలను ముద్రించండి
కోట్ << ' \n తీసివేసిన తర్వాత వెక్టర్ విలువలు: ' << endl ;
డిస్ప్లే_వెక్టర్ ( పండ్లు ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పై కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
ఉదాహరణ-2: బహుళ మూలకాలను తీసివేయండి
erase() ఫంక్షన్‌ని ఉపయోగించి వెక్టర్ నుండి బహుళ మూలకాలను తీసివేయడానికి క్రింది కోడ్‌తో C++ ఫైల్‌ను సృష్టించండి. కోడ్‌లో పూర్ణాంక విలువల వెక్టర్ ఉపయోగించబడింది. వెక్టార్ నుండి తీసివేయబడిన మూలకాల పరిధిని సెట్ చేయడానికి ఇక్కడ రెండు ఇటరేటర్లు ఉపయోగించబడ్డాయి. వెక్టార్ నుండి బహుళ మూలకాలను తీసివేయడానికి ఎరేస్() ఫంక్షన్ రెండు పారామితులతో ఉపయోగించబడింది.
//అవసరమైన లైబ్రరీలను చేర్చండి#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
//వెక్టార్‌ని ప్రదర్శించు
శూన్యం డిస్ప్లే_వెక్టర్ ( వెక్టర్ < int > సంఖ్యలు )
{
//లూప్ ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం ( దానంతట అదే అతను = సంఖ్యలు. ప్రారంభం ( ) ; అతను ! = సంఖ్యలు. ముగింపు ( ) ; అతను ++ )
కోట్ << * అతను << '' ;
//కొత్త లైన్ జోడించండి
కోట్ << ' \n ' ;
}
int ప్రధాన ( ) {
//పూర్ణాంక డేటా యొక్క వెక్టర్‌ను ప్రకటించండి
వెక్టర్ < int > intArray { 678 , 435 , 960 , 231 , 800 , 387 , 634 , 267 , 409 , 294 } ;
//వెక్టార్ యొక్క ప్రస్తుత విలువలను ముద్రించండి
కోట్ << 'తొలగించే ముందు వెక్టర్ విలువలు:' << endl ;
డిస్ప్లే_వెక్టర్ ( intArray ) ;
//వెక్టార్ నుండి మూలకాల పరిధిని తీసివేయడానికి రెండు ఇటరేటర్‌లను ప్రకటించండి
వెక్టర్ < int > :: పునరావృతం చేసేవాడు startEle, endEle ;
//ఇటరేటర్‌ను మొదటి స్థానానికి సెట్ చేయండి
వాటిని ప్రారంభించండి = intArray. ప్రారంభం ( ) ;
//ప్రారంభ ఇటరేటర్‌ను 2 ద్వారా పెంచండి
ముందుకు ( వాటిని ప్రారంభించండి, 2 ) ;
//ఇటరేటర్‌ను చివరి స్థానానికి సెట్ చేయండి
endEle = intArray. ముగింపు ( ) ;
//ముగింపు పునరావృత్తిని 3తో తగ్గించండి
ముందుకు ( endEle, - 3 ) ;
//మూలకాల పరిధిని తీసివేయండి
intArray. తుడిచివేయండి ( startEle, endEle ) ;
//తొలగించిన తర్వాత వెక్టర్ యొక్క ప్రస్తుత విలువలను ముద్రించండి
కోట్ << ' \n తీసివేసిన తర్వాత వెక్టర్ విలువలు: ' << endl ;
డిస్ప్లే_వెక్టర్ ( intArray ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పై కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. ఇటరేటర్ల పరిధి ప్రకారం, వెక్టర్ యొక్క 3వ స్థానం నుండి 7వ స్థానం వరకు ఉన్న మూలకాలు తీసివేయబడ్డాయి.
ఉదాహరణ-3: నిర్దిష్ట అంశాలను తీసివేయండి
erase() ఫంక్షన్‌ని ఉపయోగించి వెక్టర్ యొక్క నిర్దిష్ట మూలకాలను తీసివేయడానికి క్రింది కోడ్‌తో C++ ఫైల్‌ను సృష్టించండి. కోడ్‌లో 7 పూర్ణాంకాల మూలకాల వెక్టర్ ప్రకటించబడింది. తరువాత, వెక్టార్ మూలకాలను పునరావృతం చేయడానికి మరియు 5 ద్వారా భాగించబడని వెక్టర్ నుండి ఆ మూలకాలను తీసివేయడానికి 'ఫర్' లూప్ ఉపయోగించబడింది.
//అవసరమైన లైబ్రరీలను చేర్చండి#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
//పూర్ణాంక డేటా యొక్క వెక్టర్‌ను ప్రకటించండి
వెక్టర్ < int > సంఖ్యలు = { 78 , నాలుగు ఐదు , 67 , 25 , 98 , 75 , 52 } ;
కోట్ << 'తొలగించే ముందు వెక్టర్ విలువలు: \n ' ;
కోసం ( int స్థిరంగా & i : సంఖ్యలు ) {
కోట్ << i << '' ;
}
కోట్ << endl ;
//5చే భాగించబడని సంఖ్యలను వెక్టార్ నుండి తీసివేయండి
కోసం ( దానంతట అదే అతను = సంఖ్యలు. ప్రారంభం ( ) ; అతను ! = సంఖ్యలు. ముగింపు ( ) ; అతను ++ )
{
//సంఖ్యను 5తో భాగించవచ్చో లేదో తనిఖీ చేయండి
ఉంటే ( * అతను % 5 ! = 0 )
{
//ఇటరేటర్ ఆధారంగా మూలకాన్ని తీసివేయండి
సంఖ్యలు. తుడిచివేయండి ( అతను -- ) ;
}
}
కోట్ << 'తొలగించిన తర్వాత వెక్టర్ యొక్క విలువలు: \n ' ;
కోసం ( int స్థిరంగా & i : సంఖ్యలు ) {
కోట్ << i << '' ;
}
కోట్ << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పై కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టార్ 5 ద్వారా మాత్రమే విభజించదగిన మూలకాలను కలిగి ఉందని అవుట్‌పుట్ చూపిస్తుంది మరియు ఇతర మూలకాలు తీసివేయబడ్డాయి.
ముగింపు:
వెక్టార్ మూలకాలను తొలగించడానికి ఈ ట్యుటోరియల్‌లో erase() ఫంక్షన్ యొక్క వివిధ ఉపయోగాలు చూపబడ్డాయి. వెక్టర్ నుండి మూలకాన్ని తీసివేయడానికి C++ అనేక ఇతర విధులను కలిగి ఉంది మరియు ఆ ఫంక్షన్‌లు ఒకే మూలకాన్ని ఒకేసారి తీసివేయగలవు. కానీ వెక్టర్ ఎరేస్() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా వెక్టర్ యొక్క ఏదైనా స్థానం నుండి ఒకే మరియు బహుళ మూలకాలు రెండింటినీ తొలగించవచ్చు.