Convertir entero a cadena binaria usando ITOA en C / C ++

Question

¿Puedo usar itoa() para convertir largos largos en una cadena binaria? He visto varios ejemplos para la conversión de int a binario utilizando itoa.¿Existe un riesgo de desbordamiento o quizás la pérdida de precisión, si utilizo un largo largo y largo?

Editar- Gracias a todos ustedes por responder.Logré lo que estaba tratando de hacer.ITOA () no fue lo suficientemente útil, ya que no es compatible con un largo largo largo. Además, no puedo usar ITOAA () en GCC, ya que no es una función de la biblioteca estándar.

Answer 1

Para convertir un entero a una cadena que contiene solo dígitos binarios, puede hacerlo revisando cada bit en el entero con una máscara de un bit y agreguela a la cadena.

algo como esto:

std::string convert_to_binary_string(const unsigned long long int value,
                                     bool skip_leading_zeroes = false)
{
    std::string str;
    bool found_first_one = false;
    const int bits = sizeof(unsigned long long) * 8;  // Number of bits in the type

    for (int current_bit = bits - 1; current_bit >= 0; current_bit--)
    {
        if ((value & (1ULL << current_bit)) != 0)
        {
            if (!found_first_one)
                found_first_one = true;
            str += '1';
        }
        else
        {
            if (!skip_leading_zeroes || found_first_one)
                str += '0';
        }
    }

    return str;
}

Editar:

Una forma más general de hacerlo podría hacerse con plantillas:

#include <type_traits>
#include <cassert>

template<typename T>
std::string convert_to_binary_string(const T value, bool skip_leading_zeroes = false)
{
    // Make sure the type is an integer
    static_assert(std::is_integral<T>::value, "Not integral type");

    std::string str;
    bool found_first_one = false;
    const int bits = sizeof(T) * 8;  // Number of bits in the type

    for (int current_bit = bits - 1; current_bit >= 0; current_bit--)
    {
        if ((value & (1ULL << current_bit)) != 0)
        {
            if (!found_first_one)
                found_first_one = true;
            str += '1';
        }
        else
        {
            if (!skip_leading_zeroes || found_first_one)
                str += '0';
        }
    }

    return str;
}

Nota: ambos static_assert y std::is_integral es parte de C ++ 11, pero se admite tanto en Visual C ++ 2010 como en GCC de al menos 4.4.5.

Answer 2

Sí, puedes.Como usted se mostró a ti mismo , ITOA se puede llamar con la base 2, lo que significa binario.

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

int main()
{
    int i;
    char str[33];

    i = 37; /* Just some number. */
    itoa (i, str, 2);
    printf("binary: %s\n", str);

    return 0;
}

Además, sí, habrá un truncamiento si usa un tipo de entero más grande que int, ya que ITOA () solo toma "int" solo como un valor.Largo largo está en su compilador, probablemente de 64 bits, mientras que INT es probablemente de 32 bits, por lo que el compilador truncará el valor de 64 bits a un valor de 32 bits antes de la conversión.

Answer 3

Tu redacción es un poco confusa, Normalmente, si establece "decimal", lo tomaría para significar: 'Un número representado como una cadena de dígitos decimales', mientras parece significar 'entero'.

y con 'binario' que tomaría eso para significar: 'Un número representado como bytes, como directamente utilizable por la CPU ".

Una mejor manera de expresar su asignatura sería: convertir el entero de 64 bits a cadena de dígitos binarios.

Algunos sistemas tienen una función _i64toa.

Answer 4

La forma estándar de convertir a long long es strtoull() y std::strtoull() para C y C ++ respectivamente

Ejemplo en CPPreference

#include <iostream>
#include <cstdlib>

int main()
{
    const char* begin = "10 200000000000000000000000000000 30 40";
    char *end;
    for (unsigned long i = std::strtoul(begin, &end, 10);
         begin != end;
         i = std::strtoul(begin, &end, 10))
    {
        begin = end;
        if (errno == ERANGE){
            std::cout << "range error\n";
            errno = 0;
        }    
        std::cout << i << '\n';
    }
}