c++ - not - Convirtiendo un int en una base 2 cstring/string

string to int c

Question

En Visual Studio en mi PC puedo usar itoa () para convertir de una base de 10 int a una base de 2 c-string. Sin embargo, cuando estoy en una máquina Linux esa función no es compatible. ¿Hay alguna otra manera rápida de hacer este tipo de conversión? Sé cómo usar una secuencia de cadenas y puedo usar la división y el modding para convertir manualmente a otra base.

Estaba saltando que había una manera más fácil de acceder a la representación binaria de un int.

Answer 1

La solución más sencilla para la string C ++:

std::string to_bin(unsigned int value) {
  if (value == 0) return "0";
  std::string result;
  while (value != 0) {
    result += ''0'' + (value & 1);
    value >>= 1;
  }
  std::reverse(result.begin(), result.end());
  return result;
}

Para diferentes bases (2 <= base <= 36):

std::string to_base(unsigned int value, int base) {
  if (value == 0) return "0";
  std::string result;
  while (value != 0) {
    int digit = value % base;
    result += (digit > 9 ? ''A'' + digit - 10 : digit +''0'');
    value /= base;
  }
  std::reverse(result.begin(), result.end());
  return s;
}

edit: arreglado para números negativos cambiando el argumento de int a unsigned int

Answer 2

Lo mismo en C:

short UtilLitoa(long value, char* str, short base);
void UtilStrReverse(char* begin, char* end);
static const char c36Digits[] =  "0123456789abcdefghijklmnopqrstuvwxyz";

short UtilLitoa(long value, char* str, short base)
 {  
  char* wstr=str;
  int sign;
  unsigned long res;
  /* Validate base */
  if (base<2 || base>36)
   {
    if(str!=NULL)
     *str=''/0'';
    return(0);
   }
  /* Take care of sign */
  if ((sign=value) < 0)
   value = -value;
  res=value;
  /* Conversion. Number is reversed */
  do
   {
    value=(long)res;
    res=res/base;
    if(str!=NULL)
     *wstr = c36Digits[(unsigned long)value-res*base];
    wstr++;
   }
  while(res);
  if(sign<0)
   *wstr++=''-'';
  *wstr=''/0'';
  /* Reverse string */
  UtilStrReverse(str, wstr-1);
  return(wstr-str);
 }

void UtilStrReverse(char* begin, char* end)
{
  char aux;

  if(begin==NULL)
   return;
  if(end==NULL)
   end=begin+strlen(begin)-1;
  while(end>begin)
   {
    aux=*end;
    *end--=*begin;
    *begin++=aux;
   }    
}

Answer 3

Otra versión más

#include <string>
#include <limits>
#include <iostream>

#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)

template <class Number> void toBinaryRepresentation(
    const Number& n,
    std::string& str,
    const bool reverse = false)
{
    std::size_t i,j; // iterators
    const std::size_t numbits = std::numeric_limits<unsigned char>::digits;
    const char *raw = reinterpret_cast<const char*>(&n);
    str.resize(sizeof(n) * numbits);
    for (i = 0; i != sizeof(n); ++i)
    {
        for (j = 0; j < numbits; ++j)
        {
            str[i * numbits + j] = ((raw[i] >> j) & 1) + 48;
        }
    }
    if (reverse == false) std::reverse(str.begin(), str.end());
}

int main(int argc, char *argv[]) {
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0];
        std::cerr << " [int|long|float] [number]" << std::endl;
        return -1;
    }
    #define test_start(type, from_string_to_type)          /
        if (std::strcmp(argv[1], TOSTRING(type)) == 0) {   /
            const type num = from_string_to_type(argv[2]); /
            toBinaryRepresentation(num, binary);           /
            std::cout << binary << std::endl;              /
        }

    #define test(type, from_string_to_type)                   /
        else if (std::strcmp(argv[1], TOSTRING(type)) == 0) { /
            const type num = from_string_to_type(argv[2]);    /
            toBinaryRepresentation(num, binary);              /
            std::cout << binary << std::endl;                 /
        }
    std::string binary;
    test_start(int, std::atoi)
    test(long, std::atol)
    test(float, std::atof)
    #undef test_start
    #undef test
    return 0;
}

Answer 4

Puede usar std::bitset<N> con un N adecuado (por ejemplo, std::numeric_limits<int>::digits ):

std::string bits = std::bitset<10>(value).to_string<std::string>();

Tenga en cuenta que int s solo representa un valor. Ciertamente no son base 10, aunque esta es la base predeterminada utilizada al formatearlos (que pueden cambiarse fácilmente a octales o hexadecimales usando std::oct y std::hex ). En todo caso, los int se representan con la base 2.