Utilisation d'un même objet dans 2 fichiers distincts

Bonjour,


J'ai un objet dans une classe qui contient une variable entrée par l'utilisateur que j'aimerai reutiliser dans une autre classe d'un autre fichier.


Fichier A:

Code:

---

1 2 3 4

Classe A { objetA->variable1 }

---

J'aimerai dans le fichier B:

Code:

---

1 2 3 4

Classe B { objetA->variable1 }

---

Est-ce possible ?


Je bloque et je n'ai pas trouvé de solution sur le net, si quelqu'un à des pistes ou à besoin d'informations nécessaires.


Merci

Bonjour,

La question me semble est un peu vague cela dépend essentiellement de comment est architecturé le projet.
Un bout de code correspondant a ton problème serait plus parlant.

Très vague en effet...

La réponse est sans doute dans composition / agrégation :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <iostream>   struct A { A(const char* name) : name_m(name) {}   std::string name_m; };   struct B { B(A& a) : a_m(a) { }   void use() { std::cout << "hello " << a_m.name_m << '\n'; }   A& a_m; };   int main() { A a("world");; B b(a); b.use(); }

---

Le projet est assez complexe, je vais essayé de vous représenter mon problème de manière simplifier :

Nous avons 3 classes A B C

Fichier A.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class A : public QObject Q_OBJECT   public :   explicit A(QObject* parent=0);   ...   protected:   Class C *objet;

---

Fichier A.cpp

Code:

---

1 2 3 4 5 6

void A::...() { objet= new C(...); objet-> variable %%"Variable" correspond à une valeur entrée par l'utilisateur }

---

J'aimerai utilisé "variable" dans un fichier B.cpp tel que

Code:

---

1 2 3 4 5

void C::...() { z=variable + x ; %% Exemple simplifié mais variable appartient à la classe A et x a la classe C en gros }

---

Je ne sais pas si j'ai tout bien précisé si il vous manque des informations vous pouvez me le signaler, je suis toujours un débutant :mouarf:

Merci

Apparemment tu veux juste accéder a A->variable en lecture ?

Une solution est que A possède un accesseur sur variable

Code:

---

1 2 3 4 5 6 7 8

class A { private: T variable;   public: const T& getVariable() const { return variable;} };

---

et donc dans C

Code:

---

1 2 3 4

C::C(const A& a) { z = a.getVariable() +x; }

---

On pourrais aussi se limiter a n'envoyer que variable a C tout dépend

Code:

---

1 2 3 4

C::C(const T& variable) { z = variable + x; }

---

ici T est le type de variable.
Après je ne sais pas si ça répond a la question car Bktero à fait un peu la même réponse.

Je pense que ta méthode est proche de ce que je recherche, cependant j'ai des erreurs car ma variable est récuperer d'une SpinBox d'une fenêtre Qt j'avais deja une fonction getVariable() tel que :

Code:

---

1 2 3 4

int getVariable() { return variable->value(); }

---

Cela fonctionnait dans mon fichier A ca me permettait bien de recuperer la valeur que l'utilisateur entre mais dans le second fichier je n'arrive pas a reutiliser cette valeur (Desole si je fais des remarques de debutants).

Du coup quand je fais :

C::NomMethode ( const int& variable) ou

C::NomMethode ( const A& variable)


J'ai "NomMethode" qui est souligné en rouge et je n'arrive pas a avoir accés a getVariable() ni a Variable à l'interieur de ma classe.

Il y a quelque chose qui m'echappe, vous voulez que je vous précise plus le code ? Et je n'ai pas bien compris le fonctionnement de votre méthode, pourquoi Const ?

Le mieux c'est que tu postes les bouts de code utile alors.
const indique juste que la variable ne peut pas être modifiée (accès en lecture).
c'est peut être ce modificateur qui pose problème si tu passe en paramètre au constructeur une méthode qui retourne un int ?

Salut,

J'ai l'impression, sur base de ton explication (particulièrement vague, comme les autres l'ont déjà signalé) que, ce que tu cherches à faire, s'appelle: une variable globale.

Et, si c'est bien le cas, la réponse est "oui, il y a moyen d'accéder à une variable globale, définie dans un fichier d'implémentation différent".

Un simple exemple, pour que tous les fichiers puissent savoir que la variable existe, nous pouvons parfaitement la déclarer comme extern dans un fichier d'en-tête, et la définir (correctement) dans un fichier d'implémentation par la suite, sous une forme proche de
fichier a.hpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#ifndef A_HPP_INCLUDED #define A_HPP_INCLUDED   class A{ public: A(int x, int y); void foo(); };   extern A aGlobal; //indique qu'il existe "quelque part" une variable globale nommée aGlobale #endif

---

fichier a.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <a.hpp> #include <iostream> A aGlobal{3,5}; // défini la variable globale nommée aGlobal en lui fournissant les paramètres dont elle a besoin   /* les fonctions spécifiques à la classe A */   A::A(int x, int y){ } void A::foo(){ std::cout<<"dans A::foo()\n"; }

---

et on peut terminer avec un fichier d'implémentation différent proche de
main.cpp

Code:

---

1 2 3 4

#include <a.hpp> int main(){ aGlobal.foo(); }

---

Le tout, une fois compilé, produisant sans grande surprise l'affichage

Code:

---

dans A::foo()

---

Mais, il faut savoir que les variables globales, C'EST MAL!!!!.

Je pourrais te donner toute une série de raisons à ce fait, mais je ne vais en donner qu'une seule:

Si tu peux accéder à cette variable depuis n'importe quel fichier d'implémentation (*.cpp), cela veut dire que ... n'importe quelle fonction peut aller "y chipoter".

Et si n'importe quelle fonction peut aller y chipoter, cela veut dire qu'il devient quasiment impossible de connaître l'état de ta variable aGlobal au moment où tu décide d'y avoir recours car son état -- à un instant T de l'exécution de ton programme -- va dépendre... de toutes les fonctions qui auront été exécutées depuis le lancement du programme et qui auront été chipoter à cette variable.

Or, le propre de la programmation est de se baser sur des "états prédictibles": quel que soit le moment auquel nous tentons d'accéder à une donnée, nous devons être en mesure de déterminer l'état (idéalement, sans même avoir à réfléchir et, dans tous les cas, sans avoir recours au débuggeur) dans lequel se trouve la donnée, de manière à savoir ... quel traitement lui faire subir afin d'obtenir le résultat souhaité.

Avec une variable globale, cela devient purement et simplement impossible :aie:

Il existe, bien sur, quelques exceptions pour lesquelles l'utilisation d'une variable globale prend "tout son sens" ou dans lesquelles "on n'a vraiment pas d'autre choix" que d'y avoir recours.

Mais saches que l'idéal, quel que soit la manière dont on accède à une donnée, l'idéal restera toujours d'éviter comme la peste les variables globales ;)

Merci pour vos réponses, je vais essayer le principe de la variable globale.

Je reexplique clairement mon problème:

J'ai une solution contenant différents projets :

Un projet me concerne appelons le "projet" :

Ce projet contient différents fichiers .h et .cpp ainsi qu'un fichier .ui , le fichier .ui contient une fenêtre ou l'utilisateur peut choisir la valeur de certains attributs, ici l'attribut "pente" nous concerne.

Fichier .ui et fichier ui___.h

Code:

---

1 2 3 4 5

<layout class="QGridLayout" name="gridLayout"> <item row="0" column="0"> <widget class="QSpinBox" name="pente"/> </item> </layout>

---

Code:

---

1 2	QSpinBox *pente; pente = new QSpinBox(groupBox_3);

---

Ensuite j'agis sur la valeur de "pente" dans mon fichier principal :principal.h et principal.cpp

principal.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

class qPrincipal : public QObject, public ccStd { Q_OBJECT Q_INTERFACES(ccStd)     public:     explicit qPrincipal(QObject* parent = 0);   .....       protected slots:     void itemChanged(); void doAction(); void gradd(); void cancel();   protected:       ccPrincipal *dialog;   };

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void qPrincipal::doAction() { .......   dialog = new ccPrincipal(....);     int pentee = 3;   dialog->pente->setValue(pentee);   dialog->show();       connect(dialog->pente, SIGNAL(valueChanged(int)), this, SLOT(itemChanged()));

---

Ce qui m'initialise la valeur de pente à 3 et l'utilisateur peut la modifier ce qui la modifie automatiquement dans "pente" ensuite je récupere cette attribut comme cela:

ccPrincipal.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

ccPrincipal::ccPrincipal(QWidget* parent) : QDialog(parent, Qt::Tool) , Ui_surfacee() { setupUi(this); this->setWindowFlags(((this->windowFlags() | Qt::CustomizeWindowHint) & ~Qt::WindowCloseButtonHint));   }     int ccPrincipal::getPente() { return pente->value();   }

---

ccPrincipal.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class ccPrincipal : public QDialog, public Ui_surfacee { public: explicit ccPrincipal(QWidget* parent = 0);     int getPente();   };       #endif

---

Jusque la tout fonctionne

Maintenant j'aimerai utiliser mon attribut "pente" dans un autre fichier avec d'autres classes, voir fichier suivant

calcul.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

bool Calcul::calculmoyen(const DgmOctree::octreeCell& cell, void** additionalParameters, NormalizedProgress* nProgress/*=0*/) {   .... if (counter != 0) { gN = static_cast<ScalarType>(atan(sum.norm() / counter) * 180 / 3.14);   if (gN < pente) { gN = 0; } }   } }   ... }

---

J'aimerai comparer gN à pente, j'ai essayé la méthode que vous m'avez proposé mais lorsque je déclare dans ma classe ( const int& pente) ou (const ccPrincipal& a) le nom de ma méthode est souligné en rouge et j'ai comme erreur "déclaration incompatible avec "bool calcul::calculmoyen...." J'ai suivi pourtant rigoureusement ce que vous m'avez expliqué, cependant je n'ai pas bien compris le sens c'est pourquoi je n'arrive pas à comprendre l'erreur, j'espere que les codes que j'ai ajouter sont clairs j'ai essayé de simplifier au maximum.

Quand tu parles de différents projets tu parles de deux exéutables distincts ?
Qui appelle Calcul::calculmoyen ?

J'ai un executable et des dll dans ma solution, mais mon problème se situe dans le même projet. En effet l'attribut que je veux récupérer je veux le récupérer dans un fichier du même projet. Après quelques tentatives j'ai toujours une erreur de ce type "une reference de membre non statique doit etre relative a un objet spécifique" je ne sais pas si je vais dans la bonne direction.

Tu n'aurais pas une histoire d'un mélange d'un contexte statique avec un contexte non-statique ? (mot clé static)

Apparement si, mais mon premier problème est d'abord de savoir comment "recupérer" la valeur de "pente" dans mon fichier au moins qu'il trouve le chemin pour accèder a cette valeur, ensuite je chercherais le problème de mélange de contexte (statique non-statique), chose que je ne maitrise pas en tant que débutant

Certes mais on ne peut pas t'aider avec des explications trop vagues.
Il y a peut être des includes qui manquent ou des problèmes à l'edition des lien...
Il faudrait avoir le fichier où tu appelle Calcul::calculmoyen en entier avec le .h associé ce serait peut être un début.

Je crois que tu as raison, mon problème vient du fait que dans mon .h le prototype de calculmoyen est "static" :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

namespace CClib {   class CC_CORE_LIB_API Calcul: public CCToolBox   Public:   ....     protected:   static bool calculmoyen (const DgmOctree::octreeCell& cell, void** additionalParameters, NormalizedProgress* nProgress/*=0*/);

---

Du coup y a-t-il une solution a ce problème de staticité ?

Et si quelqu'un pourrait m'expliquer pourquoi j'ai ce problème car je ne comprends pas vraiment la cause merci

EDIT : Quand j'enlève le "static" dans mon header je n'ai plus mon problème mais je ne pense pas que ce soit une solution car j'ai besoin que la méthode calculmoyen soit "static" du coup je sais d'ou provient mon erreur maintenant est-ce que quelqu'un a une méthode ou une piste pour régler ce problème ?

Montre nous ou est appelé calculMoyen. La solution serait de passer en paramètre d'une façon ou d'une autre ta fameuse pente lors de l'appel de calculMoyen c'est plutôt des notions de base. Tu donnes l'impression de ne pas maitriser du tout ton programme.

La methode calcul moyen est détaillé ci-dessus, j'aimerai intégrer "pente" à cette méthode , la méthode est appelé dans beaucoup d'endroits du programme (trop pour les mentionner ici) est-ce un problème ? En effet je ne maitrise pas ce code car je n'en suis pas l'auteur, c'est un code que je dois modifier qui a été réalisé par une autre personne. En effet mon problème est basique, je suis un débutant.

Il n'y a pas de solution direct pour regler le problème de melange "static" "non static" ? En passant "pente" "static" après que l'utilisateur est entré la valeur par exemple ?

Quand j'enleve le "static" ce qui est ci-dessous fonctionne :

.h

Code:

---

bool calculmoyen(....);

---

.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

bool Calcul::calculmoyen(const DgmOctree::octreeCell& cell, void** additionalParameters, NormalizedProgress* nProgress/*=0*/) {   .... if (counter != 0) { gN = static_cast<ScalarType>(atan(sum.norm() / counter) * 180 / 3.14);   if (gN < dialog->getPente()) { gN = 0; } }   } }   ... }

---

Cependant "calculmoyen" est appelé a un autre endroit qui me crée une erreur lorsque j'enleve le "static" qui doit etre nécessaire je ne saurai dire pourquoi en tant que débutant et n'etant pas l'auteur du code :

Code:

---

1 2 3 4 5

int calcul::calculsomme(....) { ... if(theOctree->executeFunctionCell(octreeLevel,calculmoyen,additionalParameters,true...)

---

Ici j'ai une erreur car calculmoyen est incompatible avec un des paramètres

Si quelqu'un saurait m'expliquer rapidement la nature du problème je pourrai essayer ensuite de chercher la solution

Si CalculMoyen est appelé de nombreuse fois et vu que c'est une méthode statique (donc en gros une fonction rangée dans une classe)
La solution la plus simple (mais dégeulasse) serait la suivante:

Dans qPrincipal .h :
tu ajoutes comme donnée publique

Code:

---

static int pente;

---

Dans qPrincipal.cpp:

Code:

---

int qPrincipal::pente;

---

dans qPrincipal::itemChanged()

Code:

---

pente = getPente();

---

et dans calculMoyen()
tu utilises dans ton calcul

Code:

---

qPrincipal::pente

---

C'est pas une solution terrible mais si le but est juste de faire que ça marche...
ça revient au même que de faire une variable gobale elle est juste rangée dans la classe qPrincipal histoire de dire que c'est moins grave.
Ceci suppose que tu n'as qu'une instance de qPrincipale pour toute ton appli (comprendre une seule pente). (Sinon cette solution n'est pas utilisable)

Cela fonctionne ! Merci !!!! Si je souhaite utiliser cette "technique" pour recupérer la valeur dans un autre projet (dll) est-ce possible ? Mon projet de base est aussi en dll

J'ai essayé avec dllexport ca m'a l'air compliqué

Donc avant de me lancer des choses interminables

Est ce qu'on peut utiliser une méthode contenant un attribut (ici pente) dans une autre dll en exportant juste la méthode ? (Cela m'etonnerait mais on ne sait jamais)

Je ne connais pas trop le dev windows mais je pense qu'il faut que tu importe la DLL dans ton autre projet pour que l'édition des liens se fasse correctement.
Il y a peut être d'autre chose à faire quelqu'un pourra mieux te renseigner que moi sinon sur internet on trouve des explications à ce sujet plus ou moins facilement (en anglais du moins)

Autrement tu pourrais améliorer le code que je t'ai donné précedemment en passant l'attribut static pente en privé mais en définissant une fonction publique pour y accéder.