एक पूर्णांक के एक बाइट तक कैसे पहुंचता है?

Question

एक निर्दिष्ट संचार मानक आरटीसीएम एससी 104 3.1 के लिए, मुझे डेटा को 12 बिट डेटा सेगमेंट की एक जोड़ी के रूप में बाइट्स में विभाजित करने की आवश्यकता है। तो किसी दिए गए संदेश के लिए मुझे पहले बाइट और दूसरे बाइट के आधे पर संदेश प्रकार संख्या रखने की आवश्यकता है। तो मुझे दूसरे बाइट के आधे हिस्से में एक आईडी पूर्णांक शुरू करने की आवश्यकता है और तीसरे बाइट जारी रखें। 20 बिट, 5 बिट, और अन्य आकारों में अनिवार्य रूप से 0 की कटौती करने वाले संदेश के अंत में इस प्रकार का पैटर्न जारी रहता है जो आमतौर पर पूर्णांक मानों के एमएसबी अंत को भर देगा।

मैंने स्पष्ट परिभाषा नहीं देखी है, लेकिन मुझे लगता है कि इसे बिट बाइट ऑर्डर में जाना चाहिए ताकि बिट्स की प्रतिलिपि बनाने से पहले मुझे स्मृति में अपने पूर्णांक को उलटना होगा। मैं अभी भी सीपीपी के लिए काफी नया हूं और सोच रहा हूं कि मैं व्यक्तिगत बाइट्स को मेमोरी में पूर्णांक बनाने के लिए कैसे प्राप्त करूं? अगर मैं बाइट्स तक पहुंच सकता हूं तो मैं बिटवाई का उपयोग कर सकता हूं या बिट्स को 2 बाइट्स से संदेश के लिए विभाजित कर सकता हूं।

यहाँ डेटा जोड़ने से पहले संदेश के निर्माण की शुरुआत है:

//build message 1002 gps 00111110 1010 
    char buf1002[BUFFERSIZE]; 
    buf1002[0] = 0x3E; //00111110 
    buf1002[1] = 0xA0; //10100000 
//ref station id 12 bits of 16 
//ex unsigned short m = 1100; 
//m would be byte2 00000100 byte1 01001100 
//buf1002[1] would be 10100100 
//buf1002[2] would be 01001100 
//reverse bit order for network after building? 

संदर्भ स्टेशन एक अहस्ताक्षरित कम है, इसलिए एक 2 बाइट पूर्णांक से किया जाएगा। तो मैं इससे एक बाइट पढ़ने के बारे में कैसे जा सकता हूं? क्या मैं एक मेमोरी लोकेशन पॉइंटर से शुरू करता हूं? यदि हां तो क्या?

किसी भी मदद की सराहना की जाएगी।

Answer 1

आप बाइट्स के रूप में यह punning उदाहरण के लिए सहारा कर सकते हैं:

const unsigned short s(1); 
const char* const bytes(reinterpret_cast<const char*>(&s)); 

const char NaturalOrder[sizeof(s)] = {bytes[0],bytes[1]}; 
const char EndianFlipped[sizeof(s)] = {bytes[1],bytes[0]}; 

(लेकिन यह भी builtins की प्राकृतिक आकार के बारे में dmckee की टिप्पणी देखते हैं, और निश्चित चौड़ाई प्रकार उपयोग करने पर विचार)।

Answer 2

आप अपने पूर्णांक किसी पूर्णांक एक में, उदाहरण के में निहित (मैं प्रत्येक एकल बाइट्स अंतर करने के लिए रिक्त स्थान बना रही हूँ) की तरह 00001000 00000000 11,000,000 उदाहरण के लिए 00,110,000 देख हों:

int  a; 
int  single_byte; 

a = the_number; 

आप एक समारोह कर सकता है जैसे

int  get_byte_in_integer(int byte_number, int integer); 

ताकि:

single_byte = get_byte_in_integer(1, a); // That would give you the 11000000 byte 

साथ

int get_byte_in_integer(int byte_number, int integer) 
{ 
     return (integer >> (byte_number << 3)) & 0xff); 
} 

उम्मीद है कि यह बाइट भाग के लिए मदद करता है।

bit = number & (1 << x); 

कि विभिन्न बिट में की बिट एक्स मूल्य रखा जाएगा:

Answer 3

थोड़ा, और यह बिट आप जाँच करना चाहते हैं के साथ जांच करने के लिए।

से लिया: How do you set, clear, and toggle a single bit?

Answer 4

आप थोड़ा क्षेत्रों, इस तरह उपयोग कर सकते हैं - अंत में कुछ चेतावनियां:

typedef union packet { 
    struct { 
     unsigned int msgno : 12; // creates a 12 bit wide integral field 
     unsigned int msgtype : 12; 
     unsigned int somefield2 : 3; 
     unsigned int somefield3 : 5; 
    } fields; 

    unsigned char asbytes[4]; 
} packet; 

... 

packet p; 
// fill it, by using the field side of the union 
p.fields.msgno = 16; 
p.fields.msgtype = 12; 
p.fields.somefield2 = 6; 
// and retrieving them as regular bytes 
unsigned char abyte = p.asbytes[0]; 
abyte = p.asbytes[1]; 
// and so on 

मेरे लिए मुख्य लाभ यह पठनीयता है: सभी कार्यों यद्यपि पर नियमित संचालन की तरह व्यवहार संकुचित अभिन्न प्रकार चर।सीमाएं हैं (उदाहरण के लिए पोर्टेबिलिटी) लेकिन यदि आपको एकाधिक आर्किटेक्चर या कंपाइलर्स या विभिन्न एंडियनों को लक्षित करने की आवश्यकता नहीं है, तो यह आपके प्रोग्राम को पढ़ने में बहुत आसान बनाने में मदद कर सकता है।