Мне нужно работать с двоичным числом.
Я пробовал писать:
const x = 00010000;
Но это не сработало.
Я знаю, что я могу использовать шестнадцатеричное число, имеющее то же значение, что и 00010000, но я хочу знать, есть ли тип в С++ для двоичных чисел, а если нет, есть ли еще одно решение для моего проблема?
Вы можете использовать BOOST_BINARY во время ожидания С++ 0x. :) BOOST_BINARY, возможно, имеет преимущество перед реализацией шаблонов, поскольку его можно использовать и в программах на C (он на 100% управляется препроцессором.)
Чтобы сделать обратное (то есть распечатать число в двоичной форме), вы можете использовать непереносимую функцию itoa или реализовать свою собственную.
К сожалению, вы не можете выполнить форматирование базы 2 с потоками STL (поскольку setbase будет учитывать только базы 8, 10 и 16), но вы можете использовать либо версию std::string itoa, либо ( более кратким, но несколько менее эффективным) std::bitset.
#include <boost/utility/binary.hpp>
#include <stdio.h>
#include <stdlib.h>
#include <bitset>
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
unsigned short b = BOOST_BINARY( 10010 );
char buf[sizeof(b)*8+1];
printf("hex: %04x, dec: %u, oct: %06o, bin: %16s\n", b, b, b, itoa(b, buf, 2));
cout << setfill('0') <<
"hex: " << hex << setw(4) << b << ", " <<
"dec: " << dec << b << ", " <<
"oct: " << oct << setw(6) << b << ", " <<
"bin: " << bitset< 16 >(b) << endl;
return 0;
}
производит:
hex: 0012, dec: 18, oct: 000022, bin: 10010
hex: 0012, dec: 18, oct: 000022, bin: 0000000000010010
Также прочитайте Херба Саттера The String Formatters of Manor Farm для интересного обсуждения.
Если вы используете GCC, вы можете использовать расширение GCC (которое включено в стандарт С++ 14):
int x = 0b00010000;
Вы можете использовать бинарные литералы. Они стандартизованы в С++ 14. Например,
int x = 0b11000;
Поддержка в GCC началась в GCC 4.3 (см. https://gcc.gnu.org/gcc-4.3/changes.html) в качестве расширений для семейства языков C (см. https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html#C-Extensions), но поскольку GCC 4.9 теперь распознается либо как функция С++ 14, либо расширение (см. Разница между бинарными литералами GCC и С++ 14?
Поддержка в Visual Studio началась с предварительного просмотра Visual Studio 2015 (см. https://www.visualstudio.com/news/vs2015-preview-vs#C++).
template<unsigned long N>
struct bin {
enum { value = (N%10)+2*bin<N/10>::value };
} ;
template<>
struct bin<0> {
enum { value = 0 };
} ;
// ...
std::cout << bin<1000>::value << '\n';
Самая левая цифра литерала все равно должна быть 1, но тем не менее.
Несколько компиляторов (как правило, для микроконтроллеров) имеет специальную функцию, реализованную в распознавании буквенных двоичных чисел префиксом "0b..." предшествующий числу, хотя большинство компиляторов (стандарты C/С++) не имеют такой функции, и, если это так, здесь это мое альтернативное решение:
#define B_0000 0
#define B_0001 1
#define B_0010 2
#define B_0011 3
#define B_0100 4
#define B_0101 5
#define B_0110 6
#define B_0111 7
#define B_1000 8
#define B_1001 9
#define B_1010 a
#define B_1011 b
#define B_1100 c
#define B_1101 d
#define B_1110 e
#define B_1111 f
#define _B2H(bits) B_##bits
#define B2H(bits) _B2H(bits)
#define _HEX(n) 0x##n
#define HEX(n) _HEX(n)
#define _CCAT(a,b) a##b
#define CCAT(a,b) _CCAT(a,b)
#define BYTE(a,b) HEX( CCAT(B2H(a),B2H(b)) )
#define WORD(a,b,c,d) HEX( CCAT(CCAT(B2H(a),B2H(b)),CCAT(B2H(c),B2H(d))) )
#define DWORD(a,b,c,d,e,f,g,h) HEX( CCAT(CCAT(CCAT(B2H(a),B2H(b)),CCAT(B2H(c),B2H(d))),CCAT(CCAT(B2H(e),B2H(f)),CCAT(B2H(g),B2H(h)))) )
// Using example
char b = BYTE(0100,0001); // Equivalent to b = 65; or b = 'A'; or b = 0x41;
unsigned int w = WORD(1101,1111,0100,0011); // Equivalent to w = 57155; or w = 0xdf43;
unsigned long int dw = DWORD(1101,1111,0100,0011,1111,1101,0010,1000); //Equivalent to dw = 3745774888; or dw = 0xdf43fd28;
Недостатки (это не такие большие):
<сильные > Преимущества:
spending processor time в бессмысленных операциях (like "?.. :..", "<<", "+") в исполняемую программу (это может выполняться сто раз в конечном приложении);"mainly in C" и С++ (template+enum solution works only in C++ compilers);"enum solution" (usually 255 = reach enum definition limit), иначе говоря, ограничения "буквальной константы", в компиляторе разрешено большее число;several header files (в большинстве случаев они не легко читаемы и понятны, а делают проект излишне запутанным и расширенным, например, используя "BOOST_BINARY()");Этот поток может помочь.
/* Helper macros */
#define HEX__(n) 0x##n##LU
#define B8__(x) ((x&0x0000000FLU)?1:0) \
+((x&0x000000F0LU)?2:0) \
+((x&0x00000F00LU)?4:0) \
+((x&0x0000F000LU)?8:0) \
+((x&0x000F0000LU)?16:0) \
+((x&0x00F00000LU)?32:0) \
+((x&0x0F000000LU)?64:0) \
+((x&0xF0000000LU)?128:0)
/* User macros */
#define B8(d) ((unsigned char)B8__(HEX__(d)))
#define B16(dmsb,dlsb) (((unsigned short)B8(dmsb)<<8) \
+ B8(dlsb))
#define B32(dmsb,db2,db3,dlsb) (((unsigned long)B8(dmsb)<<24) \
+ ((unsigned long)B8(db2)<<16) \
+ ((unsigned long)B8(db3)<<8) \
+ B8(dlsb))
#include <stdio.h>
int main(void)
{
// 261, evaluated at compile-time
unsigned const number = B16(00000001,00000101);
printf("%d \n", number);
return 0;
}
Это работает! (Все кредиты отправляются Тому Торфсу.)
Как уже было сказано, стандарты C не имеют возможности напрямую писать двоичные числа. Однако есть расширения компилятора, и, судя по всему, С++ 14 содержит префикс 0b для двоичного кода. (Обратите внимание, что этот ответ был первоначально опубликован в 2010 году.)
Одним из распространенных способов решения проблемы является включение файла заголовка со вспомогательными макросами. Один простой вариант - также создать файл, который включает определения макросов для всех 8-битных шаблонов, например:
#define B00000000 0
#define B00000001 1
#define B00000010 2
…
Это приводит только к 256 #define s, и если требуется больше 8-битных двоичных констант, эти определения могут быть объединены со сдвигами и OR, возможно, с вспомогательными макросами (например, BIN16(B00000001,B00001010)). (Наличие индивидуальных макросов для каждого 16-битного, не говоря уже о 32-битном значении, не правдоподобно.)
Конечно, недостатком является то, что этот синтаксис требует записи всех ведущих нулей, но это также может сделать его более понятным для использования, например, для установки бит-бит и содержимого аппаратных регистров. Для функционально-подобного макроса, приводящего к синтаксису без этого свойства, см. Ссылку bithacks.h, приведенную выше.
Сверхпромышленное мышление С++ уже хорошо отражено в других ответах здесь. Здесь моя попытка сделать это с помощью C, keep-it-simple-ffs mindset:
unsigned char x = 0xF; // binary: 00001111
C не имеет встроенной записи для чистых двоичных чисел. Лучше всего здесь будет восьмеричный (например, 07777) шестнадцатеричный (например, 0xfff).
Вы можете использовать найденную функцию в этом вопросе, чтобы получить до 22 бит на С++. Здесь код из ссылки, соответствующим образом отредактированный:
template< unsigned long long N >
struct binary
{
enum { value = (N % 8) + 2 * binary< N / 8 > :: value } ;
};
template<>
struct binary< 0 >
{
enum { value = 0 } ;
};
Итак, вы можете сделать что-то вроде binary<0101011011>::value.
Самая маленькая единица, с которой вы можете работать, - это байт (который имеет тип char). Вы можете работать с битами, хотя с помощью побитовых операторов.
Как и для целочисленных литералов, вы можете работать только с десятичными (базовыми 10), восьмеричными (базовыми 8) или шестнадцатеричными (базовыми 16) числами. В C или С++ нет бинарных (базовых 2) литералов.
Октальные числа имеют префикс 0, а шестнадцатеричные числа имеют префикс 0x. Десятичные числа не имеют префикса.
В С++ 0x вы сможете сделать то, что хотите, через пользовательские литералы.
На основании некоторых других ответов, но этот будет отклонять программы с незаконными бинарными литералами. Ведущие нули являются необязательными.
template<bool> struct BinaryLiteralDigit;
template<> struct BinaryLiteralDigit<true> {
static bool const value = true;
};
template<unsigned long long int OCT, unsigned long long int HEX>
struct BinaryLiteral {
enum {
value = (BinaryLiteralDigit<(OCT%8 < 2)>::value && BinaryLiteralDigit<(HEX >= 0)>::value
? (OCT%8) + (BinaryLiteral<OCT/8, 0>::value << 1)
: -1)
};
};
template<>
struct BinaryLiteral<0, 0> {
enum {
value = 0
};
};
#define BINARY_LITERAL(n) BinaryLiteral<0##n##LU, 0x##n##LU>::value
Пример:
#define B BINARY_LITERAL
#define COMPILE_ERRORS 0
int main (int argc, char ** argv) {
int _0s[] = { 0, B(0), B(00), B(000) };
int _1s[] = { 1, B(1), B(01), B(001) };
int _2s[] = { 2, B(10), B(010), B(0010) };
int _3s[] = { 3, B(11), B(011), B(0011) };
int _4s[] = { 4, B(100), B(0100), B(00100) };
int neg8s[] = { -8, -B(1000) };
#if COMPILE_ERRORS
int errors[] = { B(-1), B(2), B(9), B(1234567) };
#endif
return 0;
}
Вы также можете использовать встроенную сборку следующим образом:
int i;
__asm {
mov eax, 00000000000000000000000000000000b
mov i, eax
}
std::cout << i;
Хорошо, это может быть несколько излишним, но это работает.
"Тип" двоичного числа совпадает с любым десятичным, шестнадцатеричным или восьмеричным числом: int (или даже char, короткий, длинный).
Когда вы назначаете константу, вы не можете назначить ее 11011011 (любопытно и, к сожалению), но вы можете использовать hex. Hex немного легче мысленно перевести. Chunk in nibbles (4 бит) и перевести на символ в [0-9a-f].
Вы можете использовать битовый набор
bitset<8> b(string("00010000"));
int i = (int)(bs.to_ulong());
cout<<i;
Я продлил хороший ответ, данный @renato-chandelier, обеспечив поддержку:
_NIBBLE_(…) - 4 бит, 1 nibble в качестве аргумента_BYTE_(…) - 8 бит, 2 nibbles в качестве аргументов_SLAB_(…) - 12 бит, 3 глыбы в качестве аргументов_WORD_(…) - 16 бит, 4 глыбы в качестве аргументов_QUINTIBBLE_(…) - 20 бит, 5 кусков в качестве аргументов_DSLAB_(…) - 24 бит, 6 кусков в качестве аргументов_SEPTIBBLE_(…) - 28 бит, 7 глаголов в качестве аргументов_DWORD_(…) - 32 бита, 8 глаголов в качестве аргументовЯ действительно не так уверен в терминах "quintibble" и "septibble". Если кто-нибудь знает какую-либо альтернативу, пожалуйста, дайте мне знать.
Вот макрос, переписанный:
#define __CAT__(A, B) A##B
#define _CAT_(A, B) __CAT__(A, B)
#define __HEX_0000 0
#define __HEX_0001 1
#define __HEX_0010 2
#define __HEX_0011 3
#define __HEX_0100 4
#define __HEX_0101 5
#define __HEX_0110 6
#define __HEX_0111 7
#define __HEX_1000 8
#define __HEX_1001 9
#define __HEX_1010 a
#define __HEX_1011 b
#define __HEX_1100 c
#define __HEX_1101 d
#define __HEX_1110 e
#define __HEX_1111 f
#define _NIBBLE_(N1) _CAT_(0x, _CAT_(__HEX_, N1))
#define _BYTE_(N1, N2) _CAT_(_NIBBLE_(N1), _CAT_(__HEX_, N2))
#define _SLAB_(N1, N2, N3) _CAT_(_BYTE_(N1, N2), _CAT_(__HEX_, N3))
#define _WORD_(N1, N2, N3, N4) _CAT_(_SLAB_(N1, N2, N3), _CAT_(__HEX_, N4))
#define _QUINTIBBLE_(N1, N2, N3, N4, N5) _CAT_(_WORD_(N1, N2, N3, N4), _CAT_(__HEX_, N5))
#define _DSLAB_(N1, N2, N3, N4, N5, N6) _CAT_(_QUINTIBBLE_(N1, N2, N3, N4, N5), _CAT_(__HEX_, N6))
#define _SEPTIBBLE_(N1, N2, N3, N4, N5, N6, N7) _CAT_(_DSLAB_(N1, N2, N3, N4, N5, N6), _CAT_(__HEX_, N7))
#define _DWORD_(N1, N2, N3, N4, N5, N6, N7, N8) _CAT_(_SEPTIBBLE_(N1, N2, N3, N4, N5, N6, N7), _CAT_(__HEX_, N8))
И вот пример Ренато:
char b = _BYTE_(0100, 0001); /* equivalent to b = 65; or b = 'A'; or b = 0x41; */
unsigned int w = _WORD_(1101, 1111, 0100, 0011); /* equivalent to w = 57155; or w = 0xdf43; */
unsigned long int dw = _DWORD_(1101, 1111, 0100, 0011, 1111, 1101, 0010, 1000); /* Equivalent to dw = 3745774888; or dw = 0xdf43fd28; */
Просто используйте стандартную библиотеку в C++:
#include <bitset>
Вам нужна переменная типа std::bitset:
std::bitset<8ul> x;
x = std::bitset<8>(10);
for (int i = x.size() - 1; i >= 0; i--) {
std::cout << x[i];
}
В этом примере я сохранил двоичную форму 10 в x.
8ul определяет размер ваших битов, поэтому 7ul означает семь битов и так далее.
C++ предоставляет стандартный шаблон с именем std::bitset. Попробуйте, если хотите.
Вы можете попробовать использовать массив bool:
bool i[8] = {0,0,1,1,0,1,0,1}