Déclarer un object de classe globalement mais sans parameters

Voici donc ma situation: j’ai une classe foo résidant dans foo.cpp avec le fichier d’en-tête foo.h inclus dans mon fichier main.cpp. Je dois pouvoir déclarer un object foo en tant que variable globale dans main.cpp afin qu’il soit disponible pour toutes les fonctions de main.cpp sans avoir à lui transmettre une référence à chaque fois. Le problème est que le constructeur de foo nécessite une variable qui n’est pas récupérée de l’utilisateur jusqu’à la moitié de la fonction principale de main.cpp. Je pensais pouvoir le faire de cette façon:

static foo myFoo;

En tant que variable globale située au-dessus de la fonction principale, puis, une fois les données nécessaires extraites de l’utilisateur (appelons-le “variable”), je pourrais appeler:

 myFoo = new foo(variable);

Je reçois cependant une erreur avec ceci:

erreur: pas de fonction correspondante pour l’appel à ‘foo :: foo ()’
Vecteurs et nombres énormes
Les sockets UDP définissent-ils les données reçues en messages distincts ou recv lit-il autant de données que possible simultanément?
gtkmm gérer / append vs pointeurs intelligents:
Erreur de l’éditeur de liens C ++ lors de la tentative de construction à partir de fichiers object créés à l’aide de makefile. Ne se produit pas quand je viens de le construire
Définir un rectangle de découpage pour OpenGL?

référençant la ligne avec static foo myFoo;

Donc, cela signifie essentiellement que j’essaie de déclarer une instance de foo avec un constructeur ne prenant aucun argument, alors qu’il n’y en a aucun.

Ma question est donc la suivante: existe-t-il un moyen de déclarer une étiquette myFoo de foo en tant que variable globale afin que le programme soit compilé, puis de pouvoir l’instancier ultérieurement à l’aide du constructeur avec une variable passée?

Je sais que je pourrais faire quelque chose comme ça:

 ssortingng temp = ""; static foo myFoo(temp);

au-dessus de main () et puis avoir une fonction définie où je pourrais faire

 myFoo.setVar(variable);

quand j’en avais besoin. Pour moi, cela est très moche et nécessite l’inclusion de la fonction setVar qui n’a pas d’autre objective tangible que de contourner ce problème. Pensées?

Une option que vous avez est de faire de votre instance statique un pointeur:

 static foo *myFoo = NULL; // Later... myFoo = new foo(variable);

Ou vous pouvez utiliser un constructeur par défaut et créer une méthode Init place.

 static foo myFoo; // Later... myFoo.Init( variable );

Lorsque vous exposez une variable, vous ne la définissez pas comme static . Supprimez le mot clé static et utilisez extern dans la déclaration d’en-tête.

 static foo myFoo;

Cette ligne créera un nouvel object de type foo lors de l’initialisation statique de votre programme. Il appellera le constructeur par défaut (si vous n’en définissez pas, le compilateur en créera un pour vous dans certaines situations – vous n’avez pas posté suffisamment de code pour savoir si c’est le cas ici). Notez que s’il est défini dans un fichier d’en-tête, vous devrez l’ extern .

Tentative de définir myFoo sur un pointeur à l’aide de

 myFoo = new foo(variable);

ne pas comstackr. new foo(...) retourne un foo* , pas un foo . Si vous voulez que ce soit un pointeur, vous devez déclarer votre variable statique en tant que

 static foo* myFoo;

Si vous voulez que ce soit un object et que vous souhaitiez le définir sur autre chose que celui par défaut, vous pouvez implémenter un opérateur d’atsortingbution de copie et procéder de la sorte

 foo newFoo(variable); myFoo = newFoo;

Vous pouvez également fournir une fonction d’initialisation pour modifier les valeurs de construction ultérieurement (préférez l’atsortingbution de copie dans la plupart des cas car elle sera moins sujette aux erreurs).

Je crois que vous ne définissez peut-être pas le constructeur par défaut. Une fois que vous avez défini un constructeur, le constructeur par défaut n’est pas automatiquement défini. Cela fonctionne pour moi:

myclass.hpp:

 #ifndef _MYCLASS_ #define _MYCLASS_ class myClass { public: int I; myClass(int i); myClass(); }; #endif

myclass.cpp:

 #include "myclass.hpp" myClass::myClass(int i) : I(i) {}; myClass::myClass() : I(0) {};

main.cpp:

 #include "myclass.hpp" myClass myGlobalClassObject; int main() { myClass myLocalClassObject(1); myGlobalClassObject.I = 2; return 0; }

Vous indiquez que votre object foo ne peut être correctement instancié qu’à mi-parcours de la fonction principale. Cela ressemble à un object dont l’état sera incohérent pendant la première moitié de votre fonction principale. Très dangereux. Quoi qu’il en soit, il existe deux manières d’y accéder: 1) Si vous voulez créer un object statique foo, vous pouvez utiliser une valeur par défaut pour votre constructeur:

  classe foo {
 Publique:
     toto (type variable = valeur par défaut) {
         ...
     }
 ...

Vous pouvez maintenant déclarer votre object foo en tant que global dans foo myFoo; principal foo myFoo; et la variable de myFoo sera initialisée avec “default” ou, sans valeur par défaut:

  classe foo {
 Publique:
     toto (type variable) {
         ...
     }
 ...

Déclarez votre object foo en tant que global dans foo myFoo(default); principal foo myFoo(default);

Selon que votre application a un sens ou non, vous pouvez maintenant utiliser votre object myFoo dans les fonctions de main.cpp. Si «défaut» n’a pas de sens, vous devrez append une fonction de test avant d’utiliser myFoo. Bien sûr, vous avez également besoin d’une autre fonction membre pour pouvoir définir «variable» sur votre entrée utilisateur (quelque chose comme set_variable (variable);)

2) Utilisez un pointeur. Déclarez un object global foo * myFoo dans main.cpp et vérifiez si le pointeur est à NULL avant de l’utiliser. Désormais, votre constructeur n’a plus besoin d’une valeur par défaut, mais de la variable suivante: foo::foo(type variable) { ... } Vous initialisez votre object myFoo en utilisant: myFoo = new foo(user_input);

Vous pouvez tester le pointeur myFoo sur NULL car toutes les variables globales non initialisées sont définies sur 0 par le code de démarrage.

(En passant: vous réalisez bien sûr que les globals sont mal vus et en tant que tels devraient être évités)

Bonne chance