There is an unsigned __ int64 Is there a way in C / C++ get the bits line from it?

Answer 1, Authority 100%

For example, like this:

unsigned __int64 num = 100;
Char BUF [64];
_itoa_s (num, buf, 2);
COUT & LT; & LT; buf;

or even so (slightly pervert):

unsigned __int64 num = 100;
STD :: STRING ST = "";
While (NUM)
{
  ST .INSERT (0, NUM & AMP; 1? "1": "0");
  Num & gt; & gt; = 1;
}
COUT & LT; & LT; st.c_str () & lt; & lt; Endl;

Answer 2, Authority 150%

C++: Bitset

C: iToa ()

Answer 3, Authority 150%

If you really have a simple pragmatic task of installing, checking and resetting a bit by its number and 64 bits you enough, you can use simple macros.

Here is an example

# include & lt; stdio.h & gt;
#Include & lt; stdlib.h & gt;
#Include & lt; stdint.h & gt;
#Define Setbit (U, N) ((U) | = ((int64_t) 1 & lt; & lt; (n)))
#Define CLRBIT (U, N) ((U) & amp; = ~ ((int64_t) 1 & lt; & lt; (n)))
#Define TSTBIT (U, N) ((U) & amp; ((int64_t) 1 & lt; & lt; (n)))
int.
Main ()
{
 uint64_t x = 0;
 Setbit (x, 0);
 Setbit (x, 1);
 Setbit (x, 62);
 Setbit (x, 63);
 PrintF ("% LLX \ N", (Long Long) X);
 CLRBIT (X, 1);
 CLRBIT (X, 62);
 PrintF ("% LLX \ N", (Long Long) X);
 If (! Tstbit (X, 62))
  PrintF ("Bit 62 IS Cleared \ N");
 if (TSTBIT (X, 0))
  Printf ("Bit 0 is set \ n");
 Setbit (x, 30 + 2);
 PrintF ("% LLX \ N", (Long Long) X);
 RETURN PUTS ("END") == EOF;
}

works in C and in C++.

avp @ avp-ubu1: ~ / hashcode $ g ++ bits.c
AVP @ AVP-UBU1: ~ / Hashcode $ ./a.out
C00000000000033.
8000000000000001.
Bit 62 is Cleared
Bit 0 is set
8000000100000001.
End.
AVP @ AVP-UBU1: ~ / Hashcode

Naturally, in a similar way (taking or constructing the correct mask), you can install, reset or check the bit group for one operation.

Answer 4, Authority 50%

Why no one has not published a solution in Compile-Time with Template Metaprogramming?

template & lt; int n, TypeName S & GT;
 Struct to_binary_string_Rec
 {
   TypeDef TypeName To_Binary_String_REC & LT;
       N / 2,
       TypeName BOOST :: MPL :: PUSH_FRONT & LT;
           s,
           Boost :: MPL :: CHAR_ & LT; (N & AMP; 1)? '1': '0' & gt;
       & GT; :: Type
   & gt; :: Type Type
 };
 TEMPLATE & LT; TYPENAME S & GT;
 struct to_binary_string_rec & lt; 0, s & gt;
 {
   TypeDef TypeName Boost :: MPL :: if_ & lt;
       TypeName Boost :: MPL :: EMPTY & LT; S & GT; :: Type,
       Boost :: MPL :: STRING & LT; '0' & GT;
       S.
   & gt; :: Type Type;
 };
 TEMPLATE & LT; INT N & GT;
 Struct to_binary_string
 {
   TypeDef TypeName To_Binary_String_REC & LT; N, Boost :: MPL :: String & Lt; & gt; & gt; :: Type Type;
 };
 #define to_binary_string (n) Boost :: MPL :: C_STR & LT; to_binary_string & lt; N & GT; :: Type & GT; :: Value

(Sorry, did not test, because there is no boost at hand.)

Answer 5, Authority 50%

No % B Analog % x , % o printf-specimens , no STD :: BIN Analog STD :: HEX, STD :: OCT IOMANIP for binary system and no function _itoa_s () in standard C / C++.

you can use BitSet & lt; & gt; to unsigned integer in “01 “Strike with bits to turn:

# include & lt; bitset & gt;
#Include & lt; iostream & gt;
#Include & lt; Limits & gt;
INT MAIN ()
{
  uint64_t n = 123;
  STD :: BITSET & LT; STD :: NUMERIC_LIMITS & LT; DECLTYPE (N) & GT; :: Digits & GT; Bits {N};
  STD :: COUT & LT; & LT; bits.to_string ();
}

Example:

$ C++ -std = C++ 11 * .cc & amp; & amp; ./a.out.
000000000000000000000000000000000000000000000000000111011