¿Se puede hacer un compilador incremental constante?

Question

Mientras que suena sin sentido .....

Quiero una constante en el que cada vez que lo utilice se aumentará en 1

int x; 
int y; 
x = INCREMENTING_CONSTANT; 
y = INCREMENTING_CONSTANT; 

donde x == 1; y y == 2

Nota No quiero y = INCREMENTING_CONSTANT + 1 soluciones de tipo.

Básicamente quiero utilizarlo como un ID único tiempo de compilación (por lo general no se utiliza en código como el ejemplo, pero dentro de otra macro)

Answer 1

Bueno, no es constante, entonces, ¿verdad? ;)

Usted puede hacer esto con una función:

int id() { 
    static int i = 0; 
    return ++i; 
} 

x = id(); 
y = id(); 

Como se muestra, esto no es seguro para subprocesos. Para hacer eso, necesitaría proteger esto con un mutex, o usar un compilador/incrementador atómico específico de la plataforma.

Answer 2

Una "constante creciente" es un oxímoron. No puedes hacer esto en tiempo de compilación.

Answer 3

Usted puede ser capaz de poner algo juntos usando Boost.Preprocessor (Funciona con C) y BOOST_PP_COUNTER

ejemplo dado en la página docs:

#include <boost/preprocessor/slot/counter.hpp> 
BOOST_PP_COUNTER // 0 

#include BOOST_PP_UPDATE_COUNTER() 
BOOST_PP_COUNTER // 1 

#include BOOST_PP_UPDATE_COUNTER() 
BOOST_PP_COUNTER // 2 

#include BOOST_PP_UPDATE_COUNTER() 
BOOST_PP_COUNTER // 3 

Traducido al lo que quiere

#include <boost/preprocessor/slot/counter.hpp> 

int x = BOOST_PP_COUNTER; // 0 

#include BOOST_PP_UPDATE_COUNTER() 
int y = BOOST_PP_COUNTER;// 1 

#include BOOST_PP_UPDATE_COUNTER() 
int z = BOOST_PP_COUNTER; // 2 

También podría usar ranuras (un poco más flexible a cambio de más código que la solución anterior):

#include <boost/preprocessor/slot/slot.hpp> 

#define BOOST_PP_VALUE 0 //ensure 0 to start 
#include BOOST_PP_ASSIGN_SLOT(1) 
int a = BOOST_PP_SLOT(1); //0 

#define BOOST_PP_VALUE 1 + BOOST_PP_SLOT(1) 
#include BOOST_PP_ASSIGN_SLOT(1) 
int b = BOOST_PP_SLOT(1); //1 

Answer 4

Si sólo necesita algo único ID ish, se puede utilizar el símbolo __LINE__ preprocesador? No es lo que estás pidiendo, pero podría funcionar para tus propósitos.

Answer 5

No es estándar, pero algunos compiladores admiten la macro __COUNTER__. Ver Has anyone ever had a use for the __COUNTER__ pre-processor macro?

Answer 6

A menudo he deseado variables de tiempo de compilación. Sin embargo, lo más fácil sería simplemente definir constantes para cada uno de forma individual.

La respuesta sobre el problema de la hebra podría resolverse mediante el uso de un functionoid en alguna clase de estado global o un tipo similar de solución si está utilizando C en lugar de C++.

También podría intentar usar un xmacro. Crear un nuevo archivo, vamos a llamarlo xmacro.h

INCREMENTING_CONSTANT; 
#define INCREMENTING_CONSTANT INCREMENTING_CONSTANT + 1 

Luego, en un encabezado estándar,

#define INCREMENTING_CONSTANT 0 
#define USE_INCREMENTING_CONSTANT #include "xmacro.h" 

const int x = USE_INCREMENTING_CONSTANT 

No he probado esto, pero xmacros tienen un poder increíble que las macros regulares puede' uso, como defs/undefs, y mi intuición dice que debería funcionar. El preprocesador es poderoso, pero bastante tonto, por lo que podría fallar.

Answer 7

¿Desea que x y y sean constantes? Si es así lo más fácil y más limpio que hacer puede ser utilizar una enumeración anónima:

enum { 
    x = 1, 
    y 
    /* Add new ones here. */ 
}; 

Esto significa que sólo tiene que añadir un nuevo nombre a la lista y se les dará el siguiente valor entero. Este es un truco útil en el que no importa cuáles sean los valores (fuera del tiempo de ejecución), siempre que sean distintos. Por ejemplo, al asignar identificadores a los controles en una interfaz gráfica de usuario, que suelen aparecer:

enum { 
    button1_id = FIRST_USER_ID, 
    button2_id, 
    combo_id, 
    ... 
} 

Algunos marcos de interfaz gráfica de usuario proporcionan una función getUserId() que va a generar una nueva (utilizando una variable estática interna); pero creo que esto sucede en tiempo de ejecución. También es un poco tedioso ver tantas llamadas consecutivas.

button1_id = GetUserId(); 
button2_id = GetUserId(); 
combo_id = GetUserId(); 
... 

Answer 8

Aquí hay una manera fea de implementarlo.

static int _counter=0; 
#define INCREMENTING_CONSTANT (_counter++) 

Answer 9

En mi caso yo quería tener una clave única para todo el sistema para cada subsistema, pero la selección de los subsistemas dependería de la persona que utiliza el sistema. Estos deben ser valores de 8 bits porque están destinados a sistemas integrados.

Esto es lo que me ocurrió hace un momento:

#define LAST_KEY -1 

// SUB1_KEY definition 
enum { 
    SUB1_KEY_ORIGIN = LAST_KEY, 
    SUB1_KEY, 
}; 
#undef LAST_KEY 
#define LAST_KEY SUB1_KEY 

// SUB2_KEY definition 
enum { 
    SUB2_KEY_ORIGIN = LAST_KEY, 
    SUB2_KEY, 
}; 
#undef LAST_KEY 
#define LAST_KEY SUB2_KEY 

// SUB3_KEY definition 
enum { 
    SUB3_KEY_ORIGIN = LAST_KEY, 
    SUB3_KEY, 
}; 
#undef LAST_KEY 
#define LAST_KEY SUB3_KEY 

// .... 

el reto será asegurarse de que los incluya la cadena que lleva en cada uno de estos bloques se compila en el mismo orden cada vez.