C++లో ప్రిప్రాసెసర్ ఆదేశాలు ద్వారా సూచించబడతాయి # (హాష్) ప్రకటన ప్రారంభంలో చిహ్నం. C++లో సాధారణ ప్రిప్రాసెసర్ ఆదేశాలు ఉన్నాయి ఫైల్ చేర్చడం మరియు మాక్రోలు నిర్వచనం. ఈ ఆదేశాలు సాధారణంగా C++ ప్రోగ్రామ్ ఎగువన ప్రధాన() ఫంక్షన్ వెలుపల ఉంచబడతాయి. ప్రీ-ప్రాసెసింగ్ సమయంలో, దీనితో ఒక ఇంటర్మీడియట్ ఫైల్ .ఐ పొడిగింపు ఉత్పత్తి చేయబడుతుంది.
#C++లో డైరెక్టివ్‌ను నిర్వచించండి
C++లో, #define డైరెక్టివ్ అనేది స్థిరాంకాలు లేదా మాక్రోలను నిర్వచించడానికి ఉపయోగించే ప్రిప్రాసెసర్ డైరెక్టివ్. అసలు సంకలన ప్రక్రియ జరగడానికి ముందు కోడ్ అంతటా ప్రత్యామ్నాయంగా ఉండే సింబాలిక్ పేర్లు లేదా విలువలను నిర్వచించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.
#define ప్రీ-ప్రాసెసర్ యొక్క కొన్ని ప్రధాన ముఖ్యాంశాలు ఇక్కడ ఉన్నాయి
- C++లో, మాక్రోలను నిర్వచించడానికి ప్రీప్రాసెసర్ డైరెక్టివ్ #define ఉపయోగించబడుతుంది.
- C++లోని మాక్రోలు #define డైరెక్టివ్‌తో ప్రకటించబడిన స్థిరాంకాలు లేదా వ్యక్తీకరణలు అని పేరు పెట్టబడ్డాయి.
- #డిఫైన్ డైరెక్టివ్‌లను మాక్రో డైరెక్టివ్‌లుగా కూడా సూచిస్తారు.
- C++ ప్రోగ్రామ్‌లో #define డైరెక్టివ్ ఎదురైనప్పుడు, ప్రాథమిక సంకలన దశలో నిర్వచించబడిన మాక్రో పేరు స్థిరమైన విలువ లేదా వ్యక్తీకరణతో భర్తీ చేయబడుతుంది.
#డిఫైన్ డైరెక్టివ్ యొక్క సింటాక్స్
#define డైరెక్టివ్‌ని ఉపయోగించడం కోసం వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
#ఐడెంటిఫైయర్ విలువను నిర్వచించండి
ఇక్కడ ఐడెంటిఫైయర్ అనేది స్థిరమైన లేదా స్థూల నిర్వచించబడిన పేరు, మరియు విలువ అనేది కోడ్ కంపైల్ చేయబడినప్పుడు దానితో భర్తీ చేయవలసిన విలువ.
#డిఫైన్ డైరెక్టివ్ యొక్క ఉదాహరణ
C++ కోడ్‌లో #define డైరెక్టివ్‌ను ఎలా ఉపయోగించవచ్చో వివరించే ఉదాహరణ క్రిందిది:
##PI 3.14159ని నిర్వచించండి
#SQUARE(x) ((x) * (x))ని నిర్వచించండి
int ప్రధాన ( ) {
రెట్టింపు వ్యాసార్థం = 5.0 ;
రెట్టింపు ప్రాంతం = PI * చతురస్రం ( వ్యాసార్థం ) ;
std :: కోట్ << 'ప్రాంతం: ' << ప్రాంతం << std :: endl ;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము #define డైరెక్టివ్‌ని ఉపయోగించి రెండు స్థిరాంకాలను నిర్వచిస్తాము: PI, ఇది గణిత స్థిరాంకం piని సూచిస్తుంది మరియు SQUARE, ఇది ఇచ్చిన విలువ యొక్క వర్గాన్ని లెక్కించే మాక్రో. మేము ఇచ్చిన వ్యాసార్థంతో సర్కిల్ యొక్క వైశాల్యాన్ని లెక్కించడానికి మా కోడ్‌లో ఈ స్థిరాంకాలను ఉపయోగిస్తాము.
#define మరియు const మధ్య వ్యత్యాసం
#define డైరెక్టివ్‌ను చర్చించేటప్పుడు ఉత్పన్నమయ్యే ఒక సాధారణ ప్రశ్న ఏమిటంటే, ఇది C++లో కాన్స్ట్ వేరియబుల్స్‌ని ఉపయోగించడం నుండి ఎలా భిన్నంగా ఉంటుంది. మీ కోడ్ అంతటా ఉపయోగించగల స్థిరాంకాలను నిర్వచించడానికి రెండు విధానాలు మిమ్మల్ని అనుమతించినప్పటికీ, వాటి మధ్య కొన్ని కీలక తేడాలు ఉన్నాయి.
మధ్య ఒక ప్రధాన వ్యత్యాసం #నిర్వచించండి మరియు స్థిరంగా #define అనేది ప్రీప్రాసెసర్ డైరెక్టివ్, అయితే const అనేది C++ భాషలో భాగమైన కీలకపదం. దీనర్థం #define ఉపయోగించి నిర్వచించబడిన స్థిరాంకాలు కోడ్ కంపైల్ చేయడానికి ముందు వాటి విలువలతో భర్తీ చేయబడతాయి, అయితే కాన్స్ట్ వేరియబుల్స్ కంపైలర్ ద్వారానే నిర్వహించబడతాయి.
#define మరియు const మధ్య మరొక ముఖ్యమైన వ్యత్యాసం ఏమిటంటే, కాన్స్ట్ వేరియబుల్స్ నిర్దిష్ట రకాన్ని కలిగి ఉంటాయి, అయితే #define ఉపయోగించి నిర్వచించబడిన స్థిరాంకాలు ఉండవు. దీనర్థం మీరు నిర్దిష్ట రకం అవసరమైన ప్రదేశాలలో కాన్స్ట్ వేరియబుల్‌లను ఉపయోగించవచ్చు, అయితే #define ఉపయోగించి నిర్వచించబడిన స్థిరాంకాలు ఆ పరిస్థితుల్లో ఎల్లప్పుడూ పని చేయకపోవచ్చు.
ముగింపు
#define డైరెక్టివ్ అనేది స్థిరాంకాలు లేదా మాక్రోలను నిర్వచించడానికి ఉపయోగించే ప్రీప్రాసెసర్ డైరెక్టివ్. అసలైన సంకలన ప్రక్రియ జరగడానికి ముందు కోడ్ అంతటా ప్రత్యామ్నాయంగా ఉండే సింబాలిక్ పేర్లు లేదా విలువలను నిర్వచించడానికి ఇది మమ్మల్ని అనుమతిస్తుంది. ఈ కథనంలో C++లో #define directive గురించి మరింత చదవండి.