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:

Classe A

{

objetA->variable1

}

J'aimerai dans le fichier B:

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écéssaires

Merci

EDIT : INFOS SUPP.

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

class A : public QObject
Q_OBJECT

public :

explicit A(QObject* parent=0);

...

protected:

Class C *objet;

Fichier A.cpp

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

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

Merci

-
Edité par Lkr22 14 mai 2019 à 11:47:00

Bonjour,

Il y a des choses à clarifier:
Quand tu écris : objet-> variable %%"Variable" correspond à une valeur entrée par l'utilisateur. En aucun cas l'utilisateur ne peut agir sur une expression objet->nomDunMembreDuTypeA, (les noms objet et nomDunMembreDuTypeA sont des données du code qui n'existent plus après compilation) il pourra par contre fournir une valeur qui sera stockée dans objet->nomDunMembreDuTypeA.

Quand tu écris : z=variable + x ; %% Exemple simplifié mais variable appartient à la classe A et x a la classe C en gros. Une variable n'appartient pas à une classe, elle appartient à un objet a qui serait du type class A. Pour x, on peut l'utiliser car ici la valeur sous entendue est x le champ de l'objet courant du type courant. On peut écrire :

void C::fctMembre() {
   z = adrDUnObjetDeTypeA->nomDunMembreDuTypeA + this->x;
}

adrDUnObjetDeTypeA doit avoir préalablement mis à jour à partir un d'un objet de type A qui existe quelque part.
this-> est facultatif, on ne l'écris jamais, il rappelle que l'on utilise un membre de l'objet courant (si on appelé totor.fctMembre(), on accède ici au x de totor.)

Peux-tu clarifier s'il te plait

Merci pour ta reponse, je comprends déjà quelques mauvaises expressions de ma part

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

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

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

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

   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

  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

    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

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é de simplifier au mieux le code et mettre les parties qui nous interessent, je suis un debutant, si jamais j'ai oublié certaines choses importante à mentionner vous pouvez me le signaler

Tu souhaites accéder à la fonction getPente() pour un objet qui serait de la classe ccPrincipal à partir d'une méthode membre de la classe Calcul. J'avais indiqué qu'un membre n'a de sens que pour un objet donné, ici l'objet serait le dialog de type ccPrincipal, qui est un membre d'un objet de type qPrincipal, c'est une notion qu'il est primordial de comprendre.

A. Il faut ici trouver un pointeur sur l'objet de type ccPrincipal et s'en servir en écrivant alors if ( gn < ptrSurObjetPrincipal->getPente() ).

B. Le fichier calcul.cpp doit connaître le type qui contient la valeur à récupérer, ça serait un #include ccPrincipal.h, (ou peut-être plutôt un #include qPrincipal.h on verra plus loin) au début.

C. Reste à trouver cet objet qui serait peut-être du type ccPrincipal , je suppose vu le nom qu'il n'y en a qu'un. C'est l'adresse de cette variable dialog qui va devoir être transmise aux objets de type Calcul. Pour cela on pourrait supposer que le constructeur de Calcul reçoive cette adresse et la mémorise dans un de ses champs qui serait défini ainsi :

class ccPrincipal* ptrSurObjetPrincipal;

D. Mais ton ccPrincipal décrit un type de dialogue. dialogue qui serait peut-être terminé au moment où l'objet de type Calcul est utilisé, il est trop tard le membre que tu convoites n'existe plus! Il faut donc tout repenser si on est dans ce cas!

E. Il faut mettre la donnée pente au bon endroit. C'est au dialogue de transmettre au moment de sa fermeture les données qu'il a permis de mettre à jour. De manière symétrique un objet de type qPrincipal à transmis la pente par l'utilisation de dialog->pente->setValue(pentee); l'objet dialogue connaît son père, il peut lui transmettre la pente. Tu peux aussi utiliser la méthode itemchanged() qui s'est enregistrée pour savoir que la valeur de pente a changée. Dans cette fonction il suffit de demander la pente et de la mémoriser.

      membre_pente = dialog->getPente();   // qPrincipal récupère dans un de ses membres la valeur de la pente.

F. Cette fois la pente serait alors dans un objet de type qPrincipal qui lui existerait encore au moment de l'utilisation de Calcul. Il reste toujours à l'objet de type Calcul de retrouver l'objet de type qPrincipal pour pouvoir lui demander cette pente. (on reprend les commentaire A. B. et C. en considérant cette fois que l'on accède à un objet du type qPrincipal au lieu du type ccPrincipal.)

Je n'ai certainement pas été assez clair, n'hésite pas à demander des précisions.