C++ ప్రోగ్రామింగ్‌లో, కోడ్ సౌలభ్యం మరియు సామర్థ్యాన్ని మెరుగుపరచడానికి మాక్రో ఫంక్షన్‌లు శక్తివంతమైన సాధనం. ఒక మాక్రో సోర్స్ కోడ్‌లో ప్లేస్‌హోల్డర్‌గా పనిచేస్తుంది, అసలు కంపైలింగ్ ప్రాసెస్‌కు ముందు దాని సంబంధిత విలువతో ప్రీప్రాసెసర్ ద్వారా భర్తీ చేస్తుంది. మాక్రోల ప్రారంభీకరణ #define కమాండ్ ఉపయోగించి చేయబడుతుంది మరియు #undef కమాండ్‌తో వాటిని తొలగించవచ్చు. ఈ మాక్రోలు డెవలపర్‌లకు పునర్వినియోగ కోడ్ స్నిప్పెట్‌లను నిర్వచించడానికి అధికారం ఇస్తాయి, పునరావృతమయ్యే పనులను సులభంగా క్రమబద్ధీకరిస్తాయి. ఈ కథనం స్థూల ఫంక్షన్‌ల వివరాలను, వాటి లక్షణాలు, వినియోగ సందర్భాలు మరియు సంభావ్య ప్రయోజనాలపై వెలుగునిస్తుంది.
మాక్రో ఫంక్షన్ అంటే ఏమిటి?
మాక్రో ఫంక్షన్ అనేది #define డైరెక్టివ్‌తో వ్రాయబడిన C++ కోడ్ యొక్క చిన్న, పునర్వినియోగ భాగం. మాక్రో ఒక పాఠ్య ప్రత్యామ్నాయ విధానం వలె పనిచేస్తుంది, ఇక్కడ కోడ్‌లో దాని పేరు ఏదైనా సంభవించినట్లయితే ప్రిప్రాసెసర్ దశలో దాని నిర్వచించిన కోడ్ బ్లాక్‌తో భర్తీ చేయబడుతుంది. స్థూల విధులు ప్రత్యేకించి పునరావృత పనులు, పారామీటర్ చేయబడిన ఆపరేషన్‌లు మరియు విభిన్న దృశ్యాలకు అనుగుణంగా ఉండే కోడ్‌ని నిర్వహించడానికి ప్రయోజనకరంగా ఉంటాయి.
మాక్రో ఫంక్షన్ యొక్క సింటాక్స్:
స్థూల ఫంక్షన్‌ని నిర్వచించే సింటాక్స్‌లో #define డైరెక్టివ్‌ని ఉపయోగించి స్థూల పేరు, పారామితి జాబితా (ఏదైనా ఉంటే) మరియు కోడ్ బ్లాక్ ఉంటుంది. ఇక్కడ ఒక ప్రాథమిక ఉదాహరణ:
# చతురస్రాన్ని నిర్వచించండి ( చ ) ( ( చ ) * ( చ ) )
ఈ ఉదాహరణలో, 'స్క్వేర్' అనేది ఒక స్థూల ఫంక్షన్, ఇది 'sq' అనే ఒకే పరామితిని తీసుకొని దాని స్క్వేర్‌ని గణిస్తుంది. డబుల్ కుండలీకరణాలు సరైన మూల్యాంకనాన్ని నిర్ధారిస్తాయి, ప్రత్యేకించి పరామితి వ్యక్తీకరణలను కలిగి ఉన్నప్పుడు.
ఇప్పుడు, C++ ప్రోగ్రామ్‌లో మాక్రో ఫంక్షన్‌ను ఎప్పుడు ఉపయోగించాలో తెలుసుకోవడానికి ఉదాహరణల విభాగానికి వెళ్దాం.
C++ మాక్రో ఫంక్షన్‌ల అప్లికేషన్‌లు
డెవలపర్‌లకు బహుముఖ కోడ్ ఆప్టిమైజేషన్ మరియు సరళీకరణ సాధనాన్ని అందించడం ద్వారా వివిధ ప్రోగ్రామింగ్ దృశ్యాలలో మాక్రో ఫంక్షన్‌లు ప్రాముఖ్యతను కలిగి ఉంటాయి. C++లో మాక్రో ఫంక్షన్‌ల ప్రభావాన్ని హైలైట్ చేసే కొన్ని బలవంతపు వినియోగ సందర్భాలను అన్వేషిద్దాం.
దృశ్యం 1: కోడ్ పునర్వినియోగం
ప్రోగ్రామ్‌లో నిర్దిష్ట కోడ్ నమూనా పునరావృతమయ్యే సందర్భాలలో స్థూల విధులు రాణిస్తాయి. మాక్రోలో కోడ్‌ను ఎన్‌క్యాప్సులేట్ చేయడం ద్వారా, డెవలపర్‌లు దానిని అప్రయత్నంగా మళ్లీ ఉపయోగించుకోవచ్చు, క్లీనర్ మరియు మరింత మెయింటెనబుల్ కోడ్‌ను ప్రమోట్ చేయవచ్చు. కింది ఇచ్చిన ప్రోగ్రామ్‌లో, ఇచ్చిన సంఖ్యల యొక్క బహుళ మొత్తాలను లెక్కించడానికి మేము మాక్రో ఫంక్షన్‌ని ఉపయోగిస్తాము. ముందుగా కోడ్‌ని చూద్దాం మరియు దానిని వివరంగా వివరించండి:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
#ADD(ab, yz) ((ab) + (yz))ని నిర్వచించండి
పూర్ణాంక ప్రధాన ( ) {
int sum1 ADD ( 9 , 3 ) ;
కోట్ << '9 మరియు 3 మొత్తం =' << మొత్తం 1 << endl;
int sum2 ADD ( పదకొండు , 7 ) ;
కోట్ << '11 మరియు 7 మొత్తం =' << మొత్తం 2 << endl;
int cd = 8 , wx = 4 ;
int sum3 = ADD ( cd , wx ) ;
కోట్ << '8 మరియు 4 మొత్తం =' << మొత్తం3 << endl;
తిరిగి 0 ;
}
“#include
ADD స్థూలాన్ని ఉపయోగించి, మేము రెండు మొత్తాలను గణిస్తాము: ఒకటి 9 మరియు 3 మరియు మరొకటి 11 మరియు 7. ఈ రెండు మొత్తాల కోసం మేము నేరుగా ADD మాక్రోకు సంఖ్యలను పాస్ చేస్తాము. అయితే, మూడవ మొత్తానికి, మేము వేరియబుల్స్ ఉపయోగించి సంఖ్యను పాస్ చేస్తాము. 8 మరియు 4 సంఖ్యలు వరుసగా 'cd' మరియు 'wx' వేరియబుల్స్‌లో నిల్వ చేయబడతాయి, ఇవి తరువాత ADD మాక్రోకు పంపబడతాయి.
“పూర్ణాంక మొత్తం1 = ADD(9, 3);” పంక్తి 9 మరియు 3 మొత్తాన్ని “మొత్తం1” వేరియబుల్‌కు కేటాయిస్తుంది. స్థూల ADD(9, 3) సంకలనం సమయంలో 9 + 3 తో భర్తీ చేయబడుతుంది, దీని ఫలితంగా 8 విలువ “మొత్తం1″లో నిల్వ చేయబడుతుంది. “పూర్ణాంక మొత్తం 2 = ADD(11, 7);” లైన్ విభిన్న వాదనలతో మాక్రోను తిరిగి ఉపయోగించడాన్ని ప్రదర్శిస్తుంది. “మొత్తం2”లో, 11 మరియు 7 మొత్తం ఉంచబడుతుంది.
చివరగా, “int cd = 8, wx = 4; int sum3 = ADD(cd, wx);” ఉదాహరణ వేరియబుల్స్‌తో మాక్రోను ఉపయోగించడాన్ని చూపిస్తుంది. “cd” మరియు “wx” విలువలు ADD కోసం ఆర్గ్యుమెంట్‌లుగా ఉపయోగించబడతాయి, దీని ఫలితంగా మొత్తం “sum3”లో కేటాయించబడుతుంది. ఇక్కడ అవుట్‌పుట్ ఉంది:
మీరు ఈ ఉదాహరణలో గమనించినట్లుగా, ADD మాక్రో ఫంక్షన్ రెండు పారామితులను తీసుకుంటుంది. ఇది జోడింపు చర్యను నిర్వహిస్తుంది, విభిన్న విలువలు మరియు వేరియబుల్స్‌తో దాని వినియోగాన్ని ప్రదర్శిస్తుంది మరియు ఫలితాలను కన్సోల్‌కు ముద్రిస్తుంది. ఈ స్థూల ఫంక్షన్‌ని ఉపయోగించి, మేము ప్రోగ్రామ్ అంతటా అదనపు లాజిక్‌ను సులభంగా తిరిగి ఉపయోగించుకోవచ్చు. ఇది క్లీనర్‌ను మరియు మరింత మెయింటెనబుల్ కోడ్‌ను ప్రోత్సహిస్తుంది, ప్రత్యేకించి బహుళ స్థానాల్లో అదే జోడింపు ఆపరేషన్ అవసరమైనప్పుడు.
దృష్టాంతం 2: పారామీటరైజ్డ్ ఆపరేషన్స్
మాక్రో ఫంక్షన్‌లు వివిధ ఇన్‌పుట్ విలువలకు అనుగుణంగా ఉండే సామర్థ్యాన్ని కలిగి ఉండే సాధారణ కోడ్‌ను రూపొందించడానికి డెవలపర్‌లను అనుమతించే పారామీటర్‌లతో వస్తాయి. వేరియబుల్ పారామితులతో తప్పనిసరిగా నిర్వహించాల్సిన కార్యకలాపాలకు ఇది ప్రత్యేకంగా ప్రయోజనకరంగా ఉంటుంది. కింది ఉదాహరణను చూద్దాం:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
#MAXI(ab, yz) ((ab) > (yz) ? (ab) : (yz))ని నిర్వచించండి
పూర్ణాంక ప్రధాన ( ) {
int max1 = MAXI ( 9 , 3 ) ;
కోట్ << గరిష్టంగా 1 << '9 మరియు 3 మధ్య గరిష్టం' << endl << endl;
int kl = 12 , సెయింట్ = 9 ;
int max2 = MAXI ( kl, స్టంప్ ) ;
కోట్ << గరిష్టంగా 2 << 'మధ్య గరిష్టం' << వద్ద << 'మరియు' << సెయింట్ << endl << endl;
int max3 = MAXI ( 3 * kl, wed + 5 ) ;
కోట్ << గరిష్టంగా3 << ' 3 * మధ్య గరిష్టం << వద్ద << 'మరియు' << సెయింట్ << '+5' << endl;
తిరిగి 0 ;
}
స్థూల నిర్వచనం: #MAXI(ab, yz) ((ab) > (yz) ? (ab) : (yz))ని నిర్వచించండి
ఈ పంక్తి MAXI అనే స్థూల ఫంక్షన్‌ని నిర్వచిస్తుంది, ఇది “ab” మరియు “yz” అనే రెండు పారామీటర్‌లను తీసుకుంటుంది మరియు టెర్నరీ ఆపరేటర్‌ని ఉపయోగించి గరిష్టంగా రెండు విలువలను అందిస్తుంది.
మాక్రో ఫంక్షన్‌ను స్థిరాంకాలతో ఉపయోగించి, int max1 = MAXI(9, 3), మేము గరిష్ట సంఖ్యను 9 మరియు 3 మధ్య గణిస్తాము మరియు ఫలితం 'max1'లో నిల్వ చేయబడుతుంది. అప్పుడు ఫలితం కన్సోల్‌లో ప్రదర్శించబడుతుంది.
'kl' మరియు 'st' వేరియబుల్స్‌తో స్థూల ఫంక్షన్‌ని ఉపయోగించి, ఈ వేరియబుల్స్‌లో రెండు సంఖ్యలు నిల్వ చేయబడతాయి, తర్వాత వాటి మధ్య గరిష్ట సంఖ్యను కనుగొనడానికి MAXI మాక్రో ఫంక్షన్‌కి పంపబడతాయి. మాక్రో ఫంక్షన్ 'kl' మరియు 'st' వేరియబుల్స్‌తో తిరిగి ఉపయోగించబడుతుంది, ఇది స్థిరాంకాలు మరియు వేరియబుల్స్ రెండింటితో పని చేస్తుందని చూపుతుంది. మాక్రో ఫంక్షన్ (3 * kl మరియు st + 5) వ్యక్తీకరణకు వర్తించబడుతుంది, వివిధ ఇన్‌పుట్ రకాలకు దాని అనుకూలతను ప్రదర్శిస్తుంది. మీరు ఈ కోడ్‌ని అమలు చేసినప్పుడు, మీరు ఈ క్రింది విధంగా అవుట్‌పుట్‌ని చూడాలి:
ఇచ్చిన ఉదాహరణలో, MAXI మాక్రో ఫంక్షన్ రెండు సంఖ్యల మధ్య గరిష్ట విలువను నిర్ణయిస్తుంది. ప్రధాన విధి స్థిరమైన విలువలు, వేరియబుల్స్ మరియు వ్యక్తీకరణలతో ఈ స్థూల వినియోగాన్ని ప్రదర్శిస్తుంది. అప్పుడు ఫలితం కన్సోల్‌లో ప్రదర్శించబడుతుంది. MAXI స్థూల ఫంక్షన్ వివిధ ఇన్‌పుట్ విలువలు మరియు వ్యక్తీకరణలకు ఎలా అనుగుణంగా ఉంటుందో ఇది చూపిస్తుంది, గరిష్ట విలువను కనుగొనడానికి సాధారణ యంత్రాంగాన్ని అందిస్తుంది.
దృశ్యం 3: షరతులతో కూడిన సంకలనం
సంకలనం సమయంలో కోడ్‌లోని కొన్ని భాగాలను ఆన్ లేదా ఆఫ్ చేయడంలో మాక్రోలు కీలక పాత్ర పోషిస్తాయి. ప్లాట్‌ఫారమ్-నిర్దిష్ట కోడ్‌ను చేర్చడానికి లేదా ఫీచర్ టోగుల్‌లను నిర్వహించడానికి ఇది విలువైనది.
##డీబగ్_మోడ్‌ని నిర్వచించండి
పూర్ణాంక ప్రధాన ( ) {
#ifdef డీబగ్_మోడ్
std::cout << 'హే, కల్సూమ్! డీబగ్ మోడ్ ప్రారంభించబడింది.' << std::endl;
#ఎండిఫ్
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, “#define DEBUG_MODE” లైన్ DEBUG_MODE అనే మాక్రోని నిర్వచిస్తుంది. ఈ లైన్ వ్యాఖ్యానించబడకపోతే, డీబగ్ మోడ్ ప్రారంభించబడిందని అర్థం. ఇది వ్యాఖ్యానించబడితే, డీబగ్ మోడ్ నిలిపివేయబడుతుంది. “#ifdef DEBUG_MODE” డైరెక్టివ్ DEBUG_MODE మాక్రో నిర్వచించబడిందో లేదో తనిఖీ చేస్తుంది. ఇది నిర్వచించబడితే (వ్యాఖ్యానించబడనిది), సంకలనం సమయంలో #ifdef మరియు #endifలోని కోడ్ చేర్చబడుతుంది. ఇది నిర్వచించబడకపోతే (వ్యాఖ్యానించబడింది), కోడ్ యొక్క ఆ భాగం మినహాయించబడుతుంది.
విభిన్న సంకలన సెట్టింగ్‌ల ఆధారంగా కోడ్ వైవిధ్యాలను నిర్వహించడానికి ఈ షరతులతో కూడిన కంపైలేషన్ టెక్నిక్ శక్తివంతమైనది. డీబగ్-నిర్దిష్ట కోడ్ అవసరమైనప్పుడు మాత్రమే చేర్చబడిన డీబగ్గింగ్ కోసం ఇది సాధారణంగా ఉపయోగించబడుతుంది మరియు సంబంధిత మాక్రోను నిర్వచించడం లేదా వ్యాఖ్యానించడం ద్వారా దీన్ని సులభంగా ఆన్ లేదా ఆఫ్ చేయవచ్చు. కింది అవుట్‌పుట్ చూడండి:
మీరు చూడగలిగినట్లుగా, #ifdef మరియు #endif మధ్య కోడ్ అమలు చేయబడింది మరియు కన్సోల్‌కు ముద్రించబడింది, “హే, కల్సూమ్! డీబగ్ మోడ్ ప్రారంభించబడింది” సందేశం. మాక్రో ఫంక్షన్‌లు కోడ్‌బేస్ అంతటా స్థిరమైన మార్పులను చేసే ప్రక్రియను సులభతరం చేస్తాయి. సవరణ అవసరమైతే, స్థూల నిర్వచనాన్ని మార్చడం వలన స్థూలాన్ని ఉపయోగించిన చోట మార్పు ఏకరీతిగా వర్తించేలా నిర్ధారిస్తుంది.
ముగింపు
ముగింపులో, C++లోని స్థూల ఫంక్షన్‌లు కోడ్ సౌలభ్యం మరియు సామర్థ్యాన్ని మెరుగుపరచడానికి శక్తివంతమైన యంత్రాంగాన్ని అందజేస్తాయి. డెవలపర్‌లు కోడ్ బ్లాక్‌లను ఎన్‌క్యాప్సులేట్ చేయడానికి, పునర్వినియోగాన్ని ప్రోత్సహించడానికి మరియు పునరావృతమయ్యే పనులను క్రమబద్ధీకరించడానికి #డిఫైన్ డైరెక్టివ్‌ను ప్రభావితం చేయవచ్చు. మాక్రో ఫంక్షన్‌ల సింటాక్స్, వినియోగ సందర్భాలు మరియు ప్రయోజనాలను అర్థం చేసుకోవడం ప్రోగ్రామర్‌లకు వారి కోడ్‌బేస్‌ను ఆప్టిమైజ్ చేయడానికి మరియు క్లీనర్ మరియు మరింత మెయింటెనబుల్ C++ ప్రోగ్రామ్‌ను ప్రోత్సహించడానికి విలువైన సాధనంతో సన్నద్ధమవుతుంది. ఆలోచనాత్మకమైన అప్లికేషన్ మరియు ఉత్తమ అభ్యాసాలకు కట్టుబడి ఉండటం ద్వారా, స్థూల విధులు డెవలపర్ యొక్క టూల్‌కిట్‌కు సమగ్రంగా మారతాయి, ఇది కోడ్ సామర్థ్యం మరియు నిర్వహణకు దోహదపడుతుంది.