मैं सी में एक पूर्णांक मान से बिट-बाय-बिट डेटा कैसे प्राप्त करूं?

Question

मैं दशमलव संख्या के बिट्स निकालना चाहता हूं।

उदाहरण के लिए, 7 बाइनरी 0111 है, और मैं 0 1 1 1 बूल में संग्रहीत सभी बिट्स प्राप्त करना चाहता हूं। ऐसा मैं किस प्रकार करूं?

ठीक है, एक लूप एक अच्छा विकल्प नहीं है, क्या मैं इसके लिए कुछ और कर सकता हूं?

Answer 1

आप n के k- वां बिट चाहते हैं, तो ऐसा

(n & (1 << k)) >> k 

यहाँ हम एक मुखौटा बनाने के लिए, n करने के लिए मास्क लागू, और फिर सही नकाबपोश मूल्य बदलाव सिर्फ थोड़ा हम चाहते हैं ।

int mask = 1 << k; 
    int masked_n = n & mask; 
    int thebit = masked_n >> k; 

आप थोड़ा-मास्किंग here के बारे में अधिक पढ़ सकते हैं: हम और अधिक पूरी तरह से के रूप में यह बाहर लिख सकते हैं।

यहाँ एक कार्यक्रम है:

#include <stdio.h> 
#include <stdlib.h> 

int *get_bits(int n, int bitswanted){ 
    int *bits = malloc(sizeof(int) * bitswanted); 

    int k; 
    for(k=0; k<bitswanted; k++){ 
    int mask = 1 << k; 
    int masked_n = n & mask; 
    int thebit = masked_n >> k; 
    bits[k] = thebit; 
    } 

    return bits; 
} 

int main(){ 
    int n=7; 

    int bitswanted = 5; 

    int *bits = get_bits(n, bitswanted); 

    printf("%d = ", n); 

    int i; 
    for(i=bitswanted-1; i>=0;i--){ 
    printf("%d ", bits[i]); 
    } 

    printf("\n"); 
} 

Answer 2

यहाँ एक तरह से करना है यह वहाँ कई अन्य हैं:

bool b[4]; 
int v = 7; // number to dissect 

for (int j = 0; j < 4; ++j) 
    b [j] = 0 != (v & (1 << j)); 

Answer 3

यहाँ यह करने के लिए एक बहुत ही आसान तरीका है;

int main() 
{ 
    int s=7,l=1; 
    vector <bool> v; 
    v.clear(); 
    while (l <= 4) 
    { 
     v.push_back(s%2); 
     s /= 2; 
     l++; 
    } 
    for (l=(v.size()-1); l >= 0; l--) 
    { 
     cout<<v[l]<<" "; 
    } 
    return 0; 
} 

Answer 4

#include <stdio.h> 

int main(void) 
{ 
    int number = 7; /* signed */ 
    int vbool[8 * sizeof(int)]; 
    int i; 
     for (i = 0; i < 8 * sizeof(int); i++) 
     { 
      vbool[i] = number<<i < 0; 
      printf("%d", vbool[i]); 
     } 
    return 0; 
} 

Answer 5

आप किसी भी छोरों नहीं करना चाहते हैं, तो आप यह पता लिखने के लिए होगा:

#include <stdio.h> 
#include <stdbool.h> 

int main(void) 
{ 
    int num = 7; 

    #if 0 
     bool arr[4] = { (num&1) ?true: false, (num&2) ?true: false, (num&4) ?true: false, (num&8) ?true: false }; 
    #else 
     #define BTB(v,i) ((v) & (1u << (i))) ? true : false 
     bool arr[4] = { BTB(num,0), BTB(num,1), BTB(num,2), BTB(num,3)}; 
     #undef BTB 
    #endif 

    printf("%d %d %d %d\n", arr[3], arr[2], arr[1], arr[0]); 

    return 0; 
} 

के रूप में यहाँ का प्रदर्शन किया, यह भी एक प्रारंभकर्ता में काम करता है।

Answer 6

अनुरोध के अनुसार, मैंने फोरफिंगर के उत्तर पर एक पूर्ण उत्तर के लिए मेरी टिप्पणी का विस्तार करने का निर्णय लिया। हालांकि उनका जवाब सही है, यह अनिवार्य रूप से जटिल है। इसके अलावा सभी मौजूदा उत्तरों मूल्यों का प्रतिनिधित्व करने के लिए int एस पर हस्ताक्षर किए गए हैं। यह खतरनाक है, क्योंकि ऋणात्मक मूल्यों का दायां स्थानांतरित करना कार्यान्वयन-परिभाषित है (यानी पोर्टेबल नहीं) और बाएं-स्थानांतरण से अपरिभाषित व्यवहार हो सकता है (this question देखें)।

वांछित बिट को कम से कम महत्वपूर्ण स्थिति में दाएं स्थानांतरित करके, मास्किंग 1 के साथ किया जा सकता है। प्रत्येक बिट के लिए एक नया मास्क मान गणना करने की आवश्यकता नहीं है।

(n >> k) & 1 

एक पूरा कार्यक्रम है, कंप्यूटिंग के रूप में (और बाद में मुद्रण) एकल बिट मूल्यों की एक सरणी:

#include <stdio.h> 
#include <stdlib.h> 

int main(int argc, char** argv) 
{ 
    unsigned 
     input = 0b0111u, 
     n_bits = 4u, 
     *bits = (unsigned*)malloc(sizeof(unsigned) * n_bits), 
     bit = 0; 

    for(bit = 0; bit < n_bits; ++bit) 
     bits[bit] = (input >> bit) & 1; 

    for(bit = n_bits; bit--;) 
     printf("%u", bits[bit]); 
    printf("\n"); 

    free(bits); 
} 

यह मानते हुए कि आप इस मामले में के रूप में सभी बिट्स गणना करना चाहते हैं, न कि किसी विशिष्ट एक , पाश आगे

for(bit = 0; bit < n_bits; ++bit, input >>= 1) 
    bits[bit] = input & 1; 

इस जगह में input को संशोधित करता है और इस तरह एक निरंतर चौड़ाई, एकल बिट पारी है, जो कुछ एक के बारे में अधिक कुशल हो सकता है के उपयोग की अनुमति के लिए बदला जा सकता है rchitectures।

Answer 7

@prateek आपकी मदद के लिए धन्यवाद। मैं एक कार्यक्रम में उपयोग के लिए टिप्पणियों के साथ समारोह को फिर से लिखता हूं। अधिक बिट्स के लिए 8 बढ़ाएं (एक पूर्णांक के लिए 32 तक)।

std::vector <bool> bits_from_int (int integer) // discern which bits of PLC codes are true 
{ 
    std::vector <bool> bool_bits; 

    // continously divide the integer by 2, if there is no remainder, the bit is 1, else it's 0 
    for (int i = 0; i < 8; i++) 
    { 
     bool_bits.push_back (integer%2); // remainder of dividing by 2 
     integer /= 2; // integer equals itself divided by 2 
    } 

    return bool_bits; 
} 

Answer 8

का उपयोग std::bitset

int value = 123; 
std::bitset<sizeof(int)> bits(value); 
std::cout <<bits.to_string();