ముందస్తు అవసరం:
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేయడానికి ముందు, మీరు సిస్టమ్‌లో g ++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ను సృష్టించడానికి C ++ సోర్స్ కోడ్‌ని కంపైల్ చేయడానికి అవసరమైన ఎక్స్‌టెన్షన్‌లను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, C ++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి విజువల్ స్టూడియో కోడ్ అప్లికేషన్ ఉపయోగించబడింది.
ఉదాహరణ -1: లూప్ ఉపయోగించి వెక్టర్ పరిమాణాన్ని లెక్కించండి
అంతర్నిర్మిత ఫంక్షన్‌ను ఉపయోగించకుండా వెక్టర్ పరిమాణాన్ని లెక్కించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. స్ట్రింగ్ విలువల వెక్టర్ కోడ్‌లో ప్రకటించబడింది. వినియోగదారు నిర్వచించిన ఫంక్షన్ పేరు పెట్టబడింది లెక్కించు_ పరిమాణం () లూప్ ఉపయోగించి వెక్టర్ పరిమాణాన్ని లెక్కించడానికి ఇక్కడ ప్రకటించబడింది. ఈ ఫంక్షన్ వెక్టర్‌ను ఆర్గ్యుమెంట్ విలువగా తీసుకుంటుంది మరియు వెక్టర్ పరిమాణాన్ని కాలర్‌కు అందిస్తుంది. వెక్టర్‌ను ప్రకటించిన తర్వాత ఈ ఫంక్షన్ మొదటిసారిగా పిలువబడింది. తరువాత, వెక్టర్ యొక్క పరిమాణాన్ని పెంచే వెక్టర్ చివరలో రెండు విలువలు జోడించబడ్డాయి. ది లెక్కించు_ పరిమాణం () సవరించిన వెక్టర్ పరిమాణాన్ని లెక్కించడానికి ఫంక్షన్ రెండవ సారి పిలుపునిచ్చింది.
// అవసరమైన మాడ్యూల్‌లను చేర్చండి
#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ని ఉపయోగిస్తోంది;
// వెక్టర్ పరిమాణాన్ని లెక్కించడానికి డిక్లేట్ ఫంక్షన్
intcalculate_ పరిమాణం(vectorstrVec)
{
// స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించండి
intపొడవు= 0;
/ *
లూప్ యొక్క కంటెంట్‌ను పునరుద్ఘాటించండి
మరియు ప్రతి పునరుక్తిలో పొడవు వేరియబుల్ విలువను పెంచండి
వెక్టర్ పరిమాణాన్ని లెక్కించడానికి
* /
కోసం (స్ట్రింగ్ మూలకం:strVec)
పొడవు++;
// పరిమాణ విలువను తిరిగి ఇవ్వండి
తిరిగిపొడవు;
}
intmain() {
// స్ట్రింగ్ డేటా యొక్క వెక్టర్‌ని ప్రకటించండి
వెక్టర్ అంశాలు= { 'పుస్తకం', 'పెన్', 'పెన్సిల్', 'రబ్బరు' };
// వెక్టర్ యొక్క ప్రస్తుత పరిమాణాన్ని ముద్రించండి
ఖరీదు<<'వెక్టర్ పరిమాణం:'<<లెక్కించు_ పరిమాణం(వస్తువులు) <<endl;
// పుష్_బ్యాక్ () ఫంక్షన్ ఉపయోగించి రెండు కొత్త అంశాలను జోడించండి
వస్తువులు.వెనుకకు నెట్టడం('కలర్ పేపర్');
వస్తువులు.వెనుకకు నెట్టడం('వాటర్ కలర్');
// వెక్టర్ యొక్క ప్రస్తుత పరిమాణాన్ని జోడించిన తర్వాత ముద్రించండి
ఖరీదు<<'జోడించిన తర్వాత వెక్టర్ పరిమాణం:'<<లెక్కించు_ పరిమాణం(వస్తువులు) <<endl;
}
అవుట్పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది. డిక్లరేషన్ సమయంలో వెక్టర్‌లో 4 అంశాలు ఉన్నాయి. కాబట్టి, కొత్త విలువలను చొప్పించడానికి ముందు వెక్టర్ పరిమాణం 4 అని అవుట్పుట్ చూపిస్తుంది, మరియు 2 విలువలను చొప్పించిన తర్వాత పరిమాణం 6.
ఉదాహరణ -2: పరిమాణం () ఉపయోగించి వెక్టర్ పరిమాణాన్ని లెక్కించండి
వెక్టర్ పరిమాణాన్ని లెక్కించడానికి అంతర్నిర్మిత ఫంక్షన్ C ++ లో ఉంది. ఫంక్షన్ పేరు, పరిమాణం (). ఇది వెక్టర్ ఉపయోగించే సైజు లేదా మొత్తం మూలకాలను అందిస్తుంది. ఇది ఎటువంటి వాదనను తీసుకోదు.
వాక్యనిర్మాణం:
intవెక్టర్.పరిమాణం();కింది ఉదాహరణ వెక్టర్ యొక్క మొత్తం మూలకాలను లెక్కించడానికి పరిమాణం () ఫంక్షన్ యొక్క ఉపయోగాన్ని చూపుతుంది. కోడ్‌ని పరీక్షించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. పూర్ణాంక సంఖ్యల వెక్టర్ కోడ్‌లో ప్రకటించబడింది. డిక్లరేషన్ సమయంలో వెక్టర్ 8 అంశాలను కలిగి ఉంటుంది. వెక్టర్ యొక్క మొత్తం మూలకాలను లెక్కించడానికి మరియు కౌంట్ విలువను ముద్రించడానికి సైజు () ఫంక్షన్ మొదటిసారి ఉపయోగించబడింది. వెక్టర్ చివర నాలుగు మూలకాలను జోడించిన తర్వాత మొత్తం మూలకాలను లెక్కించడానికి పరిమాణం () ఫంక్షన్ రెండవసారి ఉపయోగించబడింది.
// అవసరమైన మాడ్యూల్‌లను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ని ఉపయోగిస్తోంది;
intmain()
{
// పూర్ణాంక డేటా యొక్క వెక్టర్‌ని ప్రకటించండి
వెక్టోరింట్{ 56, 89, నాలుగు ఐదు, 87, ఇరవై ఒకటి, 77, 10, 42 };
// వెక్టర్ పరిమాణాన్ని ముద్రించండి
ఖరీదు<<'వెక్టర్ పరిమాణం:'<<intVector.పరిమాణం() <<endl;
// పుష్_బ్యాక్ () ఫంక్షన్ ఉపయోగించి వెక్టర్‌కు కొన్ని విలువలను జోడించండి
intVector.వెనుకకు నెట్టడం(65);
intVector.వెనుకకు నెట్టడం(90);
intVector.వెనుకకు నెట్టడం(49);
intVector.వెనుకకు నెట్టడం(16);
// జోడించిన తర్వాత వెక్టర్ పరిమాణాన్ని ముద్రించండి
ఖరీదు<<'జోడించిన తర్వాత వెక్టర్ పరిమాణం:'<<intVector.పరిమాణం() <<endl;
రిటర్న్ 0;
}
అవుట్పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది. డిక్లరేషన్ సమయంలో వెక్టర్‌లో 8 అంశాలు ఉన్నాయి. కాబట్టి, కొత్త విలువలను చొప్పించడానికి ముందు వెక్టర్ పరిమాణం 8 అని అవుట్పుట్ చూపిస్తుంది, మరియు 4 విలువలను చొప్పించిన తర్వాత పరిమాణం 12.
ఉదాహరణ -3: సరి సంఖ్యలను చేర్చడానికి వెక్టర్ పరిమాణాన్ని లెక్కించండి
వెక్టర్ పరిమాణాన్ని నిర్వచించిన తర్వాత వెక్టర్‌లోకి 10 సరి సంఖ్యలను ఎలా చొప్పించాలో కింది ఉదాహరణ చూపుతుంది. కోడ్‌ని పరీక్షించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. కోడ్ ప్రారంభంలో 10 తో పూర్ణాంక రకం యొక్క వెక్టర్ ప్రకటించబడింది. పూర్ణాంక వేరియబుల్ 0 నుండి 18 వరకు 10 సరి సంఖ్యలను వెక్టర్‌లోకి చేర్చడానికి ప్రకటించబడింది. ఇక్కడ, 'for' లూప్ పరిమాణం () ఫంక్షన్ యొక్క తిరిగి విలువ ఆధారంగా వెక్టర్‌ను మళ్ళించడానికి మరియు మూలకాన్ని వెక్టర్‌లోకి చొప్పించడానికి ఉపయోగించబడింది. తరువాత, వెక్టర్ విలువలను ముద్రించడానికి పరిమాణం () ఫంక్షన్ యొక్క అవుట్పుట్ ఉపయోగించబడింది.
// అవసరమైన మాడ్యూల్‌లను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// 10 మూలకాల వెక్టర్‌ని ప్రకటించండి
గంటలు::వెక్టర్<int>మైఅరే(10);
// ఒక పూర్ణాంక వేరియబుల్‌ను ప్రారంభించండి
intవిలువ= 0;
// పరిమాణాన్ని ఉపయోగించి వెక్టర్‌లోకి సరి సంఖ్యలను చొప్పించండి ()
కోసం(inti= 0;i<మైఅరే.పరిమాణం();i++)
{
మైఅరే[i] =విలువ;
విలువ=విలువ+ 2;
}
// పరిమాణం () ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం(intజ= 0;జ<మైఅరే.పరిమాణం();జ++)
ఖరీదు<<మైఅరే[జ] << '';
// కొత్త లైన్ జోడించండి
ఖరీదు<<endl;
}
<strongusingnamespace std;
intmain()
{
// 10 మూలకాల వెక్టర్‌ని ప్రకటించండి
గంటలు::వెక్టర్మీ అర్రే(10);
// ఒక పూర్ణాంక వేరియబుల్‌ను ప్రారంభించండి
intవిలువ= 0;
// పరిమాణాన్ని ఉపయోగించి వెక్టర్‌లోకి సరి సంఖ్యలను చొప్పించండి ()
కోసం(మీరు= 0;i<మైఅరే.పరిమాణం();i++)
{
మైఅరే[i] =విలువ;
విలువ=విలువ+ 2;
}
// పరిమాణం () ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం(intజ= 0;జ<మైఅరే.పరిమాణం();జ++)
ఖరీదు<<మైఅరే[జ] <<'';
// కొత్త లైన్ జోడించండి
ఖరీదు<<endl;
}
అవుట్పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
ముగింపు:
వెక్టర్ ఆఫ్ స్ట్రింగ్ డేటా మరియు న్యూమరిక్ డేటా ఉపయోగించి ఈ ట్యుటోరియల్‌లో వెక్టర్ యొక్క మొత్తం ఎలిమెంట్‌లను లెక్కించడానికి రెండు విభిన్న మార్గాలు వివరించబడ్డాయి. C ++ యూజర్ ఈ ట్యుటోరియల్ చదివిన తర్వాత విభిన్న ప్రోగ్రామింగ్ ప్రయోజనాలను పరిష్కరించడానికి అంతర్నిర్మిత ఫంక్షన్ లేదా లూప్ ఉపయోగించి వెక్టర్ పరిమాణాన్ని లెక్కించగలరు.