Discussion :

[kochfet]

Bonjour,

svp,aidez moi.

J'ai les fichiers C1.h, C2.h , C3.h , C1.cpp, C2.cpp , C3.cpp et main.cpp. Je veux déclarer une variable globale varGlo de type int que je veux l'utiliser dans C1, C2 et C3.
Ou je dois la déclarer?

Merci d'avance.

[koala01]

Salut,

La première chose à te dire, c'est LES VARIABLES GLOBALES, C'EST MAL.

Autrement dit, si tu peux t'en passer, passes t'en .

Pourrais tu déjà nous expliquer pourquoi tu crois avoir besoin d'une variable globale, histoire que nous puissions t'expliquer comment t'en passer

S'il s'avère qu'il est effectivement impossible de t'en passer, je me ferai un plaisir de répondre à ta question, car la réponse est particulièrement triviale

[kochfet]

En fait, cette variable globale va être appeler dans C1.cpp, C2.cpp et C3.cpp. Plusieurs méthodes dans ces classes l'utilisent. Je vais l'initialiser avec une valeur que ne va pas dans mon code.

[koala01]

En fait, cette variable globale va être appeler dans C1.cpp, C2.cpp et C3.cpp. Plusieurs méthodes dans ces classes l'utilisent.

Ca, je m'en serais quand même douté La question que je te pose, c'est "pourquoi voudrais tu que ce soit une variable globale "

As tu conscience que ta variable globale risque d'être modifiée par chacune de tes classes et fonctions Te rend tu comptes que, selon ton flux d'exécution, tu ne pourras plus faire la moindre assertion en ce qui concerne cette variable globale parce que la reproductibilité du comportement ne pourra plus être assurée Et je ne parle même pas des problèmes inhérents aux tentatives d'utilisation dans un contexte multithread

Je reprends donc ma question : dis moi ce que tu veux faire de cette variable globale, mais un peu plus clairement que "Plusieurs méthodes dans ces classes l'utilisent." pour que je puisse t'expliquer comment t'en passer

[kochfet]

pourquoi voudrais tu que ce soit une variable globale

Puisque je vais utiliser sa valeur dans plusieurs classes, j'aime pas qu'à chaque fois je veux la déclarer. Aussi, a chaque exécution de mon code, je veux tester ce dernier avec une valeur différente de cette variable. Donc, je ne veux pas changer sa valeur dans toutes les classes à chaque exécution.

[koala01]

Puisque je vais utiliser sa valeur dans plusieurs classes, j'aime pas qu'à chaque fois je veux la déclarer.

Tu as bien tord conceptuellement parlant : s'il n'y a aucune raison pour que la valeur de ta variable dans une fonction de A soit identique à celle de la variable dans une fonction de B, il n'y a aucune raison de faire en sorte que A et B partagent la même valeur

Aussi, a chaque exécution de mon code, je veux tester ce dernier avec une valeur différente de cette variable. Donc, je ne veux pas changer sa valeur dans toutes les classes à chaque exécution.

As tu déjà entendu parler des constructeurs Si tu veux définir une valeur spécifique pour une variable qui est utilisée par A et que cette même valeur doit être utilisée (mais pas partagée) par B, c'est très certainement la solution idéale. Tu pourras même en arriver à définir cette variable sur base d'une entrée de la part de l'utilisateur

Que penserais tu d'un code (fais un copier / coller et compile le, il fonctionnera ) proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>
class A{
    public:
        A(int i): i_(i){}
        void print() const{std::cout<<i_<<std::endl;}
    private:
        int i_;
};
class B{
        B(int i): i_(i){}
        void print() const{std::cout<<i_<<std::endl;}
    private:
        int i_;
};
class C{
        C(int i): i_(i){}
        void print() const{std::cout<<i_<<std::endl;}
    private:
        int i_;
};
int main(){
    int value1 = 15;
    int value2 = 20;
    {
        std::cout<<"dans ce groupe, toutes les valeurs sont identiques et sont égale à " value1<<std::endl
        A a(value1);
        B b(value1);
        C c(value1);
        /* création d'un premier groupe de variables */
       std::cout<<"la preuve : "<<std::endl
       a.print();
       b.print();
       c.print();
    }
    {
        std::cout<<"dans ce groupe, toutes les valeurs sont identiques et sont égale à " value2<<std::endl
        A a(value2);
        B b(value2);
        C c(value2);
        /* création d'un premier groupe de variables */
       std::cout<<"la preuve : "<<std::endl
       a.print();
       b.print();
       c.print();
    }
    {
        std::cout<<"et dans ce groupe, A et C ont disposent de la valeur "<<value1
                 <<"alors que B dispose de la valeur "<<value2<<std::endl;
        A a(value1);
        B b(value2);
        C c(value1);
        /* création d'un premier groupe de variables */
       std::cout<<"la preuve : "<<std::endl
       a.print();
       b.print();
       c.print();
    }
    return 0;
}

Comme tu peux le constater, je crois avoir fait exactement ce que tu voulais sans avoir à utiliser de variable globale

[kochfet]

Tout d'abord merci pour votre effort et vos réponses.

Dans votre code proposé, vous avez utilisé des constructeurs paramétrés. Dans mon code, la variable à déclarer n'est pas un paramètre de mes constructeurs. Elle va être utilisée dans le corps de méthodes des classes C1, C2 et C3.

Mon code est semblable à ceci :

C1.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include"C1.h"
 
C1::C1(){}
int C1::fc1()
{
    int c;
    c=varGlo+5;
    return c;
}

C2.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include"C2.h"
 
C2::C2(){}
int C2::fc2()
{
    int c;
    c=varGlo+8;
    return c;
}

C3.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include"C3.h"
 
C3::C3(){}
int C3::fc3()
{
    int c;
    c=varGlo+10;
    return c;
}

Je veux initialiser varGlo à la valeur 10. Elle sera partager par les trois classes avec la même valeur pour chaque exécution.

Dans mon main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
srand (time(NULL));
C1 c;
C2 c;
C3 c;
 
int nb=rand()%3;
if(nb==0)
{
    int v=c1.fc1();
    cout<<v<<endl;
}
else
{
    int v=c2.fc2();
    cout<<v<<endl;
}
else
{
    int v=c3.fc3();
    cout<<v<<endl;
}

[koala01]

Soit, mais pourquoi est ce que varGlo ne pourrait pas être une valeur connue des seules classes qui l'utilisent

Au pire, si cela ne convient décidément pas, parce que tu voudrais pouvoir modifier la valeur de varGlo, transmet la comme paramètre aux fonctions qui l'utilisent
Cela pourrait prendre la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
31
32
33
34
35
class A{
    public:
        int fc1(int neededValue)
       {
            int c;
           c=neededValue+5;
           return c;
       }
};
class B{
        int fc3(int neededValue)
       {
            int c;
           c=neededValue+8;
           return c;
       }
};
class C{
 
       int fc3(int neededValue)
       {
            int c;
           c=neededValue+10;
           return c;
       }
};
int main(){
   A a;
   B b;
   C c;
   int value = 12;
   std::cout<<"A::fc1 :"<<a.fc1(value)<<std::endl;
   std::cout<<"B::fc2 :"<<b.fc2(value)<<std::endl;
   std::cout<<"C::fc3 :"<<c.fc3(value)<<std::endl;
}

Jusqu'à présent, je reste convaincu que tu n'as simplement pas besoin d'une variable globale
[EDIT]A vrai dire, je ne suis même pas convaincu que tu aies besoin de trois classes différentes. Peut être trois fonctions membres différentes dans une seule et même classe (et encore), mais j'ai la furieuse impression que tu cherches midi à quatorze heures dans ton projet.

Pourrais tu donc lire la deuxième ligne de ma signature, prendre le temps de la comprendre et essayer de nous indiquer clairement ce que tu veux faire. Non pas utiliser la variable globale, mais le besoin que tu essayes de remplir au travers de ton projet (donc le bu du projet, si tu préfères). Car, j'ai vraiment l'impression que tout part d'une mauvaise compréhension de tes propres besoins

[Invité]

bonjour,

pourquoi ne pas répondre à la question posée?
L'utilisateur est mis en garde sur le fait que les globales c'est mal.
L'utilisateur est mis en garde sur le fait que son design est probablement mauvais.

Ne serait-ce pas plutot à lui de demander quelles alternatives il a?

[koala01]

bonjour,

pourquoi ne pas répondre à la question posée?
L'utilisateur est mis en garde sur le fait que les globales c'est mal.
L'utilisateur est mis en garde sur le fait que son design est probablement mauvais.

Ne serait-ce pas plutot à lui de demander quelles alternatives il a?

Ne dit-on pas

Donnes un poisson à quelqu'un, il mangera un jour, apprend lui à pêcher... (tu connais la suite, hein

L'aspect "basique" de la question rend une constatation évidente : kochfet débute à peine en programmation et en développement. Il ne faut pas le prendre mal, il n'y a aucun jugement porté à ce sujet, c'est juste une constatation évidente

Et je ne peux m'empêcher de faire le rapprochement avec une autre constatation qui se fait à chaque fois que l'on est face à un débutant : les (mauvaises) habitudes prises lorsque l'on débute sont les plus difficiles à abandonner par la suite.

Je suis donc confronté à un choix :
Soit je lui donnes "bêtement" la réponse, sans m'inquiéter de quoi que ce soit, au risque que kochfet n'ait pas compris pourquoi les variables globales sont le mal incarné, ni quelles autres pistes il aurait pu suivre pour les éviter, soit je lui montre le chemin des pistes explorer pour qu'il puisse s'en passer le plus souvent possible, quitte à décider de les utiliser en "dernier recours".

Dans le premier cas, cela dégénérera forcément en mauvaise habitude dont il aura le plus grand mal à se défaire, dusse-t-elle lui péter régulièrement à la figure.

Dans le deuxième cas, je joue peut être le rôle du type un peu chiant, mais j'aurai au final donné de bons outils à kochfet et je me serai assuré de l'avoir orienté vers de bonnes habitudes.

Je lui demande depuis le début pourquoi il croit avoir besoin des variables globales et les seules réponses qu'il m'ait données à ce sujet ne sont absolument pas convaincantes. Jusqu'à preuve du contraire, il n'a donc purement et simplement pas besoin de variables globales .

Si, en cours de discussion, il finit par me donner une raison convaincante (comprends : qui justifie l'utilisation d'une variable globale par le fait que l'utilisation sera beaucoup plus facile que si l'on s'en passe), je lui donnerai la réponse. Tout comme je finirai malgré tout par lui donner la réponse "pour qu'il la connaisse à l'avenir" une fois qu'il aura compris pourquoi il vaut mieux s'en passer et comment faire pour y arriver.

Mais d'ici là, j’assume entièrement la position que j'ai prise. Et je n'empêche personne de lui indiquer comment faire

[_zzyx_]

Si tu veux utiliser une globale, j'imagine que tu as déjà étudié toute les alternatives, et que tu as pondu un raport de 10 pages montrant que dans ton cas une globale est la moins mauvaise solution.

Si oui, une stratégie pas trop sale serait

* Un fichier d'include Global.h
* Tes globales sont encapsulée dans un namespace donc un truc du genre
* Si possible tes globales sont des constantes (Par exemple définir \pi ou h en constante globale est une solution classique, Sauvegarder le dernier code d'erreur dans une globale est assez moche (et absolument pas thread-safe) mais se voit parfois. Passer des variables d'une classe à l'autre par une globale est très moche.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
namespace myproject { 
  namespace Global {
  const float pi = 3.14159265359; 
  const float hplanck = 6.62606957e-34;
  int param;  
}
}

Ca permet de bien proteger ta variable globale.

Dernière chose, avec les machines multi-core, des libs genre openmp et l'arrivée de std::thread dans c++11. Le multi-threading n'est plus reservé à une élite, mais devient utilisable par tout le monde. Donc penses dès le début à écrire du code thread-safe

[white_tentacle]

À noter que s’il s’agit d’une constante globale (ça n’est pas clair dans ce que j’ai vu), c’est potentiellement tout à fait acceptable (avec les précautions d’usage pour éviter les conflits de nom).