일부 컴파일러 (보통 마이크로 컨트롤러 용 컴파일러 )에는 대부분의 컴파일러 (C / C ++ 표준)에 이러한 기능이 없지만 대부분의 컴파일러 (C / C ++ 표준)에는 해당되지 않지만, 숫자 앞에 접두사 “0b …”로 리터럴 이진 숫자를 인식하도록 구현 된 특수 기능 이 있습니다. 이 경우 내 대안 솔루션입니다.

#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;

단점 (그다지 큰 것은 아닙니다) :

• 이진수는 4×4로 그룹화해야합니다.
• 이진 리터럴은 부호없는 정수 여야합니다.

장점 :

• spending processor time무의미한 작업이 아닌 전체 전 처리기 구동 (like "?.. :..", "<<", "+"실행 가능한 프로그램에 대한 )이 (최종 응용 프로그램에서 수백 번 수행 될 수 있음);
• "mainly in C"컴파일러와 C ++도 작동 합니다 ( template+enum solution works only in C++ compilers);
• “문자 상수”값을 표현하기 위해 “길이”의 한계 만 있습니다. "enum solution" (usually 255 = reach enum definition limit)컴파일러에서 “리터럴 상수”한계를 다르게 해석하여 상수 값을 표현한 경우 컴파일러에서 더 큰 숫자를 허용하면 초기 경도 제한 (보통 8 비트 : 0-255)이 발생했을 것 입니다.
• 일부 다른 솔루션은 길거나 several header files(대부분의 경우 쉽게 읽고 이해할 수 없으며 프로젝트를 사용하는 것과 같이 불필요하게 혼란스럽고 확장되게합니다 )을 포함하여 많은 수의 상수 정의 (제 의견으로는 너무 많은 정의 "BOOST_BINARY()")를 요구합니다.
• 솔루션의 단순성 : 다른 경우에 대해 쉽게 읽고 이해하고 조절할 수 있습니다 (8×8 그룹화도 확장 가능).

답변

/* 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;
}

#define B00000000 0
#define B00000001 1
#define B00000010 2
…