Pot folosi un literal binar în C sau C++? (Programare, C++, C, Binar)

hamza a intrebat.

Trebuie să lucrez cu un număr binar.

Am încercat să scriu:

const x = 00010000;

Dar nu a funcționat.

Știu că pot folosi un număr hexazecimal care are aceeași valoare ca și 00010000, , dar vreau să știu dacă există un tip în C++ pentru numere binare și dacă nu există, există o altă soluție pentru problema mea?

Comentarii

    54

  • Știți că 00010000 este octal, nu? (Și în declarația ta lipsește un tip).  > Por Keith Thompson.
  • Iată modul modern de utilizare a literaliilor C++. –  > Por Lol4t0.
  • C++14 a adăugat o caracteristică pentru acest lucru. Vedeți noul meu răspuns pentru mai multe detalii în partea de jos. Desigur, este nevoie de un compilator care să o implementeze. –  > Por lpapp.
  • @FormlessCloud: Acestea sunt regulile de sintaxă date în standardele C și C++ (0b apare doar în C++14). Ele sunt concepute pentru a fi lipsite de ambiguitate. –  > Por Keith Thompson.
  • Posibilă duplicare a literaliilor binare? –  > Por M.J. Rayburn.
19 răspunsuri
vladr

Puteți folosiți BOOST_BINARY în timp ce așteptați C++0x. 🙂 BOOST_BINARY se poate spune că are un avantaj față de implementarea șabloanelor în măsura în care poate fi utilizat și în programele C (se bazează 100% pe preprocesor).

Pentru a face invers (adică pentru a imprima un număr în formă binară), puteți utiliza aplicația non-portabilă itoa , , sau implementați propria dvs..

Din păcate, nu puteți efectua formatarea în baza 2 cu fluxurile STL (deoarece setbase va onora doar bazele 8, 10 și 16), dar puteți utiliza puteți utiliza fie un std::string versiune a itoa, , fie (cea mai concisă, dar marginal mai puțin eficientă) 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
", 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;
}

produce:

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

Citiți, de asemenea, Herb Sutter’s The String Formatters of Manor Farm pentru o discuție interesantă.

Comentarii

  • După cum se spune chiar pe pagina la care faceți legătura, puteți folosi doar 8, 10 sau 16 cu setbase. Cu toate acestea: int main() { cout << bitset<8>(42); } – Roger Pate
  • @Roger mulțumesc pentru bitset pont, am corectat deja partea referitoare la setbase înainte de a vedea comentariul tău. –  > Por vladr.
  • Iată un tutorial despre literali definiți de utilizator în c++11: akrzemi1.wordpress.com/2012/10/23/user-defined-literals-part-ii. Evident, c++1y (a.k.a. c++14) va include literali binari în standard. –  > Por cheshirekow.
qrdl

Dacă folosiți GCC, atunci puteți folosi o extensie GCC (care este inclusă în standardul C++14) pentru acest lucru:

int x = 0b00010000;

Comentarii

  • Mai multe alte compilatoare dispun de această metodă sau de alte metode similare de exprimare a numerelor în baza 2. –  > Por nategoose.
  • Ar fi frumos să fie standardizat, dar clang suportă aceeași notație. –  > Por polemon.
  • Funcționează în Clang, GCC și TCC. Nu funcționează în PCC. Nu am nici un alt compilator cu care să testez. –  > Por Michas.
  • Am văzut o serie de compilatoare pentru sisteme integrate care o acceptă. Nu cunosc niciun motiv anume pentru care nu ar trebui să fie o caracteristică standard a limbajului. –  > Por supercat.
  • @polemon open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf (C++14.) –  > Por Jonathan Baldwin.
Muhammad Annaqeeb

Puteți utiliza literali binari. Aceștia sunt standardizați în C++14. De exemplu,

int x = 0b11000;

Suport în GCC

Suportul în GCC a început în GCC 4.3 (a se vedea https://gcc.gnu.org/gcc-4.3/changes.html) ca extensii la familia de limbaje C (a se vedea https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html#C-Extensions), dar începând cu GCC 4.9 este acum recunoscută fie ca o caracteristică C++14, fie ca o extensie (a se vedea Diferența dintre literalele binare GCC și cele C++14?).

Suport în Visual Studio

Suportul în Visual Studio a început în Visual Studio 2015 Preview (a se vedea https://www.visualstudio.com/news/vs2015-preview-vs#C++).

Comentarii

  • Puteți utiliza ‘ pentru a separa fiecare parte : „0b0000’0100’0100’0100’0001 –  > Por Camino.
  • @camino Frumos, puteți pierde primul ” –  > Por KeyC0de.
  • Acesta ar trebui să fie răspunsul acceptat. Cele mai multe dintre celelalte răspunsuri sunt sooo învechite. –  > Por Alex.
wilhelmtell
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 << '
';

Cifra cea mai din stânga din literal trebuie să fie tot 1, dar totuși.

Comentarii

  • O versiune mai bună: bitbucket.org/kniht/scraps/src/tip/cpp/binary.hpp (binary<10>::value == binary<010>::value și unele verificări de erori) – Roger Pate
  • Cumva a lipsit acesta înainte de a posta propriul meu răspuns aproape identic. Dar în al meu cifra de început trebuie să fie 0, nu 1. –  > Por Mark Ransom.
  • O versiune mai bună a acestei idei de șablon: code.google.com/p/cpp-binary-constants –  > Por Valentin Galea.
  • @ValentinGalea – de ce versiunea google mai bună decât aceasta? –  > Por AJed.
  • Este al naibii de impresionant. Păcat că nu funcționează pentru un număr mare de biți. –  > Por Fizicianul cuantic.
Renato Chandelier

Câteva compilatoare (de obicei cele pentru microcontrolere) au o funcție specială implementată în cadrul recunoașterii numerelor binare literale de către prefixul „0b…” precedând numărul, deși majoritatea compilatoarelor (standardele C/C++) nu au o astfel de caracteristică și dacă este cazul, iată soluția mea alternativă:

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

Dezavantaje (nu sunt unele atât de mari):

  • Numerele binare trebuie să fie grupate 4 câte 4;
  • Literalii binari trebuie să fie numai numere întregi fără semn;

Avantaje:

  • Total preprocesor condus, nu spending processor time în operații inutile (like "?.. :..", "<<", "+") la programul executabil (acestea pot fi efectuate de sute de ori în aplicația finală);
  • Se lucrează "mainly in C" compilatoare și în C++, de asemenea (template+enum solution works only in C++ compilers);
  • Are doar limitarea „lungimii” pentru exprimarea valorilor „constantelor literale”. Ar fi existat de timpuriu o limitare a lungimii (de obicei 8 biți: 0-255) dacă s-ar fi exprimat valori constante prin rezolvarea parsing-ului din "enum solution" (usually 255 = reach enum definition limit), , în mod diferit, limitările „constantelor literale”, în compilator permit numere mai mari;
  • Unele alte soluții cer un număr exagerat de definiții ale constantelor (prea multe definiții, în opinia mea), inclusiv long sau several header files (în cele mai multe cazuri nu sunt ușor de citit și de înțeles și fac ca proiectul să devină inutil de confuz și extins, cum ar fi cel care folosește "BOOST_BINARY()");
  • Simplitatea soluției: ușor de citit, ușor de înțeles și ajustabilă pentru alte cazuri (ar putea fi extinsă și pentru gruparea de 8 în 8);

Comentarii

  • De ce este de ex. B_0100 nu este utilizat (în loc de 0100)? Ca și în e.g. char b = BYTE(0100,0001);. –  > Por Peter Mortensen.
  • @PeterMortensen B_ este adăugat de către _B2H funcția preprocesorului. –  > Por mxmlnkn.
Federico A. Ramponi

Acest fir poate fi de ajutor.

/* 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 
", number);
    return 0;
}

Funcționează! (Toate creditele îi aparțin lui Tom Torfs.)

Comentarii

  • nu am înțeles cu adevărat ( sunt începător în programare & în special în C++) dar pare interesant așa că voi încerca să înțeleg după ce voi studia mai mult C++ , mulțumesc –  > Por hamza.
  • Macro B8 funcționează prin convertirea literalului „binar” într-un literal hexazecimal și extragerea fiecărui al 4-lea bit. –  > Por dan04.
  • Mă întreb ce înseamnă 0x##n##LU? Nu am întâlnit niciodată o astfel de sintaxă. –  > Por Federico A. Ramponi.
  • @hamza: Într-adevăr, este destul de complicat. Dar ceea ce trebuie să înțelegeți este doar de la #include<stdio> încolo. –  > Por Federico A. Ramponi.
  • @Federico: În ## operatorul de preprocesare lipește token-uri împreună. Deci, în acest caz, dacă apelați HEX__(10), , se extinde în 0x10LU. –  > Por James McNellis.
Craig

Mentalitatea de supra-inginerie C++ este deja bine explicată în celelalte răspunsuri de aici. Iată încercarea mea de a face acest lucru cu o mentalitate de C, cu o mentalitate „keep-it-simple-ffs”:

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

Arkku

După cum s-a răspuns deja, standardele C nu au nicio modalitate de a scrie direct numere binare. Există însă extensii de compilator și se pare că C++14 include extensia 0b prefix pentru binar. (Rețineți că acest răspuns a fost postat inițial în 2010).

O soluție populară de rezolvare este de a include un fișier antet cu macro-uri ajutătoare. O opțiune ușoară este, de asemenea, generarea unui fișier care să includă definiții de macro pentru toate modelele pe 8 biți, de ex:

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

Acest lucru are ca rezultat doar 256 #defines, iar dacă sunt necesare constante binare mai mari de 8 biți, aceste definiții pot fi combinate cu deplasări și OR-uri, eventual cu macro-uri de ajutor (de ex, BIN16(B00000001,B00001010)). (A avea macro-uri individuale pentru fiecare valoare de 16 biți, ca să nu mai vorbim de 32 de biți, nu este plauzibil).

Bineînțeles, dezavantajul este că această sintaxă necesită scrierea tuturor zerourilor de început, dar acest lucru poate fi mai clar pentru utilizări cum ar fi stabilirea indicatoarelor de biți și a conținutului registrelor hardware. Pentru o macro de tip funcție care are ca rezultat o sintaxă fără această proprietate, a se vedea bithacks.h linkul de mai sus.

Comentarii

  • Așadar, cât de mare ar trebui să fie fișierul pe care CPP ar trebui să îl citească dacă ați avea toate macrogramele pentru un fișier long long int? –  > Por wilhelmtell.
  • @wilhelmtell: Și care este relevanța acestui lucru atunci când am specificat „all 8 biți modele” (= 256 de linii) și am sugerat combinarea unor cantități mai mari din acestea? Chiar și BOOST_BINARY din răspunsul acceptat definește toate modelele pe 8 biți din antet… -.  > Por Arkku.
  • Nu sunt sigur dacă upvote sau downvote. Pe de o parte, este inteligent, deoarece o simplă înlocuire a textului se face înainte de compilare. Și puteți scrie simplu un generator pentru a crea un astfel de fișier antet și pentru tipurile de date mai mari de 8-Bit. Pe de altă parte, nu știu câte #define poate gestiona un preprocesor și nici dacă acestea pot fi gestionate eficient. Poate că este posibil să se reducă numărul de definiții necesare prin utilizarea de macro-uri de ajutor pentru concatenarea cu ##. –  > Por tangoal.
  • @tangoal După cum spun în răspuns, sugerez acest lucru doar pentru macro-urile pe 8 biți și declar în mod explicit că nu cred că este plauzibil să se facă pe 16 biți sau mai mult, și sugerez, de asemenea, combinarea unor lățimi mai mari (decât 8 biți) cu macro-uri de ajutor. Deci, dacă votați în jos, aș spera că motivul nu este același vechi „nu am citit răspunsul, dar acest lucru nu funcționează pentru mai mult de 8 biți”, deoarece nu este intenționat să. =) –  > Por Arkku.
  • În ceea ce privește concatenarea cu ##, , cred că ar fi nevoie de o sintaxă de genul BIN16(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1) care nu cred că este o îmbunătățire prea mare față de cea din BIN16(B00000001,B00001010) sugerată în răspuns. Sau ai avut altă idee decât una din aceste forme de bază? (Recunosc că un editor cu autocompletare inteligentă ar putea ajuta cu prima sintaxă și ar putea pune exact numărul de argumente cu spații libere, ceea ce ar putea fi văzut ca o îmbunătățire, chiar dacă nu este atât de plăcut să scrii de mână când trebuie să numeri până la 16). –  > Por Arkku.
Nikolai Fetissov

C nu are nativ notație pentru numere binare pure. Cea mai bună opțiune ar fi fie octal (de ex. 07777) sau hexazecimal (de ex. 0xfff).

Mark Ransom

Puteți utiliza funcția găsită în această întrebare pentru a obține până la 22 de biți în C++. Iată codul din link, editat corespunzător:

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

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

Deci, puteți face ceva de genul binary<0101011011>::value.

Brian R. Bondy

Cea mai mică unitate cu care puteți lucra este un octet (care este de char tip). Totuși, puteți lucra cu biți folosind operatorii bitwise.

În ceea ce privește literalele de numere întregi, puteți lucra numai cu numere zecimale (baza 10), octale (baza 8) sau hexazecimale (baza 16). Nu există literali binari (baza 2) în C sau C++.

Numerele octale sunt prefixate cu 0 iar numerele hexazecimale sunt prefixate cu 0x. Numerele zecimale nu au prefix.

În C++0x veți putea face ceea ce doriți prin intermediul literali definiți de utilizator.

Comentarii

  • pot să arăt măcar valoarea binară a unui hexazecimal într-o funcție print sau cout ? –  > Por hamza.
  • Da, se poate <shameless_plug> stackoverflow.com/questions/2611764#2611883 </shameless_plug> –  > Por vladr.
  • Unele compilatoare C acceptă 0b100101 pentru literali binari, dar este o extensie nestandardizată, din păcate. –  > Por Joey Adams.
  • Rețineți că, deși nu este definită în standard, unele compilatoare (în special cele pentru microcontrolere și sisteme integrate) adaugă sintaxa pentru binar sub forma 0b00101010 ca o comoditate. SDCC este unul dintre ele și sunt sigur că mai sunt și altele care o fac. (Editare: Hah, m-ai întrecut la asta, @Joey!).  > Por mbauman.
renger

Puteți utiliza, de asemenea, asamblarea în linie ca aceasta:

int i;

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

std::cout << i;

Bine, s-ar putea să fie oarecum exagerat, dar funcționează.

Comentarii

  • Soluția ta nu este multi-platformă. În multe arhitecturi nu puteți include codul de asamblare în C. În mod specific, în compilatorul Microsoft Visual studio puteți (atunci când este compilat pentru x86 32bits). Dar de unde știi dacă procesorul tău are registrul ‘eax’? Gândiți-vă la procesoarele ARM din telefoanele mobile, la procesorul x64, etc. Acestea nu au ‘eax’. Procesorul MIPS nici măcar nu are comanda ‘mov’ –  > Por DanielHsH.
Thomas Eding

Bazat pe alte răspunsuri, dar acesta va respinge programele cu literali binari ilegali. Zerourile din față sunt opționale.

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

Exemplu:

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

Stephen

„Tipul” unui număr binar este același cu cel al oricărui număr zecimal, hexazecimal sau octal: int (sau chiar char, short, long long).

Atunci când atribuiți o constantă, nu o puteți atribui cu 11011011 (curios și din păcate), dar puteți folosi hexagonal. Hex este un pic mai ușor de tradus mental. Se taie în nibbles (4 biți) și se traduce la un caracter în [0-9a-f].

Deqing

Puteți utiliza un set de biți

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

madmurphy

Am extins răspunsul bun dat de @renato-chandelier prin asigurarea suportului de:

  • _NIBBLE_(…) – 4 biți, 1 nibble ca argument
  • _BYTE_(…) – 8 biți, 2 nibbles ca argumente
  • _SLAB_(…) – 12 biți, 3 nibbles ca argumente
  • _WORD_(…) – 16 biți, 4 nibbles ca argumente
  • _QUINTIBBLE_(…) – 20 de biți, 5 nibbles ca argumente
  • _DSLAB_(…) – 24 biți, 6 nibbles ca argumente
  • _SEPTIBBLE_(…) – 28 biți, 7 nibbles ca argumente
  • _DWORD_(…) – 32 biți, 8 nibbles ca argumente

De fapt, nu sunt atât de sigur de termenii „quintibble” și „septibble”. Dacă cineva cunoaște o alternativă, vă rog să mă anunțați.

Iată macroul rescris:

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

Și iată exemplul de utilizare al lui 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; */

Hadi Rasekh

Pur și simplu folosiți biblioteca standard din C++:

#include <bitset>

Aveți nevoie de o variabilă de tip std::bitset:

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

În acest exemplu, am stocat forma binară a lui 10 în x.

8ul definește dimensiunea biților, deci 7ul înseamnă șapte biți și așa mai departe.

Vara_Mai_Mai_Mai_Mai_Mai_Mai_Mai

C++ oferă un șablon standard numit std::bitset. Încercați-l dacă doriți.

george wagenknecht

Ați putea încerca să folosiți o matrice de bool:

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

Comentarii

  • O mulțime de downvotes, fără explicații. Iată explicația: stackoverflow.com/questions/2064550/c-why-bool-is-8-bits-long De asemenea, fiecare element dintr-un array se află la o adresă de memorie diferită. Dar noi vrem o secvență de 1 și 0 ambalate la o singură adresă. –  > Por twitchdotcom slash KANJICODER.
  • Un alt lucru legat de acest lucru este că este o utilizare foarte mare a memoriei pentru acest caz. Vă sugerez să scrieți o funcție care să reprezinte mai bine cifrele binare pentru ușurința operațiilor poate? –  > Por Daniel Kaczmarczyk.

Tags:,