वे मूल रूप से एक ही नहीं हैं?
नहीं, बिल्कुल नहीं। आस - पास भी नहीं।
इस सच के बावजूद से अपने मैक्रो एक है intऔर अपने constexpr unsignedएक है unsignedवहाँ महत्वपूर्ण अंतर और मैक्रो केवल कर रहे हैं, एक लाभ।
क्षेत्र
एक मैक्रो को प्रीप्रोसेसर द्वारा परिभाषित किया जाता है और इसे हर बार कोड में प्रतिस्थापित किया जाता है। प्रीप्रोसेसर गूंगा है और सी ++ सिंटैक्स या शब्दार्थ को नहीं समझता है। मैक्रोज़ स्कैप्स जैसे नेमस्पेस, क्लासेस या फंक्शन ब्लॉक को नज़रअंदाज़ करते हैं, इसलिए आप किसी स्रोत फ़ाइल में किसी और चीज़ के लिए नाम का उपयोग नहीं कर सकते। यह उचित C ++ चर के रूप में परिभाषित निरंतर के लिए सच नहीं है:
#define MAX_HEIGHT 720
constexpr int max_height = 720;
class Window {
int max_height;
};
यह एक सदस्य चर कहा जाता है max_heightक्योंकि यह एक वर्ग के सदस्य है और इसलिए एक अलग गुंजाइश है ठीक है, और नाम स्थान पर एक से अलग है। यदि आपने MAX_HEIGHTसदस्य के लिए नाम का पुन: उपयोग करने का प्रयास किया है, तो प्रीप्रोसेसर इसे इस बकवास में बदल देगा जो संकलन नहीं करेगा:
class Window {
int 720;
};
यही कारण है कि आपको मैक्रो UGLY_SHOUTY_NAMESको यह सुनिश्चित करने के लिए देना होगा कि वे बाहर खड़े रहें और आप झड़पों से बचने के लिए उनका नामकरण करने में सावधानी बरतें। यदि आप अनावश्यक रूप से मैक्रोज़ का उपयोग नहीं करते हैं, तो आपको उस बारे में चिंता करने की ज़रूरत नहीं है (और पढ़ना नहीं है SHOUTY_NAMES)।
यदि आप किसी फ़ंक्शन के अंदर केवल एक स्थिरांक चाहते हैं, तो आप एक मैक्रो के साथ ऐसा नहीं कर सकते, क्योंकि प्रीप्रोसेसर को पता नहीं है कि फ़ंक्शन क्या है या इसके अंदर होने का क्या मतलब है। किसी मैक्रो को केवल उस फ़ाइल के एक निश्चित हिस्से तक सीमित करने के लिए जिसे आपको #undefफिर से इसकी आवश्यकता है :
int limit(int height) {
#define MAX_HEIGHT 720
return std::max(height, MAX_HEIGHT);
#undef MAX_HEIGHT
}
कहीं अधिक समझदार की तुलना करें:
int limit(int height) {
constexpr int max_height = 720;
return std::max(height, max_height);
}
आप मैक्रो को क्यों पसंद करेंगे?
एक वास्तविक स्मृति स्थान
एक कॉन्स्टैक्स वेरिएबल एक वैरिएबल है इसलिए यह वास्तव में प्रोग्राम में मौजूद है और आप सामान्य सी ++ चीजें कर सकते हैं जैसे कि इसका पता लें और इसके संदर्भ को बांधें।
इस कोड में अपरिभाषित व्यवहार है:
#define MAX_HEIGHT 720
int limit(int height) {
const int& h = std::max(height, MAX_HEIGHT);
return h;
}
समस्या यह है कि MAX_HEIGHTएक चर नहीं है, इसलिए std::maxएक कॉल के लिए एक अस्थायी intसंकलक द्वारा बनाया जाना चाहिए। फिर जो संदर्भ दिया जाता है std::max, वह उस अस्थायी को संदर्भित कर सकता है, जो उस बयान के अंत के बाद मौजूद नहीं है, इसलिए return hअमान्य मेमोरी तक पहुँच प्राप्त करता है।
यह समस्या बस एक उचित चर के साथ मौजूद नहीं है, क्योंकि इसकी स्मृति में एक निश्चित स्थान है जो दूर नहीं जाता है:
int limit(int height) {
constexpr int max_height = 720;
const int& h = std::max(height, max_height);
return h;
}
(व्यवहार में आप शायद घोषित int hनहीं करेंगे, const int& hलेकिन समस्या अधिक सूक्ष्म संदर्भों में उत्पन्न हो सकती है।)
प्रीप्रोसेसर शर्तें
मैक्रो को पसंद करने का एकमात्र समय तब होता है जब आपको इसके मूल्य को पूर्वप्रक्रमक द्वारा समझने की आवश्यकता #ifहोती है, जैसे कि स्थितियों में उपयोग के लिए
#define MAX_HEIGHT 720
#if MAX_HEIGHT < 256
using height_type = unsigned char;
#else
using height_type = unsigned int;
#endif
आप यहाँ एक वैरिएबल का उपयोग नहीं कर सकते, क्योंकि प्रीप्रोसेसर को समझ में नहीं आता है कि नाम से चर कैसे देखें। यह केवल शुरुआत के साथ मैक्रो विस्तार और निर्देशों जैसी बुनियादी बहुत बुनियादी बातें समझता है #(जैसे #includeऔर #defineऔर #if)।
यदि आप एक स्थिरांक चाहते हैं जिसे प्रीप्रोसेसर द्वारा समझा जा सकता है तो आपको इसे परिभाषित करने के लिए प्रीप्रोसेसर का उपयोग करना चाहिए। यदि आप सामान्य C ++ कोड के लिए स्थिरांक चाहते हैं, तो सामान्य C ++ कोड का उपयोग करें।
उपरोक्त उदाहरण सिर्फ एक प्रीप्रोसेसर स्थिति को प्रदर्शित करने के लिए है, लेकिन यह भी कि कोड प्रीप्रोसेसर का उपयोग करने से बच सकता है:
using height_type = std::conditional_t<max_height < 256, unsigned char, unsigned int>;