ganze Zahl auf eine Darstellung Bit konvertieren

Question

Wie kann ich eine ganze Zahl seiner Bit-Darstellung zu konvertieren. Ich möchte eine ganze Zahl nehmen und einen Vektor zurückgeben, der 1 und 0 von der Bit-Darstellung der ganzen Zahl enthält.

Ich habe ein Heck einer Zeit versucht, dies selbst zu tun, so würde ich dachte, ich frage, um zu sehen, ob es ein in der Bibliothek Funktion eingebaut war, die helfen könnte.

Answer 1

funktioniert nicht mit Negativen arbeiten.

vector<int> convert(int x) { 
    vector<int> ret; 
    while(x) { 
    if (x&1) 
     ret.push_back(1); 
    else 
     ret.push_back(0); 
    x>>=1; 
    } 
    reverse(ret.begin(),ret.end()); 
    return ret; 
} 

Answer 2

Die Bit zum schlechtesten integer weltweit als Byte-Konverter:

#include <algorithm> 
#include <functional> 
#include <iterator> 
#include <stdlib.h> 

class zero_ascii_iterator: public std::iterator<std::input_iterator_tag, char> 
{ 
public: 
    zero_ascii_iterator &operator++() 
    { 
     return *this; 
    } 

    char operator *() const 
    { 
     return '0'; 
    } 
}; 


char bits[33]; 

_itoa(value, bits, 2); 
std::transform(
    bits, 
    bits + strlen(bits), 
    zero_ascii_iterator(), 
    bits, 
    std::minus<char>()); 

Answer 3

Hier ist eine Version, die mit negativen Zahlen funktioniert:

string get_bits(unsigned int x) 
{ 
    string ret; 
    for (unsigned int mask=0x80000000; mask; mask>>=1) { 
    ret += (x & mask) ? "1" : "0"; 
    } 
    return ret; 
} 

Der String kann natürlich ersetzt werden, durch einen Vektor oder indiziert für Bit-Werte.

Answer 4

Eine Änderung der Antwort des DCP. Das Verhalten ist eine Implementierung, die für negative Werte von t definiert ist. Es liefert alle Bits, sogar die führenden Nullen. Standard Einsprüche auf die Verwendung von std::vector<bool> bezogen und es keine richtige Behälter zu sein.

#include <vector> //for std::vector 
#include <algorithm> //for std::reverse 
#include <climits> //for CHAR_BIT 

template<typename T> 
std::vector<bool> convert(T t) { 
    std::vector<bool> ret; 
    for(unsigned int i = 0; i < sizeof(T) * CHAR_BIT; ++i, t >>= 1) 
    ret.push_back(t & 1); 
    std::reverse(ret.begin(), ret.end()); 
    return ret; 
} 

Und eine Version, die auch mit Fließkommawerten arbeiten könnte. Und möglicherweise andere POD-Typen. Das habe ich noch nicht wirklich getestet. Es könnte für negative Werte besser funktionieren, oder es könnte schlechter funktionieren. Ich habe nicht viel darüber nachgedacht.

template<typename T> 
std::vector<bool> convert(T t) { 
    union { 
    T obj; 
    unsigned char bytes[sizeof(T)]; 
    } uT; 
    uT.obj = t; 

    std::vector<bool> ret; 
    for(int i = sizeof(T)-1; i >= 0; --i) 
    for(unsigned int j = 0; j < CHAR_BIT; ++j, uT.bytes[i] >>= 1) 
     ret.push_back(uT.bytes[i] & 1); 
    std::reverse(ret.begin(), ret.end()); 
    return ret; 
} 

Answer 5

Gibt eine Zeichenfolge anstelle eines Vektors, aber leicht geändert werden kann.

template<typename T> 
std::string get_bits(T value) { 
    int size = sizeof(value) * CHAR_BIT; 
    std::string ret; 
    ret.reserve(size); 
    for (int i = size-1; i >= 0; --i) 
     ret += (value & (1 << i)) == 0 ? '0' : '1'; 
    return ret; 
} 

Answer 6

Es ist nicht zu hart mit einem Einzeiler zu lösen, aber es ist eigentlich eine Standard-Bibliothek Lösung.

#include <bitset> 
#include <algorithm> 

std::vector<int> get_bits(unsigned long x) { 
    std::string chars(std::bitset< sizeof(long) * CHAR_BIT >(x) 
     .to_string< char, std::char_traits<char>, std::allocator<char> >()); 
    std::transform(chars.begin(), chars.end(), 
     std::bind2nd(std::minus<char>(), '0')); 
    return std::vector<int>(chars.begin(), chars.end()); 
} 

C++ 0x macht es sogar einfacher!

#include <bitset> 

std::vector<int> get_bits(unsigned long x) { 
    std::string chars(std::bitset< sizeof(long) * CHAR_BIT >(x) 
     .to_string(char(0), char(1))); 
    return std::vector<int>(chars.begin(), chars.end()); 
} 

Dies ist eine der bizarreren Ecken der Bibliothek. Vielleicht war das, woran sie fuhren, die Serialisierung.

cout << bitset<8>(x) << endl; // print 8 low-order bits of x