ฉันสามารถใช้ตัวอักษรไบนารีใน C หรือ C ++ ได้ไหม?

ฉันต้องทำงานกับเลขฐานสอง

ฉันพยายามเขียน:

const x = 00010000;

แต่มันไม่ทำงาน

ฉันรู้ว่าฉันสามารถใช้เลขฐานสิบหกที่มีค่าเหมือน00010000กัน แต่ฉันต้องการที่จะรู้ว่ามีชนิดใน C ++ สำหรับเลขฐานสองหรือไม่และถ้าไม่มีจะมีวิธีแก้ไขปัญหาของฉันอีกหรือไม่

คุณสามารถใช้BOOST_BINARYในขณะที่รอ C ++ 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 ของ Manor Farmสำหรับการสนทนาที่น่าสนใจ

หากคุณใช้ GCC คุณสามารถใช้ส่วนขยาย GCC (ซึ่งรวมอยู่ในมาตรฐาน C ++ 14 ) สำหรับสิ่งนี้:

int x = 0b00010000;

คุณสามารถใช้ตัวอักษรไบนารี พวกเขาเป็นมาตรฐานใน C ++ 14 ตัวอย่างเช่น,

int x = 0b11000;

สนับสนุน GCC

การสนับสนุนใน 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 ได้รับการยอมรับว่าเป็นคุณลักษณะ C ++ 14 หรือส่วนขยาย (ดูความแตกต่างระหว่าง GCC binary literals และ C ++ 14 )

รองรับ Visual Studio

การสนับสนุนใน Visual Studio เริ่มต้นใน Visual Studio 2015 Preview (ดูที่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 / 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;

ข้อเสีย (มันไม่ใหญ่มาก):

• ตัวเลขไบนารีจะต้องมีการจัดกลุ่ม 4 โดย 4;
• ตัวอักษรไบนารีต้องเป็นตัวเลขจำนวนเต็มที่ไม่ได้ลงชื่อเท่านั้น

ข้อดี :

• ตัวประมวลผลล่วงหน้าทั้งหมดได้รับการขับเคลื่อนไม่ใช่spending processor timeการดำเนินการที่ไม่มีจุดหมาย ( like "?.. :..", "<<", "+") ไปยังโปรแกรมที่ปฏิบัติการได้ (อาจดำเนินการหลายร้อยครั้งในแอปพลิเคชันสุดท้าย);
• มันทำงานได้"mainly in C"คอมไพเลอร์และ C ++ เช่นกัน ( template+enum solution works only in C++ compilers);
• มันมีเพียงข้อ จำกัด ของ "ความยาว" สำหรับการแสดงค่า "คงที่ตามตัวอักษร" จะมีข้อ จำกัด ความยาวก่อนกำหนด (ปกติ 8 บิต: 0-255) หากมีการแสดงค่าคงที่โดยการแยกวิเคราะห์ของ"enum solution" (usually 255 = reach enum definition limit)ข้อ จำกัด "ค่าคงตัวตามตัวอักษร" ที่แตกต่างกันในคอมไพเลอร์อนุญาตให้มีจำนวนมากขึ้น
• โซลูชันอื่น ๆ ต้องการจำนวนคำจำกัดความคงที่เกินจริง (มากเกินไปที่กำหนดไว้ในความคิดเห็นของฉัน) รวมถึงยาวหรือ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;
}

มันได้ผล! (เครดิตทั้งหมดไปที่ Tom Torfs)

ดังที่ได้ตอบไปแล้วมาตรฐาน C ไม่มีทางที่จะเขียนเลขฐานสองโดยตรง มีนามสกุลคอมไพเลอร์อย่างไรก็ตามและเห็นได้ชัดว่า C ++ 14 มี0bคำนำหน้าสำหรับไบนารี (โปรดทราบว่าคำตอบนี้ถูกโพสต์ครั้งแรกในปี 2010)

หนึ่งวิธีแก้ปัญหาที่เป็นที่นิยมคือการรวมไฟล์ส่วนหัวที่มีแมโครผู้ช่วย ตัวเลือกที่ง่ายอย่างหนึ่งก็คือการสร้างไฟล์ที่มีคำจำกัดความมาโครสำหรับรูปแบบ 8 บิตทั้งหมดเช่น:

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

สิ่งนี้ให้ผลเพียง 256 #defineวิและหากต้องการค่าคงที่ไบนารีขนาดใหญ่กว่า 8 บิตคำจำกัดความเหล่านี้สามารถรวมกันกับกะและ OR อาจเป็นมาโครของตัวช่วย (เช่นBIN16(B00000001,B00001010) ) (การมีมาโครแต่ละตัวสำหรับทุก ๆ 16 บิตให้อยู่คนเดียว 32- บิตค่าไม่น่าเชื่อถือ)

แน่นอนว่าข้อเสียคือไวยากรณ์นี้ต้องการการเขียนศูนย์นำหน้าทั้งหมด แต่สิ่งนี้อาจทำให้ชัดเจนยิ่งขึ้นสำหรับการใช้เช่นการตั้งค่าสถานะบิตและเนื้อหาของการลงทะเบียนฮาร์ดแวร์ สำหรับมาโครที่มีฟังก์ชันคล้ายกันส่งผลให้เกิดไวยากรณ์โดยไม่มีคุณสมบัตินี้ให้ดูbithacks.hลิงก์ด้านบน

ความคิดเชิงวิศวกรรมเกินของ C ++ นั้นเป็นที่ยอมรับกันดีในคำตอบอื่น ๆ ที่นี่ นี่คือความพยายามของฉันในการทำมันด้วย C, mindset-it-simple-ffs

unsigned char x = 0xF; // binary: 00001111

C ไม่ได้มีพื้นเมืองสัญกรณ์เลขฐานสองบริสุทธิ์ ทางออกที่ดีที่สุดของคุณที่นี่จะเป็นเลขฐานแปด (เช่น07777) ของเลขฐานสิบหก (เช่น0xfff)

คุณสามารถใช้ฟังก์ชันที่พบในคำถามนี้เพื่อให้ได้มากถึง 22 บิตใน C ++ นี่คือรหัสจากลิงก์ที่แก้ไขอย่างเหมาะสม:

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) ไม่มีตัวอักษรไบนารี (ฐาน 2) ใน C หรือ C ++

หมายเลข Octal จะมีคำนำหน้าและเลขฐานสิบหกจะมีคำนำหน้า0 0xตัวเลขทศนิยมไม่มีคำนำหน้า

ใน C ++ 0x คุณจะสามารถที่จะทำสิ่งที่คุณต้องการโดยวิธีการผ่านที่ผู้ใช้กำหนดตัวอักษร

คุณยังสามารถใช้ชุดประกอบแบบอินไลน์เช่นนี้:

int i;

__asm {
    mov eax, 00000000000000000000000000000000b
    mov i,   eax
}

std::cout << i;

โอเคมันอาจจะเกินกำลังไปหน่อย แต่ก็ใช้ได้ดี

ตามคำตอบอื่น ๆ แต่โปรแกรมนี้จะปฏิเสธโปรแกรมที่มีตัวอักษรไบนารีผิดกฎหมาย เลขศูนย์นำหน้าเป็นตัวเลือก

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

"type" ของเลขฐานสองนั้นเหมือนกับทศนิยมฐานสิบหรือฐานแปด: intใด ๆ

เมื่อคุณกำหนดค่าคงที่คุณไม่สามารถกำหนดค่าด้วย 11011011 (อยากรู้อยากเห็นและน่าเสียดาย) แต่คุณสามารถใช้เลขฐานสิบหกได้ Hex นั้นง่ายต่อการแปลทางใจเล็กน้อย ก้อนใน 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 bits, 3 nibbles เป็นอาร์กิวเมนต์
• _WORD_(…) - 16 bits, 4 nibbles เป็นอาร์กิวเมนต์
• _QUINTIBBLE_(…) - 20 บิต 5 nibbles เป็นอาร์กิวเมนต์
• _DSLAB_(…) - 24 bits, 6 nibbles เป็นอาร์กิวเมนต์
• _SEPTIBBLE_(…) - 28 บิต 7 nibbles เป็นอาร์กิวเมนต์
• _DWORD_(…) - 32 บิต 8 nibbles เป็นอาร์กิวเมนต์

จริง ๆ แล้วฉันไม่แน่ใจเกี่ยวกับคำว่า "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))

และนี่คือตัวอย่างการใช้ของ Renato:

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];
}

ในตัวอย่างนี้ผมเก็บไว้ในรูปแบบของฐานใน10x

8ulกำหนดขนาดของบิตของคุณดังนั้น7ulหมายถึงเจ็ดบิตและอื่น ๆ

C ++ std::bitsetให้แม่แบบมาตรฐานชื่อ ลองถ้าคุณชอบ

คุณสามารถลองใช้อาเรย์ของbool:

bool i[8] = {0,0,1,1,0,1,0,1}