यह निर्धारित करने के लिए सुरुचिपूर्ण और सुरक्षित तरीका है कि आर्किटेक्चर 32 बिट या 64 बिट

Question

शीर्षक कहता है, क्या यह निर्धारित करने के लिए कोई सुरुचिपूर्ण और सुरक्षित तरीका है कि आर्किटेक्चर 32 बिट या 64 बिट है या नहीं। सुरुचिपूर्ण द्वारा, आप सटीक, सही, संक्षिप्त, साफ और स्मार्ट तरीके से सोच सकते हैं। सुरक्षित रूप से, मानक, सी 8 9/सी 99, और ऑपरेटिंग सिस्टम स्वतंत्रता की अवधि में सुरक्षित सोचें।

Answer 1

पॉइंटर्स का आकार वास्तव में परीक्षण करने के लिए एक अच्छी बात नहीं है - मानक सी में बहुत कुछ नहीं है जिसे आप वैसे भी परीक्षण के परिणाम के साथ कर सकते हैं।

मेरे सुझाव परीक्षण ((size_t)-1) है, सबसे बड़ी वस्तु के आकार सी समझता है कि:

if ((size_t)-1 > 0xffffffffUL) 
    { 
      printf("> 32 bits\n"); 
    } 
    else 
    { 
      printf("<= 32 bits\n"); 
    } 

यदि यह एक से अधिक 0xffffffffUL तो आप सिद्धांत रूप में 2**32 - 1 बाइट से बड़ी वस्तुओं हो सकता है, जो की तुलना में एक अधिक सार्थक परीक्षण की तरह लगता है है एक घबराहट "32 बिट्स बनाम 64 बिट्स"।

(उदाहरण के लिए, यदि आप जानते हैं कि size_t का अधिकतम मान केवल 2**32 - 1 है, तो कोई mmap() एक क्षेत्र की तुलना में 1 या 2 जीबी बड़ा करने की कोशिश कर बात है।)

Answer 2

सबसे आम तरीका sizeof(void*) और sizeof(int) का परीक्षण करना है (ध्यान दें कि उन्हें जरूरी नहीं होना चाहिए)।

x86/x64 CPUs पर एक और संभावना 'एलएम' ध्वज के लिए परीक्षण करना है। यदि यह मौजूद है तो सीपीयू AMD64 निर्देश सेट को समझता है।

Answer 3

संक्षिप्त उत्तर: कोई

विस्तृत उत्तर: यह बहुत अधिक ओएस/संकलक संयोजन पर निर्भर करता है। उदाहरण के लिए रनटाइम पर, लिनक्स पर आप proc फाइल सिस्टम से पूछ सकते हैं जबकि विंडोज़ पर आप रजिस्टर से पूछ सकते हैं।

आप साबित कर सकते हैं संकलक कि संकलन के लिए इस्तेमाल किया जा रहा एक 32/64 बिट की तरह कुछ का उपयोग करके लक्षित है:

bool is_32bit() { 
    return sizeof(int *) == 4; 
} 

bool is_64bit() { 
    return sizeof(int *) == 8; 
} 

इस सकता है कुछ मान्यताओं के तहत काम करता है (उदाहरण के लिए कार्यावधि में काम करता है)। आप अपने प्लेटफ़ॉर्म के लिए संकलन-समय #define खोज सकते हैं लेकिन यह एक प्रसिद्ध गड़बड़ है।

Answer 4

आप जीसीसी उपयोग कर रहे हैं (टैग में संकेत के रूप में) है, तो आप एक संकलन समय परीक्षण

#if __SIZEOF_POINTER__ == 8 

बाहर चाहे वह एक 64-बिट सिस्टम है खोजने के लिए के रूप में, परीक्षण कर सकते हैं। सुनिश्चित करें कि आप जिस जीसीसी संस्करण का उपयोग कर रहे हैं, उसका उपयोग करने से पहले __SIZEOF_POINTER__ को परिभाषित करता है।

Answer 5

एक सुरक्षित और पोर्टेबल तकनीक दुर्भाग्य से असंभव है (क्योंकि सुरक्षित और पोर्टेबल केवल आपको सी मानक में नियमों की अनुमति देता है)।

sizeof(int) कुछ सामान्य कंपेलरों के साथ आप 32 बिट प्लेटफ़ॉर्म के लिए 4 और 64 बिट प्लेटफ़ॉर्म के लिए 8 दे सकते हैं लेकिन इसकी गारंटी नहीं है। सभी सी मानक कहते हैं कि एक int लक्ष्य पर गणना के लिए 'प्राकृतिक' आकार होना चाहिए, और इतने सारे कंपाइलर्स ने 64 बिट दुनिया में 4 के रूप में आकार (int) को छोड़ दिया है, इस आधार पर कि यह पर्याप्त है '।

sizeof(void*) बेहतर है क्योंकि संपूर्ण पता स्थान को संबोधित करने के लिए एक सूचक होना उचित आकार होना चाहिए। sizeof(void*) इसलिए आपको उपयुक्त 4 या 8 देने की संभावना है। तकनीकी रूप से, यहां तक ​​कि यह आकार के रूप में भी गारंटी नहीं है, आपको कुछ स्टोर करने के लिए आवश्यक बाइट्स की संख्या देता है, और बाइट को 8 बिट्स नहीं होने चाहिए। एक बाइट तकनीकी रूप से स्मृति की सबसे छोटी एड्रेसेबल यूनिट है जो अधिकांश प्लेटफार्मों पर 8 बिट्स होती है जो लोगों का उपयोग किया जाता है। 8 बिट एड्रेसेबल बहुत आम है, लेकिन मैं चिप्स के साथ काम करता हूं जो 16 बिट एड्रेस करने योग्य और 16 बिट शब्द आकार (इसलिए sizeof(int) 1 है)। तो, यदि आपका बाइट आकार 8 बिट नहीं है, तो sizeof(void*) आपको विभिन्न प्रकार के मूल्य दे सकता है।

दूसरी तरफ, यदि आप केवल x86 और x64 (32 बिट और 64 बिट पीसी प्रोसेसर) के बीच अंतर करने की कोशिश कर रहे हैं तो आकार (शून्य *) पर्याप्त होगा, और कंपेलरों में पोर्टेबल होगा।

Answer 6

कोड बैंक पर 32-बिट या डेटा बैंक पर 32-बिट। :-) 8086 प्रोसेसर में 20-बिट कोड मेमोरी वाला 16-बिट डेटा था। इसके अलावा, आधुनिक हावर्ड मशीन कोड/डेटा अलगाव के साथ अजीब चीजें करते हैं ...

आप x86 प्रोसेसर के लिए cpuid निर्देश देख सकते हैं। अन्य प्रोसेसर परिवारों के पास ऐसा निर्देश नहीं हो सकता है ... वाईएमएमवी।

Answer 7

int iedx; 

__asm 
{ 

mov eax, 0x80000001; 
cpuid; 
mov, iedx,edx; 
} 

    if (iedx & (1 << 29)) 
     { 
     return 1; 
     } 
    return 0;