Can I use a binary literal in C or C

Question

I need to work with a binary number   I tried writing   const x   00010000    But it didn t work   I know that I can use an hexadecimal number that has the same value as 00010000  but I want to know if there is a type in C   for binary numbers and if there isn t  is there another solution for my problem

User · Answer

Based on some other answers  but this one will reject programs with illegal binary literals  Leading zeroes are optional   template lt bool gt  struct BinaryLiteralDigit   template lt  gt  struct BinaryLiteralDigit lt true gt        static bool const value   true      template lt unsigned long long int OCT  unsigned long long int HEX gt  struct BinaryLiteral       enum           value    BinaryLiteralDigit lt  OCT 8  lt  2  gt   value  amp  amp  BinaryLiteralDigit lt  HEX  gt   0  gt   value                OCT 8     BinaryLiteral lt OCT 8  0 gt   value  lt  lt  1                -1             template lt  gt  struct BinaryLiteral lt 0  0 gt        enum           value   0             define BINARY LITERAL n  BinaryLiteral lt 0  n  LU  0x  n  LU gt   value   Example    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

User · Answer

As already answered  the C standards have no way to directly write binary numbers  There are compiler extensions  however  and apparently C  14 includes the 0b prefix for binary   Note that this answer was originally posted in 2010    One popular workaround is to include a header file with helper macros  One easy option is also to generate a file that includes macro definitions for all 8-bit patterns  e g     define B00000000 0  define B00000001 1  define B00000010 2       This results in only 256  defines  and if larger than 8-bit binary constants are needed  these definitions can be combined with shifts and ORs  possibly with helper macros  e g   BIN16 B00000001 B00001010     Having individual macros for every 16-bit  let alone 32-bit  value is not plausible    Of course the downside is that this syntax requires writing all the leading zeroes  but this may also make it clearer for uses like setting bit flags and contents of hardware registers  For a function-like macro resulting in a syntax without this property  see bithacks h linked above

User · Answer

You can use BOOST BINARY while waiting for C  0x      BOOST BINARY arguably has an advantage over template implementation insofar as it can be used in C programs as well  it is 100  preprocessor-driven    To do the converse  i e  print out a number in binary form   you can use the non-portable itoa function  or implement your own   Unfortunately you cannot do base 2 formatting with STL streams  since setbase will only honour bases 8  10 and 16   but you can use either a std  string version of itoa  or  the more concise  yet marginally less efficient  std  bitset    include  lt boost utility binary hpp gt   include  lt stdio h gt   include  lt stdlib h gt   include  lt bitset gt   include  lt iostream gt   include  lt iomanip gt   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  lt  lt  setfill  0    lt  lt       hex     lt  lt  hex  lt  lt  setw 4   lt  lt  b  lt  lt        lt  lt       dec     lt  lt  dec  lt  lt  b  lt  lt        lt  lt       oct     lt  lt  oct  lt  lt  setw 6   lt  lt  b  lt  lt        lt  lt       bin     lt  lt  bitset lt  16  gt  b   lt  lt  endl    return 0      produces   hex  0012  dec  18  oct  000022  bin             10010 hex  0012  dec  18  oct  000022  bin  0000000000010010   Also read Herb Sutter s The String Formatters of Manor Farm for an interesting discussion

User · Answer

The smallest unit you can work with is a byte  which is of char type    You can work with bits though by using bitwise operators    As for integer literals  you can only work with decimal  base 10   octal  base 8  or hexadecimal  base 16  numbers   There are no binary  base 2  literals in C nor C       Octal numbers are prefixed with 0 and hexadecimal numbers are prefixed with 0x   Decimal numbers have no prefix   In C  0x you ll be able to do what you want by the way via user defined literals

User · Answer

You can use a bitset  bitset lt 8 gt  b string  00010000     int i    int  bs to ulong     cout lt  lt i

User · Answer

I extended the good answer given by  renato-chandelier by ensuring the support of     NIBBLE           4 bits  1 nibble as argument  BYTE           8 bits  2 nibbles as arguments  SLAB           12 bits  3 nibbles as arguments  WORD           16 bits  4 nibbles as arguments  QUINTIBBLE           20 bits  5 nibbles as arguments  DSLAB           24 bits  6 nibbles as arguments  SEPTIBBLE           28 bits  7 nibbles as arguments  DWORD           32 bits  8 nibbles as arguments   I am actually not so sure about the terms    quintibble    and    septibble     If anyone knows any alternative please let me know   Here is the macro rewritten    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     And here is Renato s 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

User · Answer

You can use binary literals  They are standardized in C  14  For example   int x   0b11000    Support in GCC  Support in GCC began in GCC 4 3  see https   gcc gnu org gcc-4 3 changes html  as extensions to the C language family  see https   gcc gnu org onlinedocs gcc C-Extensions html C-Extensions   but since GCC 4 9 it is now recognized as either a C  14 feature or an extension  see Difference between GCC binary literals and C  14 ones     Support in Visual Studio  Support in Visual Studio started in Visual Studio 2015 Preview  see https   www visualstudio com news vs2015-preview-vs C

User · Answer

If you are using GCC then you can use a GCC extension  which is included in the C  14 standard  for this   int x   0b00010000

User · Answer

This thread may help      Helper macros     define HEX   n  0x  n  LU  define B8   x    x amp 0x0000000FLU  1 0       x amp 0x000000F0LU  2 0       x amp 0x00000F00LU  4 0       x amp 0x0000F000LU  8 0       x amp 0x000F0000LU  16 0       x amp 0x00F00000LU  32 0       x amp 0x0F000000LU  64 0       x amp 0xF0000000LU  128 0      User macros     define B8 d    unsigned char B8   HEX   d     define B16 dmsb dlsb     unsigned short B8 dmsb  lt  lt 8      B8 dlsb    define B32 dmsb db2 db3 dlsb     unsigned long B8 dmsb  lt  lt 24        unsigned long B8 db2  lt  lt 16        unsigned long B8 db3  lt  lt 8      B8 dlsb      include  lt stdio h gt   int main void           261  evaluated at compile-time     unsigned const number   B16 00000001 00000101        printf   d  n   number       return 0      It works   All the credits go to Tom Torfs

User · Answer

You can also use inline assembly like this   int i     asm       mov eax  00000000000000000000000000000000b     mov i    eax    std  cout  lt  lt  i    Okay  it might be somewhat overkill  but it works

User · Answer

The  type  of a binary number is the same as any decimal  hex or octal number  int  or even char  short  long long    When you assign a constant  you can t assign it with 11011011  curiously and unfortunately   but you can use hex   Hex is a little easier to mentally translate   Chunk in nibbles  4 bits  and translate to a character in  0-9a-f

User · Answer

C does not have native notation for pure binary numbers  Your best bet here would be either octal  e g  07777  of hexadecimal  e g  0xfff

User · Answer

template lt unsigned long N gt  struct bin       enum   value    N 10  2 bin lt N 10 gt   value         template lt  gt  struct bin lt 0 gt        enum   value   0                    std  cout  lt  lt  bin lt 1000 gt   value  lt  lt    n     The leftmost digit of the literal still has to be 1  but nonetheless

User · Answer

The C   over-engineering mindset is already well accounted for in the other answers here  Here s my attempt at doing it with a C  keep-it-simple-ffs mindset   unsigned char x   0xF     binary  00001111

User · Answer

You could try using an array of bool   bool i 8     0 0 1 1 0 1 0 1

User · Answer

C   provides a standard template named std  bitset  Try it if you like

User · Answer

A few compilers  usually the ones for microcontrollers  has a special feature implemented within recognizing literal binary numbers by prefix  0b     preceding the number  although most compilers  C C   standards  don t have such feature and if it is the case  here it is my alternative solution    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    Disadvantages  it s not such a big ones     The binary numbers have to be grouped 4 by 4  The binary literals have to be only unsigned integer numbers    Advantages    Total preprocessor driven  not spending processor time in pointless operations  like              lt  lt         to the executable program  it may be performed hundred of times in the final application   It works  mainly in C  compilers and C   as well  template enum solution works only in C   compilers   It has only the limitation of  longness  for expressing  literal constant  values  There would have been earlyish longness limitation  usually 8 bits  0-255  if one had expressed constant values by parsing resolve of  enum solution   usually 255   reach enum definition limit   differently   literal constant  limitations  in the compiler allows greater numbers  Some other solutions demand exaggerated number of constant definitions  too many defines in my opinion  including long or several header files  in most cases not easily readable and understandable  and make the project become unnecessarily confused and extended  like that using  BOOST BINARY      Simplicity of the solution  easily readable  understandable and adjustable for other cases  could be extended for grouping 8 by 8 too

User · Answer

Just use the standard library in C      include  lt bitset gt    You need a variable of type std  bitset   std  bitset lt 8ul gt  x  x   std  bitset lt 8 gt  10   for  int i   x size   - 1  i  gt   0  i--          std  cout  lt  lt  x i       In this example  I stored the binary form of 10 in x   8ul defines the size of your bits  so 7ul means seven bits and so on

User · Answer

You can use the function found in this question to get up to 22 bits in C     Here s the code from the link  suitably edited   template lt  unsigned long long N  gt  struct binary     enum   value    N   8    2   binary lt  N   8  gt     value         template lt  gt  struct binary lt  0  gt      enum   value   0          So you can do something like binary lt 0101011011 gt   value

[c++] Can I use a binary literal in C or C++?

Examples related to c++

Examples related to c

Examples related to binary