Constante externa global de C ++ definida en tiempo de ejecución disponible en múltiples archivos de origen

Tengo una constante entera que se define en tiempo de ejecución. Esta constante debe estar disponible globalmente y en múltiples archivos de origen. Actualmente tengo la siguiente situación simplificada:

  • ClassA.h declara extern const int someConstant;

  • ClassA.cpp usa someConstant en algún punto.

  • Constants.h declara extern const int someConstant;

  • main.cpp incluye ClassA.h y Constants.h , declara const int someConstant , y en algún momento durante main() intenta inicializar someConstant al valor real durante el tiempo de ejecución.

Esto funciona perfectamente con una constante de caracteres char * que utilizo para tener el nombre del progtwig disponible globalmente en todos los archivos, y se declara y define exactamente como el que bash declarar y definir aquí, pero no puedo hacerlo. trabajar con un int .

Primero obtengo un error: uninitialized const 'someConstant' [-fpermissive] en la línea en la que lo declaro en main.cpp , y luego recibo un error: assignment of read-only variable 'someConstant' que supongo que es porque someConstant se está inicializando por defecto para empezar.

¿Hay una manera de hacer lo que estoy tratando de lograr aquí? ¡Gracias por adelantado!


EDITAR (a petición de @WhozCraig ): Créeme: es constante. La razón por la que no publico MCVE es por tres razones: esta es una tarea, la fuente está en español y porque realmente quería mantener la pregunta tan general (y reutilizable) como fuera posible. Comencé escribiendo el ejemplo y, a mitad de camino, me pareció que no era la pregunta más clara. Voy a tratar de explicar de nuevo.

Me piden que construya un progtwig que cree un proceso que a su vez genere dos hijos (los que a su vez generarán dos más cada uno, y así sucesivamente). El progtwig toma como único argumento el número de generaciones que tendrá que generar. Esencialmente creando una especie de árbol binario de procesos. Cada proceso debe proporcionar información sobre sí mismo, sus padres, la relación con el proceso original y sus hijos (si corresponde).

Entonces, en el ejemplo anterior, ClassA es realmente una clase que contiene información sobre el proceso (PID, PPID, PID para niños, grado de relación con el proceso original, etc.). Para cada fork creo una nueva instancia de esta clase, por lo que puedo “guardar” esta información e imprimirla en la pantalla.

Cuando estoy definiendo la relación con el proceso original, hay un único punto en el que necesito conocer el argumento utilizado al llamar al progtwig para verificar si este proceso no tiene hijos (para cambiar la salida de ese proceso en particular). Esa es la constante que necesito de main : el número de generaciones a generar, la “profundidad” del árbol.


EDITAR 2 : tendré que disculparme, ha sido un día largo y no estaba pensando con claridad. Cambié las fonts de C a C ++ solo para usar algunas características OO y olvidé por completo pensar dentro del paradigma OO. Me di cuenta, mientras estaba explicando esto, que podría resolver esto con una variable estática / clase dentro de mi clase (inicializada con el proceso original), podría no ser constante (aunque sea semánticamente) pero debería funcionar, ¿verdad? Además, también me di cuenta de que solo podía inicializar a los niños de la última generación con un valor PID imposible y usar eso para verificar si es la última generación.


Lo siento chicos y gracias por su ayuda: parece que la pregunta era válida, pero era la pregunta incorrecta que se debía hacer todo el tiempo. Nuevo mantra: alejarse de la computadora y relajarse.

Pero solo para recapitular y para mantener el punto, es absolutamente imposible crear una constante global que se definiría en tiempo de ejecución en C ++, como dice @ Jerry101 .

En C / C ++, una const se define en tiempo de comstackción. No se puede establecer en tiempo de ejecución.

La razón por la que puede establecer un const char *xyz; en tiempo de ejecución se declara un puntero no constante a un carácter const. Lenguaje complicado

Por lo tanto, si desea un int que pueda determinarse en main () y no cambiarlo posteriormente, puede escribir un int xyz() gety int xyz() que devuelve un valor estático que se inicializa en main () o en el getter.

(Por cierto, no es una buena idea declarar la misma variable externa en más de un archivo de encabezado).

Como han mencionado otros, su variable está lejos de ser constante si la configura solo en tiempo de ejecución. No puede “viajar en el tiempo” e incluir un valor ganado durante la ejecución del progtwig en el progtwig antes de que se construya.

Lo que todavía puede hacer, por supuesto, es definir qué componentes de su progtwig tienen qué tipo de acceso (lectura o escritura) a su variable.

Si yo fuera usted, convertiría la variable global en una variable miembro estática de una clase con una función de obtención pública y una función de establecimiento privado. Declare el código que debe establecer el valor como amigo.

 class SomeConstant { public: static int get() { return someConstant; } private: friend int main(); // this should probably not be `main` in real code static void set(int value) { someConstant = value; } static int someConstant = 0; }; 

En main :

 int main() { SomeConstant::set(123); } 

En cualquier otro lugar:

 void f() { int i = SomeConstant::get(); } 

Puedes ocultar aún más la clase con un poco de azúcar sintáctico:

 int someConstant() { return SomeConstant::get(); } // ... void f() { int i = someConstant(); } 

Finalmente, agregue algunas comprobaciones de errores para asegurarse de que observa si intenta acceder al valor antes de configurarlo:

 class SomeConstant { public: static int get() { assert(valueSet); return someConstant; } private: friend int main(); // this should probably not be `main` in real code static void set(int value) { someConstant = value; valueSet = true; } static bool valueSet = false; static int someConstant = 0; }; 

En lo que respecta a su edición:

Nada de esto tiene nada que ver con “OO”. La progtwigción orientada a objetos se trata de funciones virtuales, y no veo cómo su problema está relacionado con las funciones virtuales.

char * – significa ur creando un puntero al tipo de datos char. int – por otro lado crea una variable. No se puede declarar una variable constante sin valor, por lo que sugiero crear un int * y usarlo en lugar de int. y si lo estás pasando en funciones hazlo como const

 eg: int *myconstant=&xyz; .... my_function(myconstant); } //function decleration void my_function(const int* myconst) { .... } 

calificador const significa variable debe inicializarse en el punto de statement. Si está intentando cambiar su valor en tiempo de ejecución, obtiene UB.

Bueno, el uso de const en C ++ es para que el comstackdor conozca el valor de una variable en el momento de la comstackción, de modo que pueda realizar la sustitución de valores (como #define pero mucho más mejor) siempre que encuentre la variable. Por lo tanto, siempre debe asignar un valor a una constante cuando lo defina, excepto cuando esté realizando una statement explícita utilizando extern. Puede usar un int local para recibir el valor real en el tiempo de ejecución y luego puede definir e inicializar un int constante con ese valor int local.

 int l_int; cout<<"Enter an int"; cin>>l_int; const int constNum = l_int;