Как преобразовать int в двоичное строковое представление в С++

У меня есть int, который я хочу сохранить как двоичное строковое представление. Как это можно сделать?

Ответ 1

Попробуйте следующее:

#include <bitset>
#include <iostream>
int main()
{
    std::bitset<32>      x(23456);
    std::cout << x << "\n";


    // If you don't want a variable just create a temporary.
    std::cout << std::bitset<32>(23456) << "\n";
}

Ответ 2

У меня есть int, который я хочу сначала преобразовать в двоичный номер.

Что именно это означает? Нет типа "двоичное число". Ну, int уже представлен в двоичной форме внутри, если вы не используете очень странный компьютер, но что деталь реализации - концептуально, это просто целое число.

Каждый раз, когда вы печатаете номер на экране, его необходимо преобразовать в строку символов. Так получилось, что большинство систем ввода/вывода выбрали десятичное представление для этого процесса, чтобы люди имели более легкое время. Но нет ничего принципиально десятичного в int.

В любом случае, чтобы создать базовое представление b целого числа x, просто следуйте этому алгоритму:

инициализируйте s пустой строкой
m = x % b
x = x / b
Преобразуйте m в цифру, d.
Добавить d в s.
Если x не равно нулю, перейдите к шагу 2.
Обратный s

Шаг 4 легко, если b <= 10 и ваш компьютер использует кодировку символов, где цифры 0-9 смежны, потому что тогда это просто d = '0' + m. В противном случае вам нужна таблица поиска.

Шаги 5 и 7 могут быть упрощены для добавления d слева от s, если вы заранее знаете, сколько места вам понадобится и начните с правого конца строки.

В случае b == 2 (например, двоичное представление) шаг 2 можно упростить до m = x & 1, а шаг 3 можно упростить до x = x >> 1.

Решение с `reverse`:

#include <string>
#include <algorithm>

std::string binary(unsigned x)
{
    std::string s;
    do
    {
        s.push_back('0' + (x & 1));
    } while (x >>= 1);
    std::reverse(s.begin(), s.end());
    return s;
}

Решение без `reverse`:

#include <string>

std::string binary(unsigned x)
{
    // Warning: this breaks for numbers with more than 64 bits
    char buffer[64];
    char* p = buffer + 64;
    do
    {
        *--p = '0' + (x & 1);
    } while (x >>= 1);
    return std::string(p, buffer + 64);
}

Ответ 3

http://snippets.dzone.com/posts/show/4716 или http://www.phanderson.com/printer/bin_disp.html являются двумя хорошими примерами.

Основной принцип простого подхода:

Петля до тех пор, пока # не будет 0
& (побитовое и) # с 1. Распечатайте результат (1 или 0) до конца буфера строк.
Сдвиньте # на 1 бит, используя >>=.
Повторить цикл
Печать обратного буфера строк

Чтобы избежать изменения строки или вам нужно ограничить себя #s, устанавливая длину строки буфера, вы можете:

Вычислить потолок (log2 (N)) - сказать L
Маска вычисления = 2 ^ L
Петля до маски == 0:
- & (побитовое) и маску С#. Распечатайте результат (1 или 0).
- number & = (mask-1)
- mask → = 1 (разделите на 2)

Ответ 4

Я предполагаю, что это связано с вашим другим вопросом о расширяемом хешировании.

Сначала определите некоторые мнемоники для ваших бит:

const int FIRST_BIT = 0x1;
const int SECOND_BIT = 0x2;
const int THIRD_BIT = 0x4;

Затем у вас есть номер, который вы хотите преобразовать в битовую строку:

int x = someValue;

Вы можете проверить, установлен ли бит с помощью логического оператора &.

if(x & FIRST_BIT)
{
    // The first bit is set.
}

И вы можете сохранить std::string и добавить 1 к этой строке, если бит установлен, и вы добавляете 0, если бит не установлен. В зависимости от того, какой порядок вам нужен, вы можете начать с последнего бита и перейти к первому или только к последнему.

Вы можете реорганизовать это в цикл и использовать его для чисел произвольного размера, вычислив мнемонические биты выше, используя current_bit_value <= lt = 1 после каждой итерации.

Ответ 5

И число с 100000..., затем 010000..., 0010000... и т.д. Каждый раз, если результат равен 0, поместите '0' в массив char, иначе установите ' 1'.

int numberOfBits = sizeof(int) * 8;
char binary[numberOfBits + 1];
int decimal = 29;

for(int i = 0; i < numberOfBits; ++i) {
    if ((decimal & (0x80000000 >> i)) == 0) {
        binary[i] = '0';
    } else {
        binary[i] = '1';
    }
}
binary[numberOfBits] = '\0';
string binaryString(binary);

Ответ 6

Нет прямой функции, вы можете просто пройти по битам int (подсказка см. → ) и вставить в строку "1" или "0".
Похоже на вопрос о стандартном интервью/домашнем задании

Ответ 7

Используйте функцию sprintf для сохранения форматированного вывода в строковой переменной вместо printf для прямой печати. Обратите внимание, однако, что эти функции работают только с строками C, а не с С++-строками.

Ответ 8

Там небольшая библиотека только для заголовков, которую вы можете использовать для этого здесь.

Пример:

std::cout << ConvertInteger<Uint32>::ToBinaryString(21);
// Displays  "10101"

auto x = ConvertInteger<Int8>::ToBinaryString(21, true);
std::cout << x << "\n"; // displays "00010101"

auto x = ConvertInteger<Uint8>::ToBinaryString(21, true, "0b");
std::cout << x << "\n"; // displays "0b00010101"

Ответ 9

Решение без реверса, без дополнительной копии и с 0-отступом:

#include <iostream>
#include <string>

template <short WIDTH>
std::string binary( unsigned x )
{
    std::string buffer( WIDTH, '0' );
    char *p = &buffer[ WIDTH ];

    do {
        --p;
        if (x & 1) *p = '1';
    }
    while (x >>= 1);

    return buffer;
}

int main()
{
    std::cout << "'" << binary<32>(0xf0f0f0f0) << "'" << std::endl;
    return 0;
}

Ответ 10

Это моя лучшая реализация преобразования целых чисел (любого типа) в std :: string. Вы можете удалить шаблон, если собираетесь использовать его только для одного целочисленного типа. Насколько мне известно, я думаю, что существует хороший баланс между безопасностью C++ и загадочной природой C. Обязательно включите необходимые заголовки.

template<typename T>
std::string bstring(T n){
    std::string s;
    for(int m = sizeof(n) * 8;m--;){
            s.push_back('0'+((n >> m) & 1));
    }
    return s;
}

Используйте это так,

std::cout << bstring<size_t>(371) << '\n';

Это вывод на моем компьютере (он отличается на каждом компьютере),

0000000000000000000000000000000000000000000000000000000101110011

Обратите внимание, что вся двоичная строка копируется и, следовательно, дополняются нулями, что помогает представлять размер в битах. Таким образом, длина строки равна размеру size_t в битах.

Давайте попробуем подписать целое число (отрицательное число),

std::cout << bstring<signed int>(-1) << '\n';

Это вывод на моем компьютере (как указано, он отличается на каждом компьютере),

11111111111111111111111111111111

Обратите внимание, что теперь строка стала меньше, это доказывает, что знак int занимает меньше места, чем size_t. Как вы можете видеть, мой компьютер использует метод 2 дополнения для представления целых чисел со знаком (отрицательные числа). Теперь вы можете понять, почему unsigned short(-1) > signed int(1)

Вот версия, созданная только для целых чисел со знаком, чтобы сделать эту функцию без шаблонов, т.е. Использовать ее, если вы хотите преобразовать целые числа со знаком в строку.

std::string bstring(int n){
    std::string s;
    for(int m = sizeof(n) * 8;m--;){
            s.push_back('0'+((n >> m) & 1));
    }
    return s;
}