Necesito trabajar con un número binario.

Traté de escribir:

const x = 00010000;

Pero no funcionó.

Sé que se puede utilizar un número hexadecimal que tiene el mismo valor que 00010000, pero quiero saber si hay un tipo en C++ para los números binarios, y si no la hay, hay otra solución para mi problema?

  • Usted sabe que 00010000 es octal, ¿verdad? (Y su declaración es la falta de un tipo.)
  • Aquí de forma moderna con C++ literales.
  • Me gustaría considerar el uso de hex. Como se puede ver a continuación, es sólo una más comprimido con forma binaria, y que son mucho menos propensos a cambiar un 0 y 1.
  • C++14 se ha añadido una función para esto. Ver a mi nueva respuesta para más detalles en la parte inferior. Por supuesto, no requiere un compilador que la implementa.
  • puede usted explicar por qué es octal?
  • Porque empieza con 0. Un literal entero es hexadecimal si se inicia con 0x o 0X, binario (en C++14 o posterior) si se inicia con 0b o 0B, octal si se inicia con 0, y decimal de otra manera. (Sí, eso significa que 0 es octal.)
  • mmm son estos como los convenios o algo, para reconocer de manera unívoca un número de una base? Becase x no es hexadecimal (A, B, C, D, E, F), y escribir ceros en frente de binario o hexadecimal los números no afectar a cualquiera de uno de ellos, por lo que es arbitrario elegir 0b para los binarios?
  • Estas son las reglas de sintaxis dado en el C y C++ estándares (0b aparece sólo en C++14). Están diseñados para ser ambigua.
  • hacer una pregunta como esta hoy en día, y se obtiene votada abajo al infierno
  • Posibles duplicados de Binario literales?

InformationsquelleAutor hamza | 2010-04-10

19 Comentarios

  1. 69

    Puede el uso de BOOST_BINARY mientras se espera para C++0x. 🙂 BOOST_BINARY podría decirse que tiene una ventaja sobre la implementación de la plantilla, en la medida que puede ser utilizado en los programas en C así (es 100% preprocesador de motor.)

    ACTUALIZACIÓN

    A hacer a la inversa (es decir, imprimir un número en formato binario), puede utilizar la no-portátil itoa función, o implementar su propio.

    Por desgracia no se puede hacer la base 2 formato STL corrientes (desde setbase sólo el honor bases de 8, 10 y 16), pero puede utilizar un std::string versión de itoa, o (la más concisa, sin embargo, un poco menos eficiente) std::bitset.

    (Gracias Roger para la bitset punta!)

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

    produce:

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

    Lea también Herb Sutter del La Cadena de Formateadores de Manor Farm para una discusión interesante.

    • Como la página a la que enlaza dice, sólo se pueden utilizar los 8, 10 o 16 con setbase. Sin embargo: int main() { cout << bitset<8>(42); }
    • gracias por la bitset sugerencia, ya lo he corregido el poco acerca de setbase antes de ver tu comentario, aunque.
    • no aceptar si está utilizando un sistema embebido …
    • Aquí un tutorial sobre definido por el usuario en los literales c++11: akrzemi1.wordpress.com/2012/10/23/user-defined-literals-part-ii. Evidentemente, c++1y (un.k.una. c++14), los binarios de los literales de la norma.
  2. 253

    Si usted está utilizando GCC, entonces usted puede utilizar una extensión de GCC (que se incluye en el C++estándar 14) para ello:

    int x = 0b00010000;
    • Varios otros compiladores tienen este u otros similares formas de expresar los números en base 2.
    • Sería bueno tener esta estandarizado, pero el ruido se admite la misma notación.
    • Funciona en Clang, GCC, y TCC. No funciona en el PCC. Yo no tiene ningún otro compilador para realizar la prueba.
    • He visto un número de embedded systems compiladores que la apoyan. Yo no conozco a ninguna razón en particular no debería ser un estándar de la característica del lenguaje.
    • href=»http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf» >open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf (C++14.)
    • Para el registro, esto no es apoyado por MSVC2010, tristemente.
    • Esta respuesta debe ser aceptada como la mejor ya que es muy sencillo como es.
    • Esto también funciona en el Arduino IDE, lo cual tiene sentido dado su típico de aplicaciones incrustadas.

  3. 80

    Usted puede utilizar el binario literales. Ellos están estandarizadas en C++14. Por ejemplo,

    int x = 0b11000;

    Apoyo en GCC

    Apoyo en GCC comenzó en GCC 4.3 (véase https://gcc.gnu.org/gcc-4.3/changes.html) como extensiones para el lenguaje C de la familia (ver https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html#C-Extensions), pero desde GCC 4.9 es ahora reconocido como un C++14 de característica o de una extensión (ver Diferencia entre GCC binario literales y C++14? ¿)

    Apoyo en Visual Studio

    Apoyo en Visual Studio comenzó en Visual Studio 2015 Preview (ver https://www.visualstudio.com/news/vs2015-preview-vs#C++).

    • Me gustaría que este podría ser cambiado a la aceptación de la respuesta.
    • ese debería ser el favorito de respuesta
    • Usted puede utilizar para separar cada parte : «0b0000’0100’0100’0001
  4. 73
    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';

    El dígito izquierdo del literal todavía tiene que ser 1, pero no obstante.

    • +1, bravo. No creo que se responde a la pregunta, pero bravo.
    • +1 para ingenioso plantilla
    • Mejor versión: bitbucket.org/kniht/scraps/src/tip/cpp/binary.hpp (binary<10>::value == binary<010>::value y algunos de comprobación de error)
    • De alguna manera no se esto antes he publicado mi propia casi idéntica respuesta. Pero en la mía el primer dígito tiene que ser 0, no 1.
    • +1. Impulsar el Binario es el Crisco de la conversión de la base. Esto es bueno Y saludable.
    • Una mejor versión de esta plantilla idea: code.google.com/p/cpp-binary-constants
    • por qué la versión de google mejor que esto?
    • Este es freaking impresionante. Lástima que no trabajo para un alto número de bits.

  5. 30

    Un par de compiladores (generalmente los de microcontroladores) tiene una característica especial implementado dentro de reconocer literal de los números binarios, por prefijo «0b…» anterior el número, aunque la mayoría de los compiladores de C/C++ normas) no tiene tal función y, si es el caso, aquí está mi solución alternativa:

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

    Desventajas (no es un grandes):

    • Los números binarios han de ser agrupados de 4 en 4;
    • El binario literales tienen que ser sólo de enteros sin signo de los números;

    Ventajas:

    • Total de preprocesador impulsado, no spending processor time en el sentido de las operaciones (like "?.. :..", "<<", "+") para el programa ejecutable (puede ser realizado cientos de veces en la final de la aplicación);
    • Funciona "mainly in C" y los compiladores de C++ ( template+enum solution works only in C++ compilers );
    • Tiene sólo la limitación de la «longness» para expresar «literal constante» de los valores. No habría sido earlyish longness limitación (generalmente de 8 bits: 0-255) si uno había expresado a valores constantes de análisis de resolver de "enum solution" (usually 255 = reach enum definition limit), de manera diferente, «literal constante» de las limitaciones, en el compilador permite una mayor números;
    • Algunas otras soluciones de la demanda exagerado número de las definiciones de constantes (demasiados define, en mi opinión, incluyendo los de largo o several header files (en la mayoría de los casos no fácilmente legible y comprensible, y hacer que el proyecto esté innecesariamente confuso y extendido, al igual que el uso de "BOOST_BINARY()");
    • La simplicidad de la solución: fácilmente legible, comprensible y ajustable para otros casos (podría ser extendido por la agrupación de 8 por 8 también);
    • Por qué, por ejemplo, es B_0100 no utilizado (en lugar de 0100)? Como, por ejemplo, en char b = BYTE(0100,0001);.
    • El B_ se añade por el _B2H preprocesador función.
  6. 20

    Este hilo puede ayudar.

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

    Funciona! (Todos los créditos van a Tom Torfs.)

    • realmente no lo entiendo ( yo m de un principiante en la programación & especialmente en C++), pero parece muy interesante, así que voy a tratar de entenderlo después de algo más de C++ estudios , gracias
    • El B8 macro funciona mediante la conversión de los «binarios» literal hexadecimal literal y la extracción de cada 4 bits.
    • Me pregunto qué 0x##n##LU significa? Nunca encontrado a la sintaxis.
    • de hecho, es bastante complejo. Pero lo que usted necesita entender es que sólo a partir de #include<stdio> en adelante.
    • El ## preprocesador operador de pastas de tokens juntos. Así, en este caso, si la llamada HEX__(10), que se expande a 0x10LU.
    • +1 para ingenioso macros
    • Muy inteligente. Usted incluso no necesita preocuparse por el literal interpretado como octal, ya que simplemente se concatenan directamente a la 0x. Los ceros a la izquierda son totalmente opcionales.
    • Curiosamente, este conjunto de macros se producen algunos resultados interesantes para: B16(ABCDEF89,01234567); de lo Contrario, muy inteligente!

  7. 15

    Como ya se ha respondido, el C normas no tienen manera de escribir directamente los números binarios. Hay compilador de extensiones, sin embargo, y al parecer C++14 incluye la 0b prefijo binario. (Tenga en cuenta que esta respuesta fue publicado originalmente en 2010.)

    Una solución popular es incluir un encabezado de archivo con macros de ayuda. Una opción sencilla es también para generar un archivo que incluye las definiciones de macro para todos los 8 bits de los patrones, por ejemplo:

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

    Esto se traduce en sólo 256 #defines, y si es mayor de 8 bits constantes binarias son necesarias, estas definiciones pueden ser combinados con los cambios y las Sro, posiblemente con macros de ayuda (por ejemplo, BIN16(B00000001,B00001010)). (Tener individuales macros para cada 16 bits, y no digamos de 32 bits, el valor no es plausible.)

    Por supuesto, la desventaja es que esta sintaxis es necesario escribir todos los ceros a la izquierda, pero esto también puede hacer que sea más claro para usos como el establecimiento de indicadores de bit y el contenido de los registros de hardware. Para una función-como el macro resultando en una sintaxis sin esta propiedad, consulte bithacks.h vinculado anteriormente.

    • Así que, ¿qué tan grande de un archivo CPP necesidad de leer, si usted tenía todas las macros para un long long int?
    • Y ¿cuál es la relevancia de que cuando me especificado «todos los 8-bit los patrones» (= 256 líneas), y sugirió que la combinación de grandes cantidades de esos? Incluso el BOOST_BINARY de la aceptó responder define todos 8-patrones de bits en el encabezado…
    • (Me resulta un poco extraño que esta respuesta es todavía downvotes dos años más tarde, sobre todo cuando mi primera sugerencia es incluir un encabezado de la biblioteca no es fundamentalmente diferente de la de los aceptados respuesta, y mi segunda sugerencia es generar 256 macros de 8 bits constantes, que es un número más pequeño de #defines que en el BOOST_BINARY encabezado…)
  8. 14

    El C++ a través de la ingeniería de mentalidad ya está bien representaron en las otras respuestas aquí. Aquí está mi intento de hacerlo con una C, mantener-lo-simple-ffs mentalidad:

    unsigned char x = 0xF; //binary: 00001111
    • Creo que este es el más respuesta correcta. La razón por la cual C no proporciona binario literales es porque son un desastre para leer. Y en el mundo real código de usted, por supuesto, en lugar de escribir algo como unsigned char x = STUFF | THINGS | ITEMS;, completamente libre de la mala práctica que se conoce como «números mágicos».
  9. 12

    C no tiene nativo la notación para el más puro de los números binarios. Su mejor apuesta sería la de cualquiera de octal (por ejemplo,07777) de hexadecimal (por ejemplo,0xfff).

  10. 9

    Usted puede usar la función que se encuentra en esta pregunta para llegar hasta el 22 de bits en C++. Aquí está el código del enlace, convenientemente editado:

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

    Así que usted puede hacer algo como binary<0101011011>::value.

    • +1 yo prefiero tu respuesta sobre @wilhelmtell uno, porque conduce 0s no son significativas, mientras que 1 son
    • en realidad, creo que son.
  11. 7

    La unidad más pequeña que puede trabajar es de un byte (que es de char tipo). Usted puede trabajar con los bits a pesar de que mediante el uso de operadores bit a bit.

    Como para los literales de tipo entero, sólo se puede trabajar con decimales (base 10), octal (base 8) o hexadecimal (base 16) números. No hay binario (base 2) en los literales C ni C++.

    Octal los números con el prefijo 0 y hexadecimal los números con el prefijo 0x. Decimal, los números no tienen prefijo.

    En C++0x usted será capaz de hacer lo que quieres por el camino a través de definido por el usuario literales.

    • puedo, al menos, mostrar el valor en Binario hexadecimal en una impresión o una cout función ?
    • Sí, usted puede <shameless_plug> stackoverflow.com/questions/2611764#2611883 </shameless_plug>
    • Algunos compiladores de C apoyo 0b100101 binario literales, pero se trata de una extensión no estándar, por desgracia.
    • Tenga en cuenta que, si bien no se define en la norma, algunos compiladores (en particular para los microcontroladores y sistemas embebidos) añadir la sintaxis para los binarios en forma 0b00101010 como una conveniencia. SDCC es uno, y estoy seguro de que hay otros que también lo hacen. (Edit: Ah, me pegaba a él, @Joey!)
    • Y GCC, también, desde 4.3: gcc.gnu.org/gcc-4.3/changes.html
  12. 4

    Basada en algunas otras respuestas, pero esto va a rechazar los programas ilegales binario literales. Ceros a la izquierda son opcionales.

    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

    Ejemplo:

    #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;
    }
    • +1 Hay algunos inconvenientes, pero en general, esta es una buena solución. La parte más interesante para mí es que no puede rechazar no sólo las cosas que son claramente no válido (como B(/2)) o razonable, pero no binario (como B(+2)), pero también B(-001000000000000000000000) (cuando unsigned long long es de 64 bits) aunque todos los otros aspectos negativos de los números binarios son rechazados. Además, es igual a la B(001000000000000000000000), no -B(001000000000000000000000) y grandes números binarios puede ser definido, como -B(001111111111111111111111).
    • Gracias por señalar los defectos. He actualizado el código para lidiar con al menos algunos de esos problemas. Una brecha que aún existe, es algo como esto B(1+0). No estoy seguro de cómo lidiar con eso, ni estoy seguro de si C++ puede tratar con él. En cualquier caso, creo que uno tiene que tratar de hacer algo tonto ahora.
  13. 2

    El «tipo» de un número binario es el mismo que el de cualquier decimal, hexadecimal u octal número: int (o, incluso, char, short, long long).

    Cuando se asigna una constante, no se puede asignar con 11011011 (curiosamente y por desgracia), pero se puede usar hex. Hex es un poco más fácil de traducir mentalmente. Capitulo nibble (4 bits) y traducir a un personaje en [0-9a-f].

  14. 2

    También puede utilizar el ensamblado en línea como esta:

    int i;
    __asm {
    mov eax, 00000000000000000000000000000000b
    mov i,   eax
    }
    std::cout << i;

    Bien, puede ser un poco excesiva, pero funciona 🙂

    • La solución no es multi-plataforma. En muchas de las arquitecturas que no se puede incluir el código de ensamblado en C. Específicamente en Microsoft Visual studio compilador puede (cuando se compila para x86 32bits). Pero ¿cómo saber si tu procesador tiene ‘eax’ registrarse? Pensar en procesadores ARM en los teléfonos móviles, procesador x64, etc. Ellos no tienen «eax’. Procesador MIPS aun no tienes el comando ‘mov’
  15. 2

    Puede utilizar un bitset

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

    Me extendió la buena respuesta dada por @renato-araña por conseguir el apoyo de:

    • _NIBBLE_(…) – 4 bits, 1 nibble como argumento
    • _BYTE_(…) – 8 bits de datos, 2 nibbles como argumentos
    • _SLAB_(…) – 12 bits, 3 nibbles como argumentos
    • _WORD_(…) – 16 bits, 4 nibbles como argumentos
    • _QUINTIBBLE_(…) – 20 bits, 5 nibbles como argumentos
    • _DSLAB_(…) – 24 bits, 6 nibbles como argumentos
    • _SEPTIBBLE_(…) – 28 bits, 7 nibbles como argumentos
    • _DWORD_(…) – 32 bits, 8 nibbles como argumentos

    Realmente no estoy tan seguro acerca de los términos «quintibble» y «septibble». Si alguien conoce alguna alternativa, por favor hágamelo saber.

    Aquí es la macro reescrito:

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

    Y aquí es Renato con el ejemplo:

    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; */
  17. 0

    Sólo el uso de la biblioteca estándar de C++:

    #include <bitset>

    Necesita una variable de tipo std::bitset:

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

    En este ejemplo, he binario almacenado de 10 en x.

    8ul define el tamaño de los bits, por lo que 7ul significa siete bits y así sucesivamente.

Dejar respuesta

Please enter your comment!
Please enter your name here