C++ 将整数转换为位表示

如何将整数转换为其位表示形式。我想取一个整数并返回一个向量，该向量包含整数位表示的1和0

---

我自己做这件事花了很长时间，所以我想问一下是否有一个内置的库函数可以提供帮助。

不适用于底片

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;
}

矢量转换（int x）{
向量ret；
while（x）{
如果（x&1）
后推（1）；
其他的
反向推回（0）；
x> >=1；
}
反向（反向开始（），反向结束（））；
返回ret；
}

世界上最差的整数到位字节转换器：

#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>());

#包括
#包括
#包括
#包括
零类ascii迭代器：公共std:：迭代器
{
公众：
零ascii迭代器和运算符++（）
{
归还*这个；
}
字符运算符*（）常量
{
返回“0”；
}
};
字符位[33]；
_itoa（值，位，2）；
std:：transform(
位，
位+strlen（位），
零ascii迭代器（），
位，
std：：负（））；

这是一个适用于负数的版本：

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

---

当然，字符串可以用向量替换，也可以为位值编制索引。

对DCP答案的修改。该行为是为t的负值定义的实现。它提供所有位，甚至前导零。与

std:：vector

的使用相关的标准注意事项，它不是一个合适的容器

#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;
}

#包含//用于std:：vector
#include//for std:：reverse
#包括//字符位
模板
标准：：向量转换（T）{
std：：载体ret；
for（无符号整数i=0；i>=1）
后推（t&1）；
反向（反向开始（），反向结束（））；
返回ret；
}

还有一个版本，也可以使用浮点值。可能还有其他类型的豆荚。我还没有真正测试过这个。它可能对负值更好，也可能更糟。我没怎么想

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;
}

模板
标准：：向量转换（T）{
联合{
T-obj；
无符号字符字节[sizeof（T）]；
}uT；
uT.obj=t；
std：：载体ret；
对于（int i=sizeof（T）-1；i>=0；--i）
for（无符号整数j=0；j>=1）
ret.push_back（uT.bytes[i]&1）；
反向（反向开始（），反向结束（））；
返回ret；
}

返回字符串而不是向量，但很容易更改

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;
}

模板
std:：字符串获取_位（T值）{
int size=sizeof（值）*字符位；
std：：字符串ret；
净储备（规模）；
对于（int i=size-1；i>=0；--i）
ret+=（value&（1用一个线性函数求解并不太难，但实际上有一个标准的库解决方案

#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() );
}

#包括
#包括
std:：vectorget_位（无符号长x）{
标准：：字符串字符（标准：：位集（x）
.to_string（））；
std:：transform（chars.begin（），chars.end（），
std:：bind2nd（std:：减号（），'0'）；
返回std:：vector（chars.begin（），chars.end（））；
}

C++0x甚至使它更容易

#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() );
}

#包括
std:：vectorget_位（无符号长x）{
标准：：字符串字符（标准：：位集（x）
.to_字符串（char（0），char（1））；
返回std:：vector（chars.begin（），chars.end（））；
}

这是图书馆中更奇怪的角落之一。也许他们真正想要的是序列化

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

cout（x）我想你指的是位表示法。既然一个整数是固定大小的，为什么不使用一个简单的数组呢？@bobber205：你可能想编辑你的问题以避免进一步的混淆。如果你能构造一个位集，它已经有一个to_字符串方法来创建0和1的序列。不幸的是，没有from_-ulong方法，即使它们有e to_ulong.Many thanks！：）我现在可以按照我最初打算的方式实现算法了。：DOr
do ret.push_back（x&1）while（x>>=1）；
-这个版本为零输入返回零位。哇。我想知道为什么Perl会因为不可理解而名声大噪=）绝对值得@Codinghoror拥有专属空间。这是一个来自现实生活的例子？我希望不是。我想在不使用boost:：bind（…）的情况下写这篇文章。Endianess可能会在第二篇文章中出现，嗯？哦，好吧。