వాక్యనిర్మాణం :
ఈ ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది. ఈ ఫంక్షన్ నిర్దిష్ట స్థానాన్ని ఆర్గ్యుమెంట్ విలువగా తీసుకుంటుంది మరియు పొజిషన్ వాల్యూ ఉన్నట్లయితే ఆ పొజిషన్ విలువను అందిస్తుంది.
vector.at (స్థానం)
ఉదాహరణ -1: వెక్టర్‌లోని ప్రతి మూలకాన్ని చదవండి
వద్ద () ఫంక్షన్ ఉపయోగించి వెక్టర్ యొక్క ప్రతి మూలకాన్ని ముద్రించే మార్గం కింది ఉదాహరణలో చూపబడింది. స్ట్రింగ్ విలువల వెక్టర్ కోడ్‌లో నిర్వచించబడింది.
వెక్టర్ పరిమాణం ఆధారంగా వెక్టర్‌ను మళ్ళించడానికి మరియు () ఫంక్షన్‌ను ఉపయోగించి ప్రతి లైన్‌లో వెక్టర్ యొక్క ప్రతి విలువను ముద్రించడానికి ‘for’ లూప్ ఉపయోగించబడింది. వెక్టర్ యొక్క మూలకాల సంఖ్యను లెక్కించడానికి పరిమాణం () ఫంక్షన్ ఉపయోగించబడింది.
// ఇన్‌పుట్ మరియు అవుట్‌పుట్ కోసం లైబ్రరీని చేర్చండి
#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// స్ట్రింగ్ విలువల వెక్టర్‌ని ప్రకటించండి
వెక్టర్ Str= {'స్వాగతం', 'కు', 'LinuxHint'};
// లూప్‌ని ఉపయోగించి స్ట్రింగ్‌ను సూచించండి
కోసం(inti=0;i<స్ట్రీట్.పరిమాణం();i++)
{
// అక్షరాన్ని ముద్రించండి
ఖరీదు<<స్ట్రీట్.వద్ద(i) << ' n';
}
ఖరీదు<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టర్‌లోని 3 అంశాలు అవుట్‌పుట్‌లో ముద్రించబడ్డాయి.
ఉదాహరణ -2: వెక్టర్ విలువల మొత్తాన్ని లెక్కించండి
పూర్ణాంక సంఖ్యలను కలిగి ఉన్న వెక్టర్ యొక్క అన్ని విలువల మొత్తాన్ని లెక్కించే మార్గం కింది ఉదాహరణలో చూపబడింది. కోడ్‌లో 10 పూర్ణాంక సంఖ్యల వెక్టర్ ప్రకటించబడింది. వెక్టర్ యొక్క విలువలను ముద్రించడానికి మొదటి 'ఫర్' లూప్ ఉపయోగించబడింది మరియు వెక్టర్ యొక్క అన్ని విలువల మొత్తాన్ని లెక్కించడానికి రెండవ 'ఫర్' లూప్ ఉపయోగించబడింది. తరువాత, సమ్మషన్ ఫలితం ముద్రించబడింది.
// అవసరమైన మాడ్యూల్‌లను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// పూర్ణాంక సంఖ్యల వెక్టర్‌ని ప్రకటించండి
వెక్టోరింట్{7, 4, 9, 2, 1, 0, 8, 3, 5, 6};
// ఒక పూర్ణాంక వేరియబుల్‌ను ప్రారంభించండి
intమొత్తం= 0;
// వెక్టర్ విలువలను ముద్రించండి
ఖరీదు<< వెక్టర్ విలువలు: n';
కోసం (inti=0;i<intVector.పరిమాణం();i++)
ఖరీదు<< '' <<intVector.వద్ద(i);
ఖరీదు<< ' n';
// వెక్టర్ విలువల మొత్తాన్ని లెక్కించండి
కోసం (inti=0;i<intVector.పరిమాణం();i++)
మొత్తం+ =intVector.వద్ద(i);
// మొత్తం విలువను ముద్రించండి
ఖరీదు<< 'అన్ని వెక్టర్ విలువల మొత్తం:' <<మొత్తం<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. అవుట్‌పుట్‌లో ముద్రించిన అన్ని విలువలు (7 + 4 + 9 + 2 + 1 + 0 + 8 +3 +5 + 6) మొత్తం 45.
ఉదాహరణ -3: వెక్టర్‌లో నిర్దిష్ట విలువను శోధించండి
వద్ద () ఫంక్షన్ ఉపయోగించి వెక్టర్‌లో నిర్దిష్ట విలువను శోధించే మార్గం కింది ఉదాహరణలో చూపబడింది. మునుపటి ఉదాహరణ వలె కోడ్‌లో 10 పూర్ణాంక సంఖ్యల వెక్టర్ ఉపయోగించబడింది. వెక్టర్ యొక్క విలువలు ‘for’ లూప్ మరియు () ఫంక్షన్ ఉపయోగించి ప్రింట్ చేయబడ్డాయి.
శోధన విలువ వినియోగదారు నుండి తీసుకోబడుతుంది. వెక్టర్‌లోకి ఇన్‌పుట్ విలువను శోధించడానికి మరియు వేరియబుల్ విలువను సెట్ చేయడానికి మరొక 'ఫర్' లూప్ ఉపయోగించబడింది, కనుగొన్నారు ఉండాలి నిజం వెక్టర్‌లో ఇన్‌పుట్ విలువ ఉంటే.
// అవసరమైన మాడ్యూల్‌లను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// పూర్ణాంక సంఖ్యల వెక్టర్‌ని ప్రకటించండి
వెక్టోరింట్{7, 4, 9, 2, 1, 0, 8, 3, 5, 6};
// ఒక పూర్ణాంక వేరియబుల్‌ను ప్రారంభించండి
బూల్ కనుగొనబడింది= తప్పుడు;
intసంఖ్య;
// వెక్టర్ విలువలను ముద్రించండి
ఖరీదు<< వెక్టర్ విలువలు: n';
కోసం (inti=0;i<intVector.పరిమాణం();i++)
ఖరీదు<< '' <<intVector.వద్ద(i);
ఖరీదు<< ' n';
// శోధించడానికి ఒక నంబర్ తీసుకోండి
ఖరీదుసంఖ్య;
// లూప్ ఉపయోగించి నంబర్‌ను వెక్టర్‌లోకి శోధించండి
కోసం (inti=0;i<intVector.పరిమాణం();i++)
{
ఉంటే(intVector.వద్ద(i) ==సంఖ్య)
{
కనుగొన్నారు= నిజం;
విరామం;
}
}
// శోధన ఫలితం ఆధారంగా సందేశాన్ని ముద్రించండి
ఉంటే(కనుగొన్నారు== నిజం)
ఖరీదు<< 'నంబర్ కనుగొనబడింది. n';
లేకపోతే
ఖరీదు<< 'నంబర్ దొరకలేదు. n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టర్‌లో విలువ 2 ఉంది, మరియు సందేశం, సంఖ్య కనుగొనబడింది ముద్రించబడింది.
వెక్టర్ మరియు సందేశంలో విలువ 11 లేదు, సంఖ్య కనుగొనబడలేదు ముద్రించబడింది.
ఉదాహరణ -4: వెక్టర్‌లోని పరిస్థితుల ఆధారంగా శోధన విలువ
5 మరియు 3 ద్వారా భాగించబడే వెక్టర్ నుండి ఆ విలువలను తెలుసుకోవడానికి మార్గం క్రింది ఉదాహరణలో చూపబడింది. ఐదు పూర్ణాంక విలువలు వినియోగదారు నుండి తీసుకోబడతాయి మరియు పుష్_బ్యాక్ () ఫంక్షన్ ఉపయోగించి ఖాళీ వెక్టర్‌లోకి చేర్చబడతాయి. చొప్పించిన తర్వాత, వెక్టర్ యొక్క ప్రతి విలువ 3 మరియు 5 ద్వారా విభజించబడుతుంది. రెండు విభాగాల యొక్క మిగిలిన విలువలు సున్నా అయితే, ఆ వెక్టర్ విలువ ముద్రించబడుతుంది.
#చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// ఖాళీ వెక్టర్‌ని ప్రకటించండి
వెక్టోరింట్;
// ఒక పూర్ణాంక సంఖ్యను ప్రకటించండి
intసంఖ్య;
కోసం (inti=0;i<5;i++)
{
// చొప్పించడానికి ఒక నంబర్ తీసుకోండి
ఖరీదుసంఖ్య;
// సంఖ్యను చొప్పించండి
intVector.వెనుకకు నెట్టడం(సంఖ్య);
}
/ *
విభజించదగిన సంఖ్యలను ముద్రించండి
5 మరియు 3 ద్వారా
* /
ఖరీదు<< '5 మరియు 3 ద్వారా విభజించబడిన సంఖ్యలు: n';
కోసం (inti=0;i<intVector.పరిమాణం();i++) {
ఉంటే(intVector.వద్ద(i) % 5 ==0 &&intVector.వద్ద(i) %3 == 0)
ఖరీదు<<intVector.వద్ద(i) << '';
}
ఖరీదు<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
ఇన్‌పుట్ విలువలు, 5, 9, 15, 8, మరియు 45 కోసం పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ, 15 మరియు 45 లను 3 మరియు 5 ద్వారా భాగించవచ్చు.
ముగింపు:
C ++ వెక్టర్‌లో at () ఫంక్షన్ యొక్క వివిధ ఉపయోగాలు బహుళ ఉదాహరణలను ఉపయోగించి ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి. వద్ద () ఫంక్షన్ స్ట్రింగ్ డేటా రకం కోసం కూడా ఉపయోగించవచ్చు. ఈ ట్యుటోరియల్ చదివిన తర్వాత రీడర్ వివిధ ప్రయోజనాల కోసం వెక్టర్‌లో ఈ ఫంక్షన్‌ను ఉపయోగించగలరని నేను ఆశిస్తున్నాను.