కొత్తదాన్ని ఉపయోగించి C++లో 2D శ్రేణిని ఎలా ప్రకటించాలో మీకు తెలియకపోతే ఈ కథనం యొక్క మార్గదర్శకాలను అనుసరించండి.
C++లో కొత్తది ఉపయోగించి 2D అర్రే డిక్లరేషన్
కొత్తదాన్ని ఉపయోగించి C++లో 2D శ్రేణిని ప్రకటించే ముందు, ముందుగా మీరు శ్రేణిని ఎలా సృష్టించాలో తెలుసుకోవాలి. 2D శ్రేణిని సృష్టించడానికి సాధారణ వాక్యనిర్మాణం క్రింద ఇవ్వబడింది:
డేటాటైప్ arr_name [ మొత్తం - అంశాలు - యొక్క - వరుసలు ] [ మొత్తం - అంశాలు - యొక్క - కాలమ్ ] ;
పై సింటాక్స్‌లో, మీరు శ్రేణిలో నిల్వ చేయాలనుకుంటున్న డేటా రకాన్ని తప్పనిసరిగా నిర్వచించాలి. శ్రేణి యొక్క డేటా రకాన్ని తెలుసుకోవడం చాలా తప్పనిసరి, తద్వారా కంపైలర్ దానిని సులభంగా కంపైల్ చేయవచ్చు. ఇంకా, మీరు దాని స్థానంలో శ్రేణి పేరును కూడా అందించాలి అర్_పేరు శ్రేణిలోని అడ్డు వరుసలు మరియు నిలువు వరుసల సంఖ్య తర్వాత.
మీరు C++లో పూర్ణాంక-రకం డేటా శ్రేణిని ప్రకటించాలనుకుంటే, మీరు తప్పనిసరిగా క్రింది కోడ్‌ను జోడించాలి:
int అమరిక [ 2 ] [ 3 ]
ఈ విధంగా మీరు C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో 2D శ్రేణిని సృష్టిస్తారు.
కొత్త ఏముంది
C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో, C++ ప్రోగ్రామ్‌లో 2D శ్రేణిని సులభంగా ప్రకటించడానికి కొత్త ఆపరేటర్ మిమ్మల్ని అనుమతిస్తుంది. ట్రాష్ నుండి మెమరీని పొందేందుకు కొత్త కీవర్డ్ ఉపయోగించబడుతుంది. తగినంత మెమరీ ఉంటే, రన్‌టైమ్‌లో కొత్త ఉదాహరణ లేదా వేరియబుల్ ఉత్పత్తి చేయబడుతుంది.
మీరు కింది వాక్యనిర్మాణం ద్వారా కొత్తదాన్ని ఉపయోగించి C++లో 2D శ్రేణిని ప్రకటించవచ్చు:
సమాచార తరహా * శ్రేణి_పేరు = కొత్త < సమాచార తరహా > [ వరుస పరిమాణం ] [ కాలమ్ పరిమాణం ] ;
కొత్తదాన్ని ఉపయోగించి C++లో 2D శ్రేణిని డిక్లేర్ చేయడానికి ఒక సాధారణ ఉదాహరణను అనుసరించండి:
## x 4ని నిర్వచించండి
#నిర్వచించండి మరియు 5
int ప్రధాన ( )
{
int * అమరిక = కొత్త int [ x * మరియు ] ;
కోసం ( int i = 0 ; i < x ; i ++ )
{
కోసం ( int జె = 0 ; జె < మరియు ; జె ++ ) {
* ( అమరిక + i * మరియు + జె ) = రాండ్ ( ) % 10 ;
}
}
కోసం ( int i = 0 ; i < x ; i ++ )
{
కోసం ( int జె = 0 ; జె < మరియు ; జె ++ ) {
std :: కోట్ << * ( అమరిక + i * మరియు + జె ) << '' ;
}
std :: కోట్ << std :: endl ;
}
తొలగించు [ ] అమరిక ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము శ్రేణి పరిమాణాన్ని ప్రకటిస్తాము మరియు ఉపయోగించి 2D శ్రేణిని డైనమిక్‌గా కేటాయిస్తాము కొత్త . ఆ తర్వాత, మేము శ్రేణిని మూలకాలతో నింపి, ఆపై కౌట్ ఉపయోగించి శ్రేణి మూలకాలను ఒక్కొక్కటిగా ముద్రిస్తాము. చివరికి, మేము డిలీట్ ఉపయోగించి మెమరీని క్లియర్ చేస్తాము.
పైన C++ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ క్రింద ఉంది.
ముగింపు
C++ కొత్త ఆపరేటర్ యొక్క కార్యాచరణను అందిస్తుంది, ఇది డెవలపర్‌కు మెమరీని డైనమిక్‌గా యాక్సెస్ చేయడానికి సహాయపడుతుంది. మీరు ఉపయోగించవచ్చు కొత్త C++ ప్రోగ్రామ్‌లో 2D శ్రేణిని ప్రకటించడానికి. మీ C++ ప్రోగ్రామ్‌లో దాన్ని ఎలా ఉపయోగించాలో తెలుసుకోవడానికి పైన పేర్కొన్న మార్గదర్శకాలలో C++లో 2D శ్రేణిని ప్రకటించడానికి ఒక సాధారణ ఉదాహరణ అందించబడింది.