C++లో స్ట్రక్చర్డ్ బైండింగ్ అంటే ఏమిటి?
స్ట్రక్చర్ బైండింగ్ అనేది C++ ఫీచర్, ఇది C++17లో జోడించబడింది, ఇది ఒక స్ట్రక్ట్ లేదా టుపుల్‌ని వ్యక్తిగత వేరియబుల్స్‌గా కుళ్ళిపోయేలా అనుమతిస్తుంది, కోడ్ యొక్క సంక్షిప్తతను మెరుగుపరుస్తుంది. స్ట్రక్ట్ మెంబర్ యాక్సెస్ సింటాక్స్‌ని సులభతరం చేయడానికి మరియు అక్షరదోషాలు లేదా సరికాని ఇండెక్సింగ్ ద్వారా వచ్చే లోపాల సంభావ్యతను తగ్గించడానికి ఇది ఉపయోగించబడుతుంది.
వాక్యనిర్మాణం
C++లో స్ట్రక్చర్ బైండింగ్ యొక్క వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
దానంతట అదే [ var1 , var2 , ... ] = వ్యక్తీకరణ ;
C++లో స్ట్రక్చర్ బైండింగ్ కోసం సింటాక్స్‌లో, ఇక్కడ “var1” మరియు “var2” వేరియబుల్ పేర్లు, మరియు “expression” అనేది struct లేదా classని అందించే వ్యక్తీకరణ. స్వయంచాలకంగా సృష్టించబడిన వేరియబుల్‌లను ప్రకటించడానికి మేము ఆటో కీవర్డ్‌లను ఉపయోగిస్తాము.
సవరించేవారు
నిర్మాణాత్మక బైండింగ్‌లతో జత చేయడంలో మాడిఫైయర్‌లను ఉపయోగించవచ్చు. వారి వాక్యనిర్మాణం క్రింద పేర్కొనబడింది:
దానంతట అదే & [ a , బి , సి , ... ] = వ్యక్తీకరణ ;
దానంతట అదే && [ a , బి , సి , ... ] = వ్యక్తీకరణ ;
డిక్లరేషన్‌లో ఉపయోగించిన “&” లేదా “&&” ఆపరేటర్ బైండింగ్ అనేది lvalue లేదా rvalue సూచన కాదా అని నిర్వచిస్తుంది. బైండింగ్ వేరియబుల్స్ యొక్క విలువలను మార్చడానికి ఉపయోగించబడే సూచనను '&' ద్వారా సూచించే ఒక lvalue సూచన ఏర్పాటు చేస్తుంది. సూచనను ఉపయోగించి చేసిన విలువలకు మార్పులు అసలు నిర్మాణం లేదా టుపుల్‌లో కనిపిస్తాయి.
'&&' ద్వారా సూచించబడిన rvalue సూచన, వ్యతిరేక వైపు, బైండింగ్‌లో చేర్చబడిన వేరియబుల్స్ యొక్క విలువను చదవడానికి ఉపయోగించబడే పరిమితమైన సూచనను అందిస్తుంది. ఇది ఆబ్జెక్ట్ యొక్క ప్రతిరూపాన్ని తయారు చేయడాన్ని నివారిస్తుంది కాబట్టి నాశనం చేయాల్సిన తాత్కాలిక వస్తువులు లేదా rvalueలకు బంధించడానికి ఇది ఉపయోగపడుతుంది, ఇది జ్ఞాపకశక్తి మరియు సమయం తీసుకుంటుంది.
ఉదాహరణ 1: C++లో స్ట్రక్చర్ బైండింగ్
కిందిది C++ స్ట్రక్చర్ బైండింగ్‌కి ఉదాహరణ:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
నిర్మాణం క్యూబ్
{
int x ;
int మరియు ;
int తో ;
} ;
int ప్రధాన ( )
{
c-క్యూబ్ = { 10 , ఇరవై , 30 } ;
దానంతట అదే [ x_coordinate , y_కోఆర్డినేట్ , z_coordinate ] = సి ;
కోట్ << 'X అక్షం :' << x_coordinate << endl ;
కోట్ << 'Y-యాక్సిస్ :' << y_కోఆర్డినేట్ << endl ;
కోట్ << 'Z అక్షం :' << z_coordinate << endl ;
తిరిగి 0 ;
}
పై ఉదాహరణలో, మేము x, y మరియు z అనే మూడు పూర్ణాంకాలతో ఒక స్ట్రక్ట్ క్యూబ్‌ని ప్రకటిస్తాము. నిర్మాణం అంతరిక్షంలో ఒక క్యూబ్‌ను చూపుతుంది. c టైప్ క్యూబ్ యొక్క వేరియబుల్ సృష్టించబడుతుంది మరియు విలువలతో ప్రారంభించబడుతుంది (10,20,30). ఈ కోడ్ స్ట్రక్చర్ బైండింగ్‌లో సింటాక్స్ ఆటో[ x_coordinate, y_coordinate, z_coordinate ] = c ఉపయోగించి వ్యక్తిగత వేరియబుల్స్ x_coordinate, y_coordinate, z_coordinate వరుసగా struct యొక్క సభ్యుల x, y మరియు z విలువలను కేటాయిస్తుంది. పై వాటి యొక్క అవుట్‌పుట్ క్రింద చూపబడింది:
ఉదాహరణ 2: నిర్మాణాన్ని అన్‌ప్యాక్ చేయడానికి C++లో స్ట్రక్చర్ బైండింగ్
స్ట్రక్ట్‌ను అన్‌ప్యాక్ చేయడంలో స్ట్రక్చర్ బైండింగ్‌కి ఉదాహరణ క్రిందిది:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
నిర్మాణం విద్యార్థి {
స్ట్రింగ్ పేరు ;
int వయస్సు ;
} ;
int ప్రధాన ( ) {
విద్యార్థి ఎస్ { 'హంజా' , 32 } ;
దానంతట అదే [ పేరు , వయస్సు ] = లు ;
కోట్ << పేరు << 'ఉంది' << వయస్సు << ' ఏళ్ళ వయసు.' << endl ;
తిరిగి 0 ;
}
పై కోడ్‌లో, విద్యార్థి నిర్మాణంలో ఇద్దరు సభ్యులు ఉంటారు: a పేరు అది ఒక స్ట్రింగ్ మరియు ఒక వయస్సు అది పూర్ణాంకం. అప్పుడు, మేము విద్యార్థి వస్తువును సృష్టించి, దానిలోని ప్రతి సభ్యులకు ప్రారంభ విలువలను కేటాయిస్తాము. s యొక్క సభ్యులు స్ట్రక్చరల్ బైండింగ్ ఉపయోగించి వేరియబుల్ పేరు మరియు వయస్సుతో వేరు చేయబడతారు మరియు ఈ విలువలు క్రింది స్క్రీన్‌షాట్‌లో ఉన్నట్లుగా ముద్రించబడతాయి:
ఉదాహరణ 3: మాడిఫైయర్‌లతో C++లో స్ట్రక్చర్ బైండింగ్
వేరియబుల్ విలువను num1 మరియు num2గా అప్‌డేట్ చేయడానికి మాడిఫైయర్‌ని ఉపయోగించే స్ట్రక్చర్ బైండింగ్ యొక్క ఉదాహరణ క్రింద ఉంది:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
టుపుల్ < int , int > t { 25 , ఇరవై } ;
దానంతట అదే & [ సంఖ్య1 , సంఖ్య2 ] = t ;
కోట్ << 'సంఖ్య1 విలువ =' << సంఖ్య1 << ', సంఖ్య2 = ' << సంఖ్య2 << ' \n ' ;
సంఖ్య1 = 30 ;
కోట్ << 'num1 యొక్క మారిన విలువ =' << సంఖ్య1 << ', సంఖ్య2 = ' << సంఖ్య2 <<
' \n ' ;
దానంతట అదే && [ సంఖ్య3 , సంఖ్య 4 ] = తయారు_టుపుల్ ( 100 , 250 ) ;
కోట్ << 'ఇప్పుడు num3 విలువ =' << సంఖ్య3 << ', సంఖ్య 4 = ' << సంఖ్య 4 << ' \n ' ;
తిరిగి 0 ;
}
మునుపటి కోడ్‌లో, మేము tuple tని నిర్మిస్తాము మరియు దాని భాగాలను num1 మరియు num2కి లింక్ చేయడానికి lvalue సూచనను ఉపయోగిస్తాము. మేము num1 విలువను 30కి మారుస్తాము మరియు num1 మరియు num2 విలువలను అవుట్‌పుట్ చేస్తాము. make_tuple(100, 250) ద్వారా తాత్కాలిక టుపుల్‌ని కూడా నిర్మించండి మరియు దాని మూలకాలను num3 మరియు num4కి కట్టడానికి rvalue సూచనను ఉపయోగించండి. num3 మరియు num4 విలువలు ప్రింట్ చేయబడతాయి ఎందుకంటే num3 మరియు num4 rvalue సూచనతో జతచేయబడతాయి, make_tuple(100, 250) ద్వారా ఏర్పడిన తాత్కాలిక టుపుల్‌ని మార్చడానికి వాటిని ఉపయోగించలేరు. వారు దాని నుండి మాత్రమే చదవగలరు. మీరు ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, కింది ఫలితం స్క్రీన్‌పై ప్రదర్శించబడుతుంది:
ముగింపు
స్ట్రక్చర్ బైండింగ్ అనేది C++లో ఒక లక్షణం, ఇది ఒక struct లేదా class యొక్క బహుళ విలువలను ఒకే వ్యక్తీకరణలో వ్యక్తిగత వేరియబుల్స్‌గా అన్‌ప్యాక్ చేస్తుంది, ఫలితంగా మరింత సంక్షిప్త, చదవగలిగే మరియు సురక్షితమైన కోడ్ వస్తుంది. మాడిఫైయర్‌లను ఉపయోగించి స్ట్రక్చర్ బైండింగ్ నిర్మాణాత్మక వస్తువులలో విలువలను మార్చే ప్రక్రియను క్రమబద్ధీకరిస్తుంది.