कस्टम बाइट आकार?

Question

तो, आप जानते हैं कि किस तरह के प्राचीन प्रकार के 1 बाइट का आकार है? मैं एक कस्टम आकार के साथ एक आदिम कैसे बनाऊंगा? तो 4 बाइट्स के आकार के साथ int में एक की तरह मैं एक आकार के आकार के साथ 16 कहता हूं। क्या ऐसा करने का कोई तरीका है? क्या इसके आसपास कोई रास्ता है?

Answer 1

आम तौर पर आप केवल एक संरचना बनाते हैं जो उस डेटा का प्रतिनिधित्व करती है जिसमें आप रुचि रखते हैं। यदि यह डेटा के 16 बाइट्स है, या तो यह कई छोटे प्रकारों का कुल है या आप प्रोसेसर पर काम कर रहे हैं जिसमें मूल 16-बाइट अभिन्न प्रकार है।

यदि आप बहुत बड़ी संख्याओं का प्रतिनिधित्व करने की कोशिश कर रहे हैं, तो आपको एक विशेष पुस्तकालय खोजने की आवश्यकता हो सकती है जो मनमाने ढंग से आकार की संख्या को संभालती है।

Answer 2

यह इस बात पर निर्भर करता है कि आप ऐसा क्यों कर रहे हैं। आमतौर पर, आप 8 बिट से कम प्रकार के प्रकार का उपयोग नहीं कर सकते हैं, क्योंकि यह वास्तुकला के लिए पता योग्य इकाई है। आप अलग-अलग लंबाई को परिभाषित करने के structs उपयोग कर सकते हैं, हालांकि,:

struct s { 
    unsigned int a : 4; // a is 4 bits 
    unsigned int b : 4; // b is 4 bits 
    unsigned int c : 16; // c is 16 bits 
}; 

हालांकि, वहाँ कोई गारंटी नहीं कि struct 24 बिट लंबे हो जाएगा। इसके अलावा, यह एंडियन मुद्दों का कारण बन सकता है। आप कहां कर सकते हैं, सिस्टम स्वतंत्र प्रकारों का उपयोग करना सबसे अच्छा है, जैसे कि uint16_t, आदि। आप बिटवाई ऑपरेटरों और बिट शिफ्ट का उपयोग विशेष रूप से चीजों को हल करने के लिए भी कर सकते हैं।

Answer 3

यदि आप एक नया प्रकार बनाना चाहते हैं, तो इसे टाइप करें। यदि आप इसे 16-बाइट आकार में रखना चाहते हैं, तो उस स्ट्रिप टाइप करें जिसमें उसके भीतर 16-बाइट सदस्य डेटा हैं। बस सावधान रहें कि आपके सिस्टम संरेखण आवश्यकताओं से मेल खाने के लिए अक्सर कंपिलर आपके लिए चीजों को पैड करेंगे। एक बाइट स्ट्रक्चर बिना किसी देखभाल के 1 बाइट्स बना रहता है।

Answer 4

सी ++ 11 में, इसके लिए एक उत्कृष्ट समाधान है: std :: aligned_storage।

#include <memory> 
#include <type_traits> 

int main() 
{ 
    typedef typename std::aligned_storage<sizeof(int)>::type memory_type; 
    memory_type i; 
    reinterpret_cast<int&>(i) = 5; 
    std::cout << reinterpret_cast<int&>(i) << std::endl; 

    return 0; 
} 

यह आप ढेर पर अप्रारंभीकृत भंडारण के एक ब्लॉक घोषित करने के लिए अनुमति देता है।