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