Constante externe globale C ++ définie au moment de l’exécution disponible sur plusieurs fichiers source

J’ai une constante entière à définir au moment de l’exécution. Cette constante doit être disponible globalement et sur plusieurs fichiers source. J’ai actuellement la situation simplifiée suivante:

Cela fonctionne parfaitement avec une constante char * que j’utilise pour que le nom du programme soit globalement disponible dans tous les fichiers. Il est déclaré et défini exactement comme celui que j’essaie de déclarer et de définir ici, mais je ne parviens pas à l’obtenir. travailler avec un int .

error: uninitialized const 'someConstant' [-fpermissive] abord une error: uninitialized const 'someConstant' [-fpermissive] à la ligne que je déclare dans main.cpp , puis j’obtiens une error: assignment of read-only variable 'someConstant' que je présume est parce que someConstant est initialisé par défaut.

Y a-t-il un moyen de faire ce que j’essaie de réaliser ici? Merci d’avance!


EDIT (à la demande de @WhozCraig ): Croyez-moi, c’est constant. La raison pour laquelle je ne poste pas MCVE est pour trois raisons: il s’agit d’une tâche, la source est en espagnol et parce que je voulais vraiment que la question soit aussi générale (et réutilisable) que possible. J’ai commencé à écrire l’exemple et à mi-parcours, cela ne m’a pas semblé être la question la plus claire. Je vais essayer d’expliquer à nouveau.

On me demande de créer un programme qui crée un processus qui engendre à son tour deux enfants (ceux-ci en engendrent deux autres chacun, etc.). Le programme prend comme argument unique le nombre de générations qu’il devra engendrer. Créer essentiellement une sorte d’arborescence binary de processus. Chaque processus doit fournir des informations sur lui-même, son parent, la relation avec le processus initial et ses enfants (le cas échéant).

Ainsi, dans l’exemple ci-dessus, ClassA est en réalité une classe contenant des informations sur le processus (PID, PPID, PID pour enfants, degré de relation avec le processus d’origine, etc.). Pour chaque fork je crée une nouvelle instance de cette classe afin de pouvoir “enregistrer” ces informations et les imprimer à l’écran.

Lorsque je définis la relation avec le processus d’origine, il me faut connaître l’argument utilisé lors de l’appel du programme pour vérifier si ce processus n’a pas d’enfant (pour modifier le résultat de ce processus particulier). C’est la constante dont j’ai besoin dans main : le nombre de générations à engendrer, la “profondeur” de l’arbre.


EDIT 2 : Je vais devoir m’excuser, la journée a été longue et je ne pensais pas bien. Je suis passé des sources de C à C ++ uniquement pour utiliser certaines fonctionnalités de OO et j’ai complètement oublié de penser au paradigme de OO. Je venais de réaliser, en expliquant cela, que je pourrais résoudre ce problème avec une variable statique / classe dans ma classe (initialisée avec le processus d’origine), elle pourrait ne pas être constante (bien que ce soit sémantiquement) mais cela devrait fonctionner, non? De plus, j’ai aussi compris que je pouvais simplement initialiser les enfants de la dernière génération avec une valeur PID impossible et l’utiliser pour vérifier s’il s’agissait de la dernière génération.


Désolé les gars et merci pour votre aide: il semble que la question était valide mais c’était la mauvaise question à poser tout le temps. Nouveau mantra: sortez de l’ordinateur et détendez-vous.

Mais juste pour récapituler et restr sur le point, il est absolument impossible de créer une constante globale qui serait définie à l’exécution en C ++, comme @ Jerry101 dit?

En C / C ++, un const est défini à la compilation. Il ne peut pas être défini à l’exécution.

La raison pour laquelle vous pouvez définir un const char *xyz; at runtime is this déclare un pointeur non-const sur un caractère const. Langue délicate.

Donc, si vous voulez un int qui peut être déterminé dans main () et non modifié par la suite, vous pouvez écrire un getter int xyz() qui renvoie une valeur statique initialisée dans main () ou dans le getter.

(En passant, ce n’est pas une bonne idée de déclarer la même variable externe dans plusieurs fichiers d’en-tête.)

Comme d’autres l’ont mentionné, votre variable est loin d’être constante si vous ne la définissez qu’au moment de l’exécution. Vous ne pouvez pas “remonter dans le temps” et inclure une valeur acquise au cours de l’exécution du programme dans le programme lui-même avant sa construction.

Bien entendu, vous pouvez toujours définir quels composants de votre programme ont quel type d’access (en lecture ou en écriture) à votre variable.

Si j’étais vous, je transformerais la variable globale en une variable membre statique d’une classe avec une fonction de lecture publique et une fonction de définition privée. Déclarez le code qui doit définir la valeur en tant qu’ami.

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

N’importe où ailleurs:

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

Vous pouvez encore cacher la classe avec du sucre syntaxique:

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

Enfin, ajoutez une vérification d’erreur pour vous assurer que vous remarquerez que vous essayez d’accéder à la valeur avant qu’elle ne soit définie:

 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 ce qui concerne votre édition:

Rien de tout cela n’a rien à voir avec “OO”. La programmation orientée object concerne les fonctions virtuelles et je ne vois pas en quoi votre problème est lié aux fonctions virtuelles.

char * – signifie que vous créez un pointeur sur le type de données char. int – d’autre part crée une variable. vous ne pouvez pas déclarer une variable const sans valeur, donc je vous suggère de créer un int * et de l’utiliser à la place de int. et si vous passez en fonctions le font comme const

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

qualificateur const signifie que la variable doit être initialisée au sharepoint déclaration. Si vous essayez de changer sa valeur au moment de l’exécution, vous obtenez UB.

Eh bien, l’utilisation de const en C ++ permet au compilateur de connaître la valeur d’une variable au moment de la compilation, de sorte qu’il puisse effectuer une substitution de valeur (un peu comme #define mais beaucoup mieux) chaque fois qu’il rencontre la variable. Vous devez donc toujours assigner une valeur à un const lorsque vous le définissez, sauf lorsque vous faites une déclaration explicite à l’aide de extern. Vous pouvez utiliser un int local pour recevoir la valeur réelle au moment de l’exécution, puis vous pouvez définir et initialiser un int entier avec cette valeur int locale.

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