C++ ప్రోగ్రామింగ్ ఉత్తమ భాష, ఎందుకంటే ఇది విస్తృత శ్రేణి ఫంక్షన్‌లు, కన్స్ట్రక్టర్లు, హెడర్ ఫైల్‌లు, తరగతులు మరియు మరెన్నో మాకు సులభతరం చేస్తుంది, కోడింగ్‌ను మరింత ఆసక్తికరంగా మరియు సులభతరం చేస్తుంది. C++ ప్రోగ్రామింగ్‌లోని కన్‌స్ట్రక్టర్‌లలో ఒకటి “మూవ్” కన్స్ట్రక్టర్. 'తరలించు' కన్స్ట్రక్టర్ అనేది ఒక ప్రత్యేకమైన కన్స్ట్రక్టర్, ఇది డైనమిక్‌గా కేటాయించబడిన మెమరీ లేదా ఇతర వనరుల యాజమాన్యాన్ని ఒక వస్తువు నుండి మరొకదానికి సమర్థవంతమైన మరియు వనరుల-చేతన పద్ధతిలో బదిలీ చేయడానికి అనుమతిస్తుంది.
C++ ప్రోగ్రామింగ్‌లో, డూప్లికేషన్‌ను తగ్గించడానికి మరియు సామర్థ్యాన్ని పెంచడానికి “మూవ్” కన్స్ట్రక్టర్లు ప్రవేశపెట్టబడ్డాయి. కాపీ చేసే కార్యకలాపాలను తగ్గించడం ద్వారా పనితీరును మెరుగుపరచడంలో ఇది కీలక పాత్ర పోషిస్తుంది. ఈ గైడ్ C++ ప్రోగ్రామింగ్‌లోని “మూవ్” కన్స్ట్రక్టర్ గురించి లోతుగా అన్వేషిస్తుంది.
ఉదాహరణ 1:
ఇక్కడ కోడ్‌ను ప్రారంభించడానికి, మేము 'iostream' మరియు 'string' హెడర్ ఫైల్‌లను చేర్చుతాము, ఈ హెడర్ ఫైల్‌లలో అనేక విధులు ప్రకటించబడినందున మా కోడ్‌ని ఖచ్చితంగా అమలు చేసేలా చేస్తుంది. మనం “కౌట్” స్టేట్‌మెంట్‌ను ఉపయోగించాల్సి వచ్చినప్పుడు, ఈ ఫంక్షన్‌లో ఈ ఫంక్షన్ ప్రకటించబడినందున “iostream” హెడర్ ఫైల్ ఉపయోగించబడుతుంది. మేము స్ట్రింగ్ రకం డేటాతో పని చేయవలసి వచ్చినప్పుడు, 'స్ట్రింగ్' హెడర్ ఫైల్ అవసరం.
దీని తర్వాత, ఈ హెడర్ ఫైల్‌ల క్రింద “నేమ్‌స్పేస్ std” జోడించబడుతుంది. అప్పుడు, మేము ఇక్కడ ఒక తరగతిని నిర్మిస్తాము. తరగతి పేరు 'తరలించు'. దీని క్రింద, “ప్రైవేట్” కీవర్డ్ జోడించబడింది, దీనిలో మేము “my_str” పేరుతో ప్రైవేట్ స్ట్రింగ్ వేరియబుల్‌ని ప్రకటిస్తాము. ఇప్పుడు, మేము డిఫాల్ట్ కన్స్ట్రక్టర్ యొక్క నిర్వచనాన్ని జోడించే 'పబ్లిక్' కీవర్డ్‌ను ఉంచుతాము. మేము “ఇది ఇక్కడ డిఫాల్ట్ స్ట్రింగ్” అని “my_str”కి పారామీటర్‌గా పాస్ చేసి, డిఫాల్ట్ కన్స్ట్రక్టర్ను ఖాళీగా ఉంచుతాము.
దీని తర్వాత, మేము కన్స్ట్రక్టర్ డెఫినిషన్‌ను కాపీ చేసి, “my_str”ని “my_obj.my_str”కి ప్రారంభిస్తాము. దీని క్రింద, మేము ఒక పంక్తిని ప్రింట్ చేసి, ఆపై 'తరలించు' కన్స్ట్రక్టర్ యొక్క నిర్వచనాన్ని ఉంచుతాము. ఇక్కడ, మేము 'my_obj.my_str'తో మళ్లీ 'my_str'ని ప్రారంభిస్తాము. మేము దీని క్రింద ఎటువంటి ప్రకటనను జోడించము; అది ఖాళీగా ఉంది. దీని తర్వాత, మేము స్ట్రింగ్ రకానికి చెందిన “displayMyObject()” పేరుతో ఒక ఫంక్షన్‌ను ప్రకటిస్తాము మరియు “రిటర్న్ str”ని ఉపయోగిస్తాము కాబట్టి అది స్ట్రింగ్‌ను తిరిగి ఇస్తుంది.
మేము గ్లోబల్ “new_temp” ఫంక్షన్‌ను “తరలించు” రకంలో ఉంచుతాము. దాని క్రింద, మూవ్ టైప్ ఆబ్జెక్ట్‌ను తిరిగి ఇచ్చే “రిటర్న్ టెంప్” మనకు ఉంది. ఇప్పుడు, మేము 'move' రకం యొక్క 'main()' డ్రైవర్ కోడ్ మరియు 'new_obj1'ని ఉంచాము మరియు 'rvalue' నుండి 'move' కన్స్ట్రక్టర్ను పొందుతాము. ముందు వరుసలో, 'lvalue' నుండి 'move' కన్స్ట్రక్టర్ను పొందడానికి మేము 'new_obj1.displayMyObject()'ని ఉంచుతాము. దీని తరువాత, మేము 'my_obj1' ఆబ్జెక్ట్‌తో 'తరలించు' కన్స్ట్రక్టర్‌ని పిలుస్తాము. అప్పుడు, మేము 'my_obj1' యాజమాన్యాన్ని 'my_obj2' అయిన ఇతర వస్తువుకు బదిలీ చేస్తాము.
కోడ్ 1:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి కదలిక
{
ప్రైవేట్ :
స్ట్రింగ్ my_str ;
ప్రజా :
కదలిక ( ) : నా_str ( 'ఇది ఇక్కడ డిఫాల్ట్ స్ట్రింగ్' )
{
}
కదలిక ( స్థిరంగా కదలిక & నా_వస్తువు ) : నా_str ( నా_వస్తువు. నా_str )
{
కోట్ << 'కాపీ కన్స్ట్రక్టర్ ప్రారంభించబడింది, తరలింపు విఫలమైంది! \n ' ;
}
కదలిక ( కదలిక && నా_వస్తువు ) : నా_str ( కదలిక ( నా_వస్తువు. నా_str ) )
{
}
స్ట్రింగ్ displayMyObject ( )
{
తిరిగి నా_str ;
}
} ;
కొత్త_టెంప్‌ని తరలించండి ( tmpని తరలించండి )
{
తిరిగి tmp ;
}
int ప్రధాన ( )
{
new_obj1ని తరలించండి = కొత్త_టెంప్ ( కదలిక ( ) ) ;
కోట్ << 'తరలించడానికి () కాల్ చేయడానికి ముందు: new_obj1 = ' << కొత్త_obj1. ప్రదర్శన MyObject ( ) << endl ;
new_obj2ని తరలించండి = కదలిక ( కొత్త_obj1 ) ;
కోట్ << 'తరలింపు() కన్స్ట్రక్టర్ కాల్ తర్వాత: new_obj1 = ' << కొత్త_obj1. ప్రదర్శన MyObject ( ) << endl ;
కోట్ << 'తరలింపు() కన్స్ట్రక్టర్ కాల్ తర్వాత: new_obj2 = ' << కొత్త_obj2. ప్రదర్శన MyObject ( ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
అవుట్‌పుట్ “move()” పద్ధతిని కాల్ చేయడానికి ముందు, “new_obj1” డిఫాల్ట్ స్ట్రింగ్‌ని కలిగి ఉందని రెండర్ చేస్తుంది. కానీ “Move” class move() మెథడ్‌కి కాల్ చేసిన తర్వాత, “my_obj1” ఖాళీ స్ట్రింగ్‌ని కలిగి ఉంటుంది మరియు “my_obj2”లో డిఫాల్ట్ స్ట్రింగ్ ఉంటుంది.
ఉదాహరణ 2:
ఇక్కడ, మేము 'వెక్టర్' హెడర్ ఫైల్ అయిన మరో హెడర్ ఫైల్‌ని చేర్చాము. మేము వెక్టర్స్‌పై ఆపరేషన్‌లను మార్చవలసి వచ్చినప్పుడల్లా మేము దీన్ని చేర్చుతాము. మేము ఇక్కడ సృష్టించే తరగతి 'తరలించు' తరగతి. మేము ఇక్కడ 'పబ్లిక్' కన్స్ట్రక్టర్ను కూడా సృష్టిస్తాము, దీనిలో మేము 'int* విలువ' ముడి పాయింటర్‌ని తరగతి సభ్యుల డేటాగా ప్రకటిస్తాము. దాని క్రింద, మనకు 'పబ్లిక్' ఉంది, దీనిలో మనం 'మూవ్' కన్స్ట్రక్టర్‌ని ఉంచాము మరియు దాని పరామితిగా 'int v1'ని పాస్ చేస్తాము.
దీని తరువాత, మేము వస్తువులను కుప్పగా ప్రకటిస్తాము. మేము 'విలువ'ను 'కొత్త పూర్ణాంకంతో' మరియు '* విలువ'ని 'v1'తో ప్రారంభిస్తాము. అప్పుడు, 'కౌట్' ను ఉంచండి, అక్కడ మేము కోడ్‌ను అమలు చేసినప్పుడు ముద్రించే పంక్తిని జోడించండి. దీని క్రింద, మేము 'కాపీ' కన్స్ట్రక్టర్‌ని ఉపయోగిస్తాము. ఈ 'కాపీ' కన్స్ట్రక్టర్ లోతైన కాపీని చేయడం ద్వారా డేటాను కాపీ చేస్తుంది. మేము 'తరలించు' కన్స్ట్రక్టర్‌ని ఉంచుతాము మరియు దాని పరామితిగా 'Move&& new_source'ని పాస్ చేస్తాము. దాని క్రింద, మేము అవసరమైన స్టేట్‌మెంట్‌ను ప్రదర్శించడంలో సహాయపడే “కౌట్”ని ఉంచుతాము.
సూచనను ఉపయోగించకముందే పాయింటర్ ఖాళీగా ఉందో లేదో తెలుసుకోవడానికి మేము “nullptr” కీవర్డ్‌ని ఇన్సర్ట్ చేస్తాము. ఇప్పుడు, మనం “~Move()” డిస్ట్రక్టర్‌ని కూడా ఉంచుతాము, దీనిలో “value” “nullptr”కి సమానం కాదా అని ధృవీకరించే “if” కండిషన్‌ను ఉంచుతాము. ఈ షరతు ధృవీకరించబడినప్పుడు, దీని క్రింద ఉన్న ప్రకటన అమలు చేయబడుతుంది. ఈ షరతు ధృవీకరించబడకపోతే, అది 'if' కండిషన్ తర్వాత ఉన్న 'కౌట్' స్టేట్‌మెంట్‌ను దాటవేసి, 'వేరే' భాగం వైపు కదులుతుంది.
దీని తర్వాత, మేము ఆబ్జెక్ట్‌ను డీలాకేట్ చేయడంలో సహాయపడే “తొలగించు” కీవర్డ్‌ని ఉపయోగిస్తాము లేదా ఆబ్జెక్ట్ డేటా కాంపోనెంట్‌కు కేటాయించిన మెమరీని విడుదల చేస్తుందని మేము చెప్పగలం. ఇప్పుడు, మేము ఇక్కడ “ప్రధాన()” పద్ధతిని అమలు చేస్తాము మరియు “my_vec” పేరుతో మా “మూవ్” క్లాస్ యొక్క వెక్టర్‌ని సృష్టిస్తాము. దీని తరువాత, మేము వెక్టార్ యొక్క ముగింపు బిందువు వద్ద విలువను చొప్పించడానికి సహాయపడే “పుష్_బ్యాక్()” ఫంక్షన్‌ని ఉపయోగిస్తాము. 'వెక్టర్' హెడర్ ఫైల్ ఈ ఫంక్షన్‌ను కలిగి ఉంది. మొదట, మేము వెక్టర్‌లోకి '39' ఇన్సర్ట్ చేస్తాము. అప్పుడు, “57” చొప్పించబడింది మరియు “push_back()” పద్ధతిని ఉపయోగించడం ద్వారా “91” కూడా చొప్పించబడుతుంది.
కోడ్ 2:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి కదలిక {
ప్రైవేట్ :
int * విలువ ;
ప్రజా :
కదలిక ( int v1 )
{
విలువ = కొత్త int ;
* విలువ = v1 ;
కోట్ << 'కన్స్ట్రక్టర్ అంటారు'
<< v1 << endl ;
} ;
కదలిక ( స్థిరంగా కదలిక & కొత్త_మూలం )
: కదలిక { * కొత్త_మూలం. విలువ }
{
కోట్ << 'కాపీ కన్స్ట్రక్టర్ అంటారు -'
<< 'దీనికి డీప్ కాపీ'
<< * కొత్త_మూలం. విలువ
<< endl ;
}
కదలిక ( కదలిక && కొత్త_మూలం )
: విలువ { కొత్త_మూలం. విలువ }
{
కోట్ << 'కోసం కన్స్ట్రక్టర్‌ని తరలించు'
<< * కొత్త_మూలం. విలువ << endl ;
కొత్త_మూలం. విలువ = nullptr ;
}
~ తరలించు ( )
{
ఉంటే ( విలువ ! = nullptr )
కోట్ << 'డిస్ట్రక్టర్ అంటారు'
<< * విలువ << endl ;
లేకపోతే
కోట్ << 'డిస్ట్రక్టర్ అంటారు'
<< 'nullptr కోసం'
<< endl ;
తొలగించు విలువ ;
}
} ;
int ప్రధాన ( )
{
వెక్టర్ < కదలిక > నా_విషయం ;
నా_విషయం. వెనుకకు నెట్టడం ( కదలిక { 39 } ) ;
నా_విషయం. వెనుకకు నెట్టడం ( కదలిక { 57 } ) ;
నా_విషయం. వెనుకకు నెట్టడం ( కదలిక { 91 } ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“కాపీ” ఫంక్షన్‌ని ఉపయోగించకుండా, “కాపీ” ఫంక్షన్‌కు అనవసరమైన కాల్‌ను నిరోధించడానికి మనం “తరలించు” ఫంక్షన్‌ని ఉపయోగించాలని ఇది చూపిస్తుంది. మేము తాత్కాలిక వస్తువుతో లేదా నాశనం చేయబడే ఏదైనా వస్తువుతో ఆబ్జెక్ట్‌ను ప్రారంభించినప్పుడు 'తరలించు' కన్స్ట్రక్టర్ ఇక్కడ ప్రారంభించబడుతుంది. ఇచ్చిన డేటా యొక్క లోతైన కాపీని మార్చటానికి బదులుగా, 'తరలించు' కన్స్ట్రక్టర్ వనరుల యాజమాన్యాన్ని ఒక వస్తువు నుండి మరొకదానికి మారుస్తుంది.
ముగింపు
ఈ గైడ్‌లో, మేము 'తరలించు' కన్స్ట్రక్టర్ గురించి అన్వేషించాము. C++ ప్రోగ్రామింగ్‌లోని “తరలించు” కన్స్ట్రక్టర్ అనేది ఒక వస్తువు యొక్క వనరులను ప్రభావవంతంగా మరొక వస్తువుకు మార్చడానికి ఒక ప్రత్యేక పద్ధతి అని మేము వివరించాము. 'మూవ్' కన్స్ట్రక్టర్‌కు కాల్ చేయడం తక్కువ ఓవర్‌హెడ్‌ని కలిగి ఉందని, కోడ్ మరింత మెమరీ-సమర్థవంతంగా ఉంటుందని మేము చర్చించాము. C++ ప్రోగ్రామింగ్‌లో “తరలించు” కన్స్ట్రక్టర్ శక్తివంతమైన ఫీచర్ అనే వాస్తవాన్ని మేము అన్వేషించాము. మేము 'తరలించు' కన్స్ట్రక్టర్ యొక్క భావనను వివరించడానికి ఆచరణాత్మక ఉదాహరణలను కూడా ఉపయోగించాము మరియు C++ ప్రోగ్రామింగ్‌లో 'తరలించు' కన్స్ట్రక్టర్ను ఉపయోగించడం యొక్క పనితీరు ప్రయోజనాలను ప్రదర్శించాము.