Para alguna base. Base 1 incluso. Algún tipo de complejo de sustitución -ing.

También, y por supuesto, hacer esto no es una buena idea en la vida real el código de producción. Simplemente le pregunté por curiosidad.

No vas a poder representar a un montón de números en la base 1.
Deberíamos haber salido nunca de la Base 1. los bits están mal.
Um, la base 1 es el mismo que el de un conteo. 101 en la base de uno es (1 * 1^3) + (0 * 1^2) + (1 * 1^1).
¿Desde cuándo la base 1 tiene 2 dígitos? 101 es al menos de base dos.
base 1 sólo puede tener un único símbolo, pero puede representar cualquier número natural (con el símbolo que se repite N veces). en.wikipedia.org/wiki/Unary_numeral_system

OriginalEl autor user318904 | 2010-08-22

8 Comentarios

  1. 10

    Puede relativamente fácil escribir macro que suma dos enteros en binario. Por ejemplo – macro que es la síntesis de dos de 4 bits enteros en binario :

    #include "stdio.h"
    //XOR truth table
    #define XOR_0_0 0
    #define XOR_0_1 1
    #define XOR_1_0 1
    #define XOR_1_1 0
    //OR truth table
    #define OR_0_0 0
    #define OR_0_1 1
    #define OR_1_0 1
    #define OR_1_1 1
    //AND truth table
    #define AND_0_0 0
    #define AND_0_1 0
    #define AND_1_0 0
    #define AND_1_1 1
    //concatenation macros
    #define XOR_X(x,y) XOR_##x##_##y
    #define   OR_X(x,y) OR_##x##_##y
    #define  AND_X(x,y) AND_##x##_##y
    #define OVERFLOW_X(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) OVERFLOW_##rc1 (rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    //stringification macros
    #define STR_X(x) #x
    #define STR(x) STR_X(x)
    //boolean operators
    #define XOR(x,y) XOR_X(x,y)
    #define   OR(x,y) OR_X(x,y)
    #define  AND(x,y) AND_X(x,y)
    //carry_bit + bit1 + bit2
    #define BIT_SUM(carry,bit1,bit2) XOR(carry, XOR(bit1,bit2))
    //carry_bit + carry_bit_of(bit1 + bit2)
    #define CARRY_SUM(carry,bit1,bit2) OR(carry, AND(bit1,bit2))
    //do we have overflow or maybe result perfectly fits into 4 bits ?
    #define OVERFLOW_0(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) SHOW_RESULT(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    #define OVERFLOW_1(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) SHOW_OVERFLOW(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    //draft-horse macros which performs addition of two 4-bit integers
    #define ADD_BIN_NUM(a1,a2,a3,a4, b1,b2,b3,b4) ADD_BIN_NUM_4(0,0,0,0, 0,0,0,0, a1,a2,a3,a4, b1,b2,b3,b4)
    #define ADD_BIN_NUM_4(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) ADD_BIN_NUM_3(rc1,rc2,rc3,AND(CARRY_SUM(0,a4,b4),OR(a4,b4)), rb1,rb2,rb3,BIT_SUM(0,a4,b4), a1,a2,a3,a4, b1,b2,b3,b4)
    #define ADD_BIN_NUM_3(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) ADD_BIN_NUM_2(rc1,rc2,AND(CARRY_SUM(rc4,a3,b3),OR(a3,b3)),rc4, rb1,rb2,BIT_SUM(rc4,a3,b3),rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    #define ADD_BIN_NUM_2(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) ADD_BIN_NUM_1(rc1,AND(CARRY_SUM(rc3,a2,b2),OR(a2,b2)),rc3,rc4, rb1,BIT_SUM(rc3,a2,b2),rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    #define ADD_BIN_NUM_1(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)      OVERFLOW(AND(CARRY_SUM(rc2,a1,b1),OR(a1,b1)),rc2,rc3,rc4, BIT_SUM(rc2,a1,b1),rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    #define OVERFLOW(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) OVERFLOW_X(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4)
    #define   SHOW_RESULT(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) STR(a1) STR(a2) STR(a3) STR(a4) " + " STR(b1) STR(b2) STR(b3) STR(b4) " = " STR(rb1) STR(rb2) STR(rb3) STR(rb4)
    #define   SHOW_OVERFLOW(rc1,rc2,rc3,rc4, rb1,rb2,rb3,rb4, a1,a2,a3,a4, b1,b2,b3,b4) STR(a1) STR(a2) STR(a3) STR(a4) " + " STR(b1) STR(b2) STR(b3) STR(b4) " = overflow"
    void main()
    {
    printf("%s\n", 
    ADD_BIN_NUM(
    0,0,0,1, //first  4-bit int
    1,0,1,1) //second 4-bit int
    );
    printf("%s\n", 
    ADD_BIN_NUM(
    0,1,0,0, //first  4-bit int
    0,1,0,1) //second 4-bit int
    );
    printf("%s\n", 
    ADD_BIN_NUM(
    1,0,1,1, //first  4-bit int
    0,1,1,0) //second 4-bit int
    );
    }

    Esta macro puede ser fácilmente extendido para la adición de dos de 8 bits o de 16 bits o incluso 32 bits enteros.
    Así que, básicamente, todo lo que necesitamos es token de concatenación y reglas de sustitución para lograr resultados sorprendentes con macros.

    EDICIÓN:
    He cambiado el formato de los resultados y lo que es más importante -, he añadido el desbordamiento de verificación.

    HTH!

    OriginalEl autor Agnius Vasiliauskas

  2. 12

    El preprocesador opera en el preprocesamiento de fichas y el único momento en el que se evalúa los números es durante la evaluación de un #if o #elif directiva. Aparte de eso, los números no son realmente los números durante el preprocesamiento; éstos se clasifican como el preprocesamiento número tokens, que en realidad no son números.

    Podría evaluar la aritmética básica el uso de token de concatenación:

    #define ADD_0_0 0
    #define ADD_0_1 1
    #define ADD_1_0 1
    #define ADD_1_1 2
    #define ADD(x, y) ADD##_##x##_##y
    ADD(1, 0) //expands to 1
    ADD(1, 1) //expands to 2

    Realmente, sin embargo, no hay ninguna razón para ello, y sería tonto para hacerlo (tendrías que definir un gran número de macros para que sea ni remotamente útil).

    Sería más sensato tener una macro que se expande a una integral de la expresión de la constante de que puede ser evaluado por el compilador:

    #define ADD(x, y) ((x) + (y))
    ADD(1, 1) //expands to ((1) + (1))

    El compilador será capaz de evaluar la 1 + 1 expresión.

    Siempre me gusta ver el ## haciendo el verdadero trabajo.

    OriginalEl autor James McNellis

  3. 5

    Sé que no es el preprocesador, pero si ayuda, usted puede hacerlo con las plantillas. Tal vez usted podría usar esto en conjunto con una macro para lograr lo que usted necesita.

    #include <iostream>
    using namespace std;
    template <int N, int M>
    struct Add
    {
    static const int Value = N + M;
    };
    int main()
    {
    cout << Add<4, 5>::Value << endl;
    return 0;
    }
    Por qué no usar simplemente Value = N + M dentro de Add?
    buen punto, gracias. He actualizado mi respuesta.

    OriginalEl autor Chris Schmich

  4. 5

    Es muy posible hacer delimitada entero de la adición en el preprocesador. Y, en realidad, es necesario más a menudo de lo que sería realmente la esperanza, es decir, la alternativa de tener sólo ((2) + (3)) en el programa no funciona. (E. g., usted no puede tener una variable llamada x((2)+(3))). La idea es simple: gire la adición a los incrementos, que no te importa (mucho) listado de todos ellos. E. g.,

    #define INC(x) INC_ ## x
    #define INC_0 1
    #define INC_1 2
    #define INC_2 3
    #define INC_3 4
    #define INC_4 5
    #define INC_5 6
    #define INC_6 7
    #define INC_7 8
    #define INC_8 9
    #define INC_9 10
    INC(7) //=> 8

    Ahora sabemos cómo hacer la adición de hasta 1.

    #define ADD(x, y) ADD_ ## x(y)
    #define ADD_0(x) x
    #define ADD_1(x) INC(x)
    ADD(0, 2) //=> 2
    ADD(1, 2) //=> 3

    Para añadir aún mayores de los números, necesitamos algún tipo de «recursividad».

    #define ADD_2(x) ADD_1(INC(x))
    #define ADD_3(x) ADD_2(INC(x))
    #define ADD_4(x) ADD_3(INC(x))
    #define ADD_5(x) ADD_4(INC(x))
    #define ADD_6(x) ADD_5(INC(x))
    #define ADD_7(x) ADD_6(INC(x))
    #define ADD_8(x) ADD_7(INC(x))
    #define ADD_9(x) ADD_8(INC(x))
    #define ADD_10(x) ADD_9(INC(x))
    ADD(5, 2) //=> 7

    Uno tiene que tener cuidado en esto, sin embargo. E. g., la siguiente no funciona.

    #define ADD_2(x) INC(ADD_1(x))
    ADD(2, 2) //=> INC_ADD_1(2)

    Para cualquier uso prolongado de estos trucos, Impulsar el Preprocesador es tu amigo.

    OriginalEl autor Isaac To

  5. 4

    Al parecer, usted puede. Si usted echa un vistazo a la Impulsar El Preprocesador de la biblioteca, usted puede hacer todo tipo de cosas con el preprocesador, incluso entero además.

    El Impulso de preprocesador (la última vez que revisé, hace un par de años) falta de cumplimiento con las especificaciones. La adición de bits no se encuentra en la especificación.
    No estoy hablando sobre el Impulso de la Onda de la biblioteca, que es una implementación de una C/C++ pre-procesador que usted puede utilizar en su código, sino más bien el Impulso de Preprocesador de la biblioteca, que utiliza el preprocesador ya integrada en el compilador C/C++ para hacer cosas asombrosas.

    OriginalEl autor Ferruccio

  6. 1

    El preprocesador de C puede evaluar condicionales que contiene aritmética de enteros. No va a sustituir las expresiones aritméticas y pasar el resultado para el compilador, pero el compilador evaluar aritmética constantes en tiempo de compilación y emite el resultado en binario, siempre y cuando usted no ha sobrecargado los operadores se usan.

    OriginalEl autor Chris

  7. 1

    Macros del preprocesador en realidad no puede hacer aritmética, pero que puede ser útil aprovechar para hacer matemáticas con las enumeraciones. El general truco es tener una macro que llama a otras macros, y pueden ser repetidamente invocado el uso de diferentes definiciones de aquellas otras macros.

    Por ejemplo, algo como:

    #define MY_THINGS \ 
    a_thing(FRED,4) \ 
    a_thing(GEORGE,6) \ 
    a_thing(HARRY,5) \ 
    a_thing(HERMIONE,8) \ 
    a_thing(RON,3) \ 
    //Esta línea a la izquierda en blanco 
    #define a_thing(nombre,tamaño) EN_##nombre}; enum {EN_SIZE_##nombre=(tamaño),EN_BLAH_##name = EN_##nombre+(tamaño-1), 
    enum {EN_FIRST_THING=0, MY_THINGS EN_TOTAL_SIZE}; 
    #undef a_thing 
    

    Que le permitirá a uno ‘asignar’ una cierta cantidad de espacio para cada cosa, por ejemplo, en una matriz. La matemática no es hecho por el preprocesador, pero las enumeraciones son considerados como constantes en tiempo de compilación.

    OriginalEl autor supercat

  8. 0

    Estoy bastante seguro de la C/preprocesador de C++ hace copiar y pegar … no es realmente evaluar las expresiones. La evaluación de la expresión es realizada por el compilador.

    Para mejor responder a su pregunta, usted puede publicar lo que estás tratando de lograr.

    El preprocesador no realizar alguna evaluación de la expresión. El #if y #elif directivas de ambas tomar las expresiones que deben ser macro sustituido y luego evaluado para determinar si la evaluación es verdadero o falso (o uno o cero, en C).

    OriginalEl autor greatwolf

Dejar respuesta

Please enter your comment!
Please enter your name here