Bisakah saya menggunakan literal biner dalam C atau C ++?

Saya perlu bekerja dengan nomor biner.

Saya mencoba menulis:

const x = 00010000;

Tapi itu tidak berhasil.

Saya tahu bahwa saya dapat menggunakan angka heksadesimal yang memiliki nilai yang sama 00010000, tetapi saya ingin tahu apakah ada tipe dalam C ++ untuk angka-angka biner dan jika tidak, apakah ada solusi lain untuk masalah saya?

Anda dapat menggunakanBOOST_BINARY sambil menunggu C ++ 0x. :) BOOST_BINARYbisa dibilang memiliki keunggulan dibandingkan implementasi templat sejauh dapat digunakan dalam program C juga (100% preprocessor-driven.)

Untuk melakukan sebaliknya (yaitu mencetak angka dalam bentuk biner), Anda dapat menggunakan non-portabel itoafungsi , atau menerapkan sendiri .

Sayangnya Anda tidak dapat melakukan pemformatan basis 2 dengan aliran STL (karena setbasehanya akan menghormati basis 8, 10 dan 16), tetapi Anda dapat menggunakan std::stringversi itoa, atau (yang lebih ringkas, namun sedikit kurang efisien) 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;
}

menghasilkan:

hex: 0012, dec: 18, oct: 000022, bin:            10010
hex: 0012, dec: 18, oct: 000022, bin: 0000000000010010

Baca juga buku The String Formatters dari Manor Farm milik Herb Sutter untuk diskusi yang menarik.

Jika Anda menggunakan GCC maka Anda dapat menggunakan ekstensi GCC (yang termasuk dalam standar C ++ 14 ) untuk ini:

int x = 0b00010000;

Anda dapat menggunakan literal biner. Mereka distandarisasi dalam C ++ 14. Sebagai contoh,

int x = 0b11000;

Dukungan dalam GCC

Dukungan dalam GCC dimulai pada GCC 4.3 (lihat https://gcc.gnu.org/gcc-4.3/changes.html ) sebagai ekstensi ke keluarga bahasa C (lihat https://gcc.gnu.org/onlinedocs/gcc/ C-Extensions.html # C-Extensions ), tetapi karena GCC 4.9 sekarang dikenal sebagai fitur C ++ 14 atau ekstensi (lihat Perbedaan antara literal biner GCC dan yang C ++ 14? )

Dukungan dalam Visual Studio

Dukungan di Visual Studio dimulai di Visual Studio 2015 Preview (lihat 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';

Digit paling kiri dari literal masih harus 1, tetapi tetap saja.

Beberapa kompiler (biasanya yang untuk mikrokontroler ) memiliki fitur khusus yang diimplementasikan dalam mengenali angka biner literal dengan awalan "0b ..." sebelum nomor tersebut, meskipun sebagian besar kompiler (standar C / C ++) tidak memiliki fitur seperti itu dan jika itu ini masalahnya, ini dia solusi alternatif saya:

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

Kerugian (bukan yang besar):

• Angka-angka biner harus dikelompokkan 4 oleh 4;
• Literal biner harus berupa bilangan bulat tak bertanda;

Keuntungan :

• Total preprocessor didorong, bukan spending processor timedalam operasi pointless ( like "?.. :..", "<<", "+") ke program yang dapat dieksekusi (dapat dilakukan ratusan kali dalam aplikasi akhir);
• Ia bekerja dengan "mainly in C"kompiler dan C ++ juga ( template+enum solution works only in C++ compilers);
• Ia hanya memiliki batasan "panjang" untuk mengekspresikan nilai "konstanta literal". Akan ada batasan longness awal (biasanya 8 bit: 0-255) jika seseorang telah menyatakan nilai konstan dengan mengurai tekad "enum solution" (usually 255 = reach enum definition limit), berbeda, batasan "literal konstan", dalam kompiler memungkinkan jumlah yang lebih besar;
• Beberapa solusi lain menuntut jumlah definisi konstan yang berlebihan (terlalu banyak mendefinisikan menurut saya) termasuk panjang atau several header files(dalam banyak kasus tidak mudah dibaca dan dimengerti, dan membuat proyek menjadi tidak perlu membingungkan dan diperluas, seperti menggunakan "BOOST_BINARY()");
• Kesederhanaan solusinya: mudah dibaca, dimengerti dan dapat disesuaikan untuk kasus-kasus lain (juga dapat diperluas untuk pengelompokan 8 oleh 8);

Utas ini dapat membantu.

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

Berhasil! (Semua kredit jatuh ke Tom Torfs.)

Seperti yang sudah dijawab, standar C tidak memiliki cara untuk secara langsung menulis angka biner. Namun, ada ekstensi kompiler, dan tampaknya C ++ 14 menyertakan 0bawalan untuk biner. (Perhatikan bahwa jawaban ini awalnya diposting pada tahun 2010.)

Salah satu solusi yang populer adalah memasukkan file header dengan makro pembantu . Salah satu opsi yang mudah adalah menghasilkan file yang menyertakan definisi makro untuk semua pola 8-bit, misalnya:

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

Ini menghasilkan hanya 256 #definedetik, dan jika lebih besar dari konstanta biner 8-bit diperlukan, definisi ini dapat dikombinasikan dengan shift dan OR, mungkin dengan macro pembantu (misalnya, BIN16(B00000001,B00001010)). (Memiliki makro individu untuk setiap 16-bit, apalagi 32-bit, nilainya tidak masuk akal.)

Tentu saja downside adalah bahwa sintaks ini mengharuskan penulisan semua nol terkemuka, tetapi ini juga dapat membuatnya lebih jelas untuk penggunaan seperti pengaturan bendera bit dan isi register perangkat keras. Untuk makro seperti fungsi yang menghasilkan sintaksis tanpa properti ini, lihat bithacks.htertaut di atas.

Pola pikir over-engineering C ++ sudah diperhitungkan dengan baik dalam jawaban lain di sini. Inilah upaya saya melakukannya dengan pola pikir C, keep-it-simple-ffs:

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

C tidak memiliki notasi asli untuk angka biner murni. Taruhan terbaik Anda di sini adalah oktal (misal 07777) dari heksadesimal (mis 0xfff).

Anda dapat menggunakan fungsi yang ditemukan dalam pertanyaan ini untuk mendapatkan hingga 22 bit dalam C ++. Berikut kode dari tautan, yang diedit sesuai:

template< unsigned long long N >
struct binary
{
  enum { value = (N % 8) + 2 * binary< N / 8 > :: value } ;
};

template<>
struct binary< 0 >
{
  enum { value = 0 } ;
};

Jadi Anda bisa melakukan sesuatu seperti binary<0101011011>::value.

Unit terkecil yang dapat Anda gunakan adalah byte (yang charbertipe). Anda dapat bekerja dengan bit meskipun dengan menggunakan operator bitwise.

Sedangkan untuk bilangan bulat integer, Anda hanya dapat bekerja dengan angka desimal (basis 10), oktal (basis 8) atau heksadesimal (basis 16). Tidak ada literal biner (basis 2) dalam C atau C ++.

Angka oktal diawali dengan 0dan angka heksadesimal diawali dengan 0x. Angka desimal tidak memiliki awalan.

Dalam C ++ 0x Anda akan dapat melakukan apa yang Anda inginkan dengan cara melalui literal yang ditentukan pengguna .

Anda juga dapat menggunakan rakitan inline seperti ini:

int i;

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

std::cout << i;

Oke, ini mungkin agak berlebihan, tetapi berhasil.

Berdasarkan beberapa jawaban lain, tetapi yang ini akan menolak program dengan literal biner ilegal. Nol terkemuka adalah opsional.

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

Contoh:

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

"Jenis" angka biner sama dengan angka desimal, hex atau oktal: int(atau bahkan char, pendek, panjang).

Saat Anda menetapkan konstanta, Anda tidak bisa menetapkannya dengan 11011011 (dengan rasa ingin tahu dan sayangnya), tetapi Anda bisa menggunakan hex. Hex sedikit lebih mudah untuk diterjemahkan secara mental. Potong nibble (4 bit) dan terjemahkan ke karakter dalam [0-9a-f].

Anda bisa menggunakan bitset

bitset<8> b(string("00010000"));
int i = (int)(bs.to_ulong());
cout<<i;

Saya memberikan jawaban yang bagus yang diberikan oleh @ renato-chandelier dengan memastikan dukungan dari:

• _NIBBLE_(…) - 4 bit, 1 gigit sebagai argumen
• _BYTE_(…) - 8 bit, 2 camilan sebagai argumen
• _SLAB_(…) - 12 bit, 3 camilan sebagai argumen
• _WORD_(…) - 16 bit, 4 camilan sebagai argumen
• _QUINTIBBLE_(…) - 20 bit, 5 camilan sebagai argumen
• _DSLAB_(…) - 24 bit, 6 camilan sebagai argumen
• _SEPTIBBLE_(…) - 28 bit, 7 camilan sebagai argumen
• _DWORD_(…) - 32 bit, 8 camilan sebagai argumen

Saya sebenarnya tidak begitu yakin tentang istilah "quintibble" dan "septibble". Jika ada yang tahu alternatifnya, beri tahu saya.

Inilah makro yang ditulis ulang:

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

Dan inilah contoh penggunaan 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; */

Cukup gunakan perpustakaan standar di C ++:

#include <bitset>

Anda memerlukan variabel tipe std::bitset:

std::bitset<8ul> x;
x = std::bitset<8>(10);
for (int i = x.size() - 1; i >= 0; i--) {
      std::cout << x[i];
}

Dalam contoh ini, saya menyimpan bentuk biner 10di x.

8ulmendefinisikan ukuran bit Anda, jadi 7ulartinya tujuh bit dan sebagainya.

C ++ menyediakan templat standar bernama std::bitset. Cobalah jika Anda suka.

Anda dapat mencoba menggunakan larik bool:

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