Зачем вообще такой геморой нужен. По-моему только усложнение программы. Вообще госпрода программисты запомните таблицу из 16 элементов:
0000 — 0
0001 — 1
0010 — 2
0011 — 3
0100 — 4
0101 — 5
0110 — 6
0111 — 7
1000 — 8
1001 — 9
1010 — A
1011 — B
1100 — C
1101 — D
1110 — E
1111 — F
и никаких проблемм с переводом BIN->HEX (10110010b -> 1011 0010 -> 0xB2)
Вот еще вариант ради интереса
const u8 bc = BIN8(10110111);
const u16 bs = BIN16(10101111,11110011);
const u32 bi3 = BIN24(10101111,11110011,11110011);
const u32 bi4 = BIN32(10101111,11110011,11110011,10001000);
const u64 bll5 = BIN40(10101111,11110011,11110011,10001000,10000000);
const u64 bll6 = BIN48(10100000,10001000,10000000,00000001,10000000,00000001);
const u64 bll7 = BIN56(10000000,01000001,10000000,00000001,10000000,00000001,10000000);
const u64 bll8 = BIN64(10000000,00000001,10000000,00000001,10000000,00000001,10000000,00000001);
Здесь проверяеться все
т.е. при задании константы обязательно надо указывать 8 цифр и только "0" и "1"
нельзя, написать, допустим
BIN(10000020) — неверный символ "2"
BIN8(00000), BIN8(00010) — 5 символов, а должнобыть 8
BIN8(000000000) — 9 символов, а должнобыть 8
#define __TO_BIN(x) (convertors::_byte_length_check<u64,0x1##x,0x100000000,0x111111111>::value)
#define BIN(type,x1,x2,x3,x4,x5,x6,x7,x8) (convertors::bin_val<type,__TO_BIN(x1),__TO_BIN(x2),__TO_BIN(x3), \
__TO_BIN(x4),__TO_BIN(x5),__TO_BIN(x6),__TO_BIN(x7),__TO_BIN(x8)>::value)
#define BIN64(x1,x2,x3,x4,x5,x6,x7,x8) BIN(u64,x1,x2,x3,x4,x5,x6,x7,x8)
#define BIN56(x1,x2,x3,x4,x5,x6,x7) BIN(u64, 00000000, x1,x2,x3,x4,x5,x6,x7)
#define BIN48(x1,x2,x3,x4,x5,x6) BIN(u64, 00000000, 00000000, x1,x2,x3,x4,x5,x6)
#define BIN40(x1,x2,x3,x4,x5) BIN(u64, 00000000, 00000000, 00000000, x1,x2,x3,x4,x5)
#define BIN32(x1,x2,x3,x4) BIN(u32, 00000000, 00000000, 00000000, 00000000, x1,x2,x3, x4)
#define BIN24(x1,x2,x3) BIN(u32, 00000000, 00000000, 00000000, 00000000, 00000000, x1,x2,x3)
#define BIN16(x1,x2) BIN(u16, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000,x1,x2)
#define BIN8(x1) BIN( u8, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, 00000000, x1)
namespace convertors
{
template<bool bFlag, typename T, typename U> struct SelectType { typedef T Result; };
template<typename T, typename U> struct SelectType<false, T, U> { typedef U Result; };
template <class From, class To> To safe_convert(From _val) { assert(To(_val)==_val); return To(_val); }
template<class T, T _val, T _min, T _max, bool bInRange=(_val>=_min && _val<=_max)> struct _byte_length_check {};
template<class T, T _val, T _min, T _max>
struct _byte_length_check<T,_val,_min,_max,true> { enum {value=_val-_min}; };
#if _MSC_VER >=1400
template<class T, int _val>
struct bin_val_t
{
template<int val> struct _bit_val;
template<> struct _bit_val<0> { enum : T {ival=0};};
template<> struct _bit_val<1> { enum : T {ival=1};};
template<int _val> struct _bin_val;
template<int _val> struct _bin_val<_val>
{ enum : T { value=_bit_val<(_val%0x10)>::ival+(_bin_val<(_val/0x10)>::value*2)};};
template<> struct _bin_val<0> { enum : T {value=0};};
template<> struct _bin_val<1> { enum : T {value=1};};
enum : T { value=_bin_val<_val>::value };
};
template <class T, int x1, int x2=-1, int x3=-1, int x4=-1, int x5=-1, int x6=-1, int x7=-1, int x8=-1>
class bin_val {
enum { b1=bin_val_t<u8,x1>::value, b2=bin_val_t<u8,x2>::value, b3=bin_val_t<u8,x3>::value,
b4=bin_val_t<u8,x4>::value, b5=bin_val_t<u8,x5>::value, b6=bin_val_t<u8,x6>::value,
b7=bin_val_t<u8,x7>::value, b8=bin_val_t<u8,x8>::value };
public:
enum : T { value=((u64(b1)<<56)+(u64(b2)<<48)+(u64(b3)<<40)+(u64(b4)<<32)+(u64(b5)<<24)+
(u64(b6)<<16)+(u64(b7)<<8)+u64(b8)) };
};
#else // _MSC_VER >=1400
template<typename To, class From, From _val>
struct ConvertInt { static typename SelectType<To(_val)==_val,To,From>::Result value; };
template<typename To, typename From, From _val>
typename SelectType<To(_val)==_val,To,From>::Result ConvertInt<To,From,_val>::value=_val;
template<class T,int _val>
struct bin_val_t{
template<int val> struct _bit_val;
template<> struct _bit_val<0> { enum {ival=0};};
template<> struct _bit_val<1> { enum {ival=1};};
template<int _val> struct _bin_val;
template<int _val> struct _bin_val<_val> { enum { value=_bit_val<(_val%0x10)>::ival+
(_bin_val<(_val/0x10)>::value*2)};}
template<> struct _bin_val<0> { enum {value=0};};
template<> struct _bin_val<1> { enum {value=1};};
enum { value=_bin_val<_val>::value };
};
template <class T, int x1, int x2=-1, int x3=-1, int x4=-1, int x5=-1, int x6=-1, int x7=-1, int x8=-1>
class bin_val {
enum { b1=bin_val_t<u8,x1>::value, b2=bin_val_t<u8,x2>::value, b3=bin_val_t<u8,x3>::value,
b4=bin_val_t<u8,x4>::value, b5=bin_val_t<u8,x5>::value, b6=bin_val_t<u8,x6>::value,
b7=bin_val_t<u8,x7>::value, b8=bin_val_t<u8,x8>::value, };
public:
static const T value;
};
template <class T, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8>
const T bin_val<T,x1,x2,x3,x4,x5,x6,x7,x8>::value=
ConvertInt<T,u64,((u64(b1)<<56)+(u64(b2)<<48)+(u64(b3)<<40)+(u64(b4)<<32)+(u64(b5)<<24)+(u64(b6)<<16)+
(u64(b7)<<8)+u64(b8))>::value;
#endif // _MSC_VER >=1400
}; //namespace convertors
Только Путин, и никого кроме Путина! О Великий и Могучий Путин — царь на веки веков, навсегда!
Смотрю только Соловьева и Михеева, для меня это самые авторитетные эксперты.
КРЫМ НАШ! СКОРО И ВСЯ УКРАИНА БУДЕТ НАШЕЙ!
