వాక్యనిర్మాణం:
రెండు డైమెన్షనల్ వెక్టర్ యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
వెక్టర్<వెక్టర్<సమాచార తరహా>>వెక్టర్_పేరు;
వెక్టర్ డిక్లరేషన్ సమయంలో ఒక నిర్దిష్ట డేటా రకం నిర్వచించబడింది. వెక్టర్ పరిమాణం నిర్వచించబడకపోతే వెక్టర్‌ను ఖాళీ వెక్టర్ అంటారు. వెక్టర్ పరిమాణాన్ని వివిధ పద్ధతులను ఉపయోగించి లేదా వెక్టర్‌ను ప్రారంభించడం ద్వారా మార్చవచ్చు.
ఉదాహరణ -1: సమాన సంఖ్యలో నిలువు వరుసల 2-డైమెన్షనల్ వెక్టర్‌ను సృష్టించండి
కింది ఉదాహరణ అక్షరాల డేటాను కలిగి ఉన్న మూడు వరుసలు మరియు నాలుగు నిలువు వరుసల 2 డైమెన్షనల్ వెక్టర్‌ని ప్రకటించే మార్గాన్ని చూపుతుంది. ఇక్కడ, వెక్టర్ డిక్లరేషన్ మరియు నెస్టెడ్ సమయంలో వెక్టర్ విలువలు నిర్వచించబడ్డాయి ' కోసం 'వెక్టర్ విలువలను ముద్రించడానికి లూప్ ఉపయోగించబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి
#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
/ *
రెండు డైమెన్షనల్ వెక్టర్‌ని ప్రకటించండి
పాత్రల
* /
వెక్టర్<వెక్టర్>chrVector
{{'కు', 'b', 'సి', 'd'}, {'మరియు', 'f', 'g', 'h'}, {'నేను', 'j', 'కు', 'ది'}};
// వెక్టర్ విలువలను ముద్రించండి
ఖరీదు<< 'వెక్టర్ విలువలు: n';
కోసం (inti= 0;i<chrVector.పరిమాణం();i++)
{
కోసం (intజ= 0;జ<chrVector[i].పరిమాణం();జ++)
ఖరీదు<<chrVector[i][జ] << '';
ఖరీదు<< ' n';
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఉదాహరణ -2: విభిన్న సంఖ్యలో నిలువు వరుసలతో 2-డైమెన్షనల్ వెక్టర్‌ను సృష్టించండి
కింది ఉదాహరణ నాలుగు వరుసల యొక్క 2-డైమెన్షనల్ వెక్టర్‌ను ప్రకటించే మార్గాన్ని చూపుతుంది, ఇక్కడ మొదటి వరుసలో ఒక కాలమ్ ఉంటుంది, రెండవ వరుసలో రెండు నిలువు వరుసలు, మూడవ వరుసలో మూడు నిలువు వరుసలు మరియు నాల్గవ వరుసలో నాలుగు నిలువు వరుసలు ఉంటాయి. వెక్టర్ పూర్ణాంక డేటాతో ప్రారంభించబడింది మరియు నెస్టెడ్ 'ఉపయోగించి ప్రింట్ చేయబడింది కోసం లూప్.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
/ *
తో 2D వెక్టర్‌ని ప్రారంభించండి
పూర్ణ సంఖ్య, ఇక్కడ ప్రతి అడ్డు వరుస విభిన్నంగా ఉంటుంది
అంశాల సంఖ్య
* /
వెక్టర్<వెక్టర్>intVector
{{ఇరవై}, {10, 30}, {యాభై, 40, 60 }, {80, 10, 70, 90 }};
// లూప్ కోసం ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
ఖరీదు<< 'వెక్టర్ విలువలు: n';
కోసం (వెక్టోరో:intVector)
{
కోసం (intగంటలు:వరుస)
ఖరీదు<<గంటలు<< '';
ఖరీదు<< ' n';
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఉదాహరణ -3: డిఫాల్ట్ విలువతో 2-డైమెన్షనల్ ఖాళీ వెక్టర్‌ని ప్రారంభించండి
ఫ్లోట్ నంబర్ యొక్క 2 డైమెన్షనల్ ఖాళీ వెక్టర్‌ను ప్రకటించడానికి మరియు ఫ్లోటర్ నంబర్‌తో వెక్టర్‌ను ప్రారంభించడానికి మార్గం క్రింది ఉదాహరణలో చూపబడింది. ఇక్కడ, వెస్టర్‌లోకి డేటాను ఇన్సర్ట్ చేయడానికి గూడులో ఉన్న ‘ఫర్’ లూప్ ఉపయోగించబడింది పుష్_బ్యాక్ () ఫంక్షన్ మరియు వెక్టర్ విలువలను ముద్రించండి.
డిఫాల్ట్ విలువ, 6.5 2 వరుసలు మరియు 3 నిలువు వరుసలను సృష్టించడం ద్వారా వెక్టర్‌లోకి చేర్చబడింది. ది పరిమాణం () వెక్టర్ విలువలను ముద్రించడానికి మొత్తం వరుసలు మరియు నిలువు వరుసలను లెక్కించడానికి ఫంక్షన్ ఉపయోగించబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// డిఫాల్ట్ విలువను సెట్ చేయండి
తేలుతాయిడిఫాల్ట్_వాల్యూ= 6.5;
// బయటి వెక్టర్‌ను నిర్వచించండి
వెక్టర్<వెక్టర్>వెలుపలి;
కోసం (inti= 0;i< 2;i++)
{
// లోపలి వెక్టర్‌ను నిర్వచించండి
వెక్టర్ ఇన్ వెక్ట్;
కోసం (intజ= 0;జ< 3;జ++) {
// డిఫాల్ట్ విలువను చొప్పించండి
inVect.వెనుకకు నెట్టడం(డిఫాల్ట్_వాల్యూ);
}
// బయటి వెక్టర్‌కి లోపలి వెక్టర్‌ని చొప్పించండి
వెలుపలి.వెనుకకు నెట్టడం(inVect);
}
// వెక్టర్ విలువలను ముద్రించండి
ఖరీదు<< 'వెక్టర్ విలువలు: n';
కోసం (inti= 0;i<వెలుపలి.పరిమాణం();i++)
{
కోసం (intజ= 0;జ<వెలుపలి[i].పరిమాణం();జ++)
ఖరీదు<<వెలుపలి[i][జ] << '';
ఖరీదు<< ' n';
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. డిఫాల్ట్ విలువ మరియు కోడ్ ద్వారా సృష్టించబడిన అడ్డు వరుసలు మరియు నిలువు వరుసల ఆధారంగా వెక్టర్ కంటెంట్‌ని అవుట్‌పుట్ చూపుతుంది.
ఉదాహరణ -4: ఇన్‌పుట్ విలువలను తీసుకోవడం ద్వారా 2-డైమెన్షనల్ ఖాళీ వెక్టర్‌ను ప్రారంభించండి
వినియోగదారు నుండి ఇన్‌పుట్ తీసుకోవడం ద్వారా 2 డైమెన్షనల్ వెక్టర్‌ను సృష్టించే మార్గం కింది ఉదాహరణలో చూపబడింది. ఒక పూర్ణాంకం యొక్క 2-డైమెన్షనల్ ఖాళీ వెక్టర్ 2 వరుసలు మరియు 3 నిలువు వరుసలను కలిగి ఉన్న కోడ్‌లో ప్రకటించబడింది.
గూడు కట్టుకున్న ' కోసం వినియోగదారు నుండి 6 (2 × 3) పూర్ణాంక సంఖ్యలను తీసుకొని వాటిని సూచిక విలువలను ఉపయోగించి వెక్టర్‌లోకి చొప్పించడానికి లూప్ ఉపయోగించబడింది. మరొక గూడు ' కోసం వెక్టర్ యొక్క చొప్పించిన విలువలను ముద్రించడానికి లూప్ ఉపయోగించబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intప్రధాన()
{
// కోల్స్ సంఖ్యను నిర్వచించండి
intతో= 3;
// అడ్డు వరుసల సంఖ్యను నిర్వచించండి
intవరుస= 2;
// ఒక పూర్ణాంక వేరియబుల్‌ను ప్రారంభించండి
intగంటలు= 0;
// ఖాళీ వెక్టర్‌ను ప్రారంభించండి
వెక్టర్<వెక్టర్>int2D వెక్టర్;
// బయటి వెక్టర్ పరిమాణాన్ని మార్చండి
int2D వెక్టర్.పరిమాణం మార్చండి(వరుస);
కోసం (inti= 0;i<వరుస;i++)
{
// లోపలి వెక్టర్ పరిమాణాన్ని మార్చండి
int2D వెక్టర్[i].పరిమాణం మార్చండి(తో);
కోసం (intజ= 0;జ<తో;జ++)
{
// వినియోగదారు నుండి ఇన్‌పుట్ తీసుకోండి
ఖరీదుగంటలు;
// వెక్టర్‌లోకి చొప్పించండి
int2D వెక్టర్[i][జ] =గంటలు;
}
}
// వెక్టర్ విలువలను ముద్రించండి
ఖరీదు<< 'వెక్టర్ విలువలు: n';
కోసం (inti= 0;i<int2D వెక్టర్.పరిమాణం();i++)
{
కోసం (intజ= 0;జ<int2D వెక్టర్[i].పరిమాణం();జ++)
ఖరీదు<<int2D వెక్టర్[i][జ] << '';
ఖరీదు<< ' n';
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. అవుట్‌పుట్ వరుసలు మరియు నిలువు వరుసల సంఖ్య ఆధారంగా 6 ఇన్‌పుట్ విలువలు మరియు వెక్టర్ కంటెంట్‌ను చూపుతుంది.
ముగింపు
వరుసలు మరియు నిలువు వరుసల ఆధారంగా డేటాను నిల్వ చేయడానికి మరియు యాక్సెస్ చేయడానికి C ++ ప్రోగ్రామింగ్‌లో 2-డైమెన్షనల్ వెక్టర్ ఉపయోగించబడుతుంది. సాధారణ ఉదాహరణలను ఉపయోగించి 2-డైమెన్షనల్ వెక్టర్‌ను సృష్టించడానికి వివిధ మార్గాలు ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి. ఈ ట్యుటోరియల్ చదివిన తర్వాత C ++ లో 2-డైమెన్షనల్ వెక్టర్‌ను ఉపయోగించడం యొక్క ఉద్దేశ్యం క్లియర్ చేయబడుతుంది.