मेमोरी में डेटा का क्रम

Question

कुछ सरल प्रश्न।

const int gFirst; 
const int gSecond; 

struct Data 
{ 
    static int First; 
    static int Second; 

    int first; 
    int second; 
}; 

Data data; 

क्या यह गारंटी है कि निम्नलिखित कथन सत्य हैं?

1. &gFirst < &gSecond
2. &Data::First < &Data::Second
3. &data.first < &data.second

Answer 1

1) इस परिणाम अनिर्दिष्ट है।
2) यह परिणाम अनिर्दिष्ट है। *
3) हां।

मानक में प्रासंगिक अनुभाग §5.9/2 है। संकेत p और q के बीच संबंधपरक तुलना केवल निर्दिष्ट कर रहे हैं जब:

• p और एक ही सरणी के अंत पिछले एक करने के लिए एक ही वस्तु या समारोह, बात करने के लिए q बिंदु, या दोनों अशक्त हैं। इस मामले में, p <= q और p >= q सत्य हैं, और p < q और p > q झूठे हैं।
• p और q उसी ऑब्जेक्ट के नॉनस्टैटिक डेटा सदस्यों को इंगित करता है, बाद में घोषित सदस्य के सूचक अधिक से अधिक की तुलना करते हैं। (ध्यान दें, यह तुलना एक्सेस विनिर्देशकों के बीच नहीं हो सकती है।)
• p और q एक ही सरणी के भीतर तत्वों या सरणी के अंत से पहले तत्वों को इंगित करता है, उच्च सबस्क्रिप्ट वाले तत्व के पॉइंटर या अंत में एक के लिए सरणी अधिक तुलना करता है।
• p और q उसी यूनियन ऑब्जेक्ट के डेटा सदस्यों को इंगित करता है, इस मामले में वे बराबर तुलना करते हैं।

अन्य सभी मामलों में, परिणाम निर्दिष्ट नहीं है।

_{* क्योंकि वे स्थैतिक हैं, वे (स्पष्ट रूप से) "nonstatic सदस्य" नियम नहीं प्राप्त करते हैं। उन्हें कुछ अनुवाद इकाई में परिभाषित किया जाएगा, और इसलिए किसी भी अन्य सूचक की तरह ही हैं। (अनिर्दिष्ट।)}

---

नोट! एक तरह से कुल आदेश प्राप्त करने के लिए नहीं है, और कहा कि std::less<void*> के माध्यम से है

यह §20.3.3/8 में है (और अन्य सभी तुलनात्मक समारोह वस्तुओं।):

टेम्पलेट्स greater, less के लिए , greater_equal, और less_equal, सूचक प्रकार के लिए विशेषज्ञता कुल ऑर्डर उत्पन्न करती है, भले ही अंतर्निहित ऑपरेटरों <, >, <=, >= नहीं।

इसलिए जब आप अगर std::less<void*>(&gFirst, &gSecond)true या false है पता नहीं है, आप की गारंटी है:

std::less<void*>(&gFirst, &gSecond) == 
    std::greater<void*>(&gSecond, &gFirst); 
std::less<void*>(&Data::First, &Data::Second) == 
    std::greater<void*>(&Data::Second, &Data::First); 

कौन सा उपयोगी साबित हो सकते हैं।

Answer 2

जवाब

:

1) Not guaranteed. 
    But probably. 
    But the order of initialization is guaranteed. 
2) No. 
    You just have the declaration here. 
    You need to to define the instances in a source file. 
    Then they will behave the same way as the objects in (1). 
3) Yes.