Discussion :

[krodelahaye]

Bonjour tous,
j'ai une question sur la déclaration de classes et leur utilisation (à appliquer à un servomoteur).

J'aurais ces 2 classes

Classe TypeRotation
int Vitesse
int NbDegres
int TempsArret
bool SensHoraire


Classe TypeBrassage
int NbAllerRetour
TypeRotation Aller
TypeRotation Retour


Sachant que je voudrais utiliser des variables de TypeRotation et TypeBrassage, comment je construis le plus proprement possible le TypeBrassage qui a 2 TypeRotation différents ?

[koala01]

Salut,

Tout simplement: comme tu l'as fait

Tu as un fichier d'en-tête TypeRotation.hpp (Rotation.hpp ? ) qui ressemble à

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef TYPEROTATION_HPP
#define TYPEROTATION_HPP
/* j'utilise une structure, car, pour l'instant, je ne vois pas ce que cela 
 * changerait d'en faire une classe
 */
struct TypeRotation{   // struct Rotation ?
    int vitesse;      // int speed ?
    int nbDegres; // int degrees ?
    int tempArret; // int stopTime ?
    bool sensHoraire; // bool rightToLeft ?
};
#endif //TYPEROTATION_HPP

et un fichier d'en-tête TypeBrassage.hpp qui ressemble à

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef TYPEBRASSAGE_HPP
#define TYPEBRASSAGE_HPP
#include <TypeRotation.hpp>
/* Même remarque que pour TypeRotation ;) */
struct TypeBrassage { // Brewing ?
/* Dans l'idéal, on place les données les plus grandes en haut des structures
 * (pour une sordide histoire d'alignement, quand cela fait sens ;) )
 */
   TypeRotation aller; // Rotation forth ?
   TypeRotation retour; // Rotation back ?
   int nbAllerRetour;   // int routes ?
};
#endif // TYPEBRASSAGE_HPP

(il est souvent pas mal d'écrire son code en anglais, bien que tu aies évité de tomber dans l'utilisation d'une moitié de termes en anglais et de l'autre moitié en francais ... les commentaires proposent des noms dans la lange de shakespeare )

De cette manière, en fonction des besoins, tu pourras soit inclure "uniquement" TypeRotation.hpp, si tu n'a vraiment besoin de connaitre que la rotation, ou bien, tu pourras décider d'inclure TypeBrassage.hpp si tu as besoin de connaitre les deux types (la rotation et le brassage)

L'idée étant toujours de n'inclure que ce qui est strictement indispensable, ni plus (parce que cela ne fait que donner du taf inutile au compilateur) ni moins (parce que, de toutes façons, cela le fera râler)

[krodelahaye]

Merci de ta réponse, elle me plaît car bien structurée et expliquée
J'arrive de l'univers du VisualBasic donc je ne connais pas les " struct "
J'étudie ça reviendrai avec du code plus précis que j'insérerai comme toi (comment on fait ça ?)

[krodelahaye]

Je viens de lire sur les Structures en C++

Ça me semble la bonne solution car tout est public dans la structure Rotation et Brassage.

Comme c'est un tout petit programme, tout serait mis dans le même fichier.

Pour l'anglais, ça me parait naturellement plus proprre en effet mais je veux que ce soit facilement compréhensible par un public large.

Une question que je n'ai pas trouvé dans ma recherche pour les classes ou structures, comment accède-t'on aux données de rotation d'un brassage ?

If Brassage.Aller.Vitesse>10
Ou

Je dois sortir la structure Rotation dans une variable avant ?

Merci de ta réponse

(je te conseille de regarder la vidéo
"Uncle Bob Clean Code"
qui décrit comment et pourquoi écrire du ccode proprement
Tu pourras continuer plus ta démarche de bon code qui semble très bien parti !!!)

[krodelahaye]

Rebonjour,
je reste sur la définition de classes car je pense qu'il y aura des méthodes associées à chacune des classes

Pas contre, je ne comprends toujours pas comment instancier et bien déclarer ces imbrications de classes

voici ci-dessous mon code

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
60
61
62
63
64
65
66
67
68
 
 
class TypeRotation
{
    public:
        int NbDegres;
        int Vitesse;
        int TempsArret;
        int Sens;
        TypeRotation(int  intDegres,
                     int  intVitesse,
                     int  intTempsArret);
};
 
 
 
 
 
TypeRotation::TypeRotation(int  intNbDegres,
                                      int  intVitesse,
                                      int  intTempsArret)
{
    NbDegres=intNbDegres; 
    Vitesse=intVitesse; 
    TempsArret=intTempsArret; 
};
 
 
 
 
 
class TypeBrassage
{
    public: 
        TypeRotation RotationAller;
        TypeRotation RotationRetour;
        int          NbAllerRetour;
        TypeBrassage(int  intNbAllerRetour,
                     TypeRotation trAller,
                     TypeRotation trRetour);
};
 
 
 
 
 
TypeBrassage::TypeBrassage(int intNbAllerRetour,
                                       TypeRotation trAller,
                                       TypeRotation trRetour)
{
    NbAllerRetour=intNbAllerRetour;
    RotationAller=Aller; 
    RotationRetour=Retour;        
};
 
 
 
 
 
void loop()
{
    TypeRotation  RotationCourte(158,3,2);
    TypeRotation  RotationLongue(158,3,2);
    TypeBrassage  BrassageAmple(2,RotationLongue,RotationLongue);
    TypeBrassage  BrassageSerre(3,RotationCourte,RotationCourte);
 
    exit(0);
};

[Bousk]

Tes classes ne sont pas du tout imbriquées.
Tu as 2 classes, c'est tout, et une utilise l'autre.
Et vu que les variables sont de simples variables (et pas pointeur ou référence), il faut que son type soit totalement connu avant de l'utiliser.
Donc Rotation doit être déclarée avant Brassage.
La bonne pratique est généralement de mettre chaque classe dans un fichier différent, puis tu inclues ce dont tu as besoin, quand tu en as besoin.
As-tu lu un cours de C++ ? Ça me semble assez basique, t'as dû rater une étape.

[krodelahaye]

J'arrive de l'univers Visual Basic et pratiquement rien de C++.
Et là, je pars que de ces notions pour programmer un petit actionneur couplé à un servomoteur dans l'IDE Arduino

Je souhaite que tout tienne dans un seul fichier c'est pourquoi j'avais déclaré la classe TypeRotation et son constructeur- avant- le TypeBrassage et son constructeur.

A priori en C++ ça n'a pas l'air suffisant ou y a t'il moyen de le faire ?

[Bousk]

Si c'est possible, et ça va marcher, c'est juste que tu vas finir rapidement avec un fichier lourd et difficilement lisible.
Quitte à ne pas vouloir faire de fichier supplémentaire, tu peux directement implémenter les fonctions avec leur déclaration dans la classe. Ça rendra le tout un peu moins gros imo.

[krodelahaye]

Je viens d'enlever des " ;" qui ne devaient pas être à la fin des procédures de constructions

Et je crois que pour construire la classe TypeBrassage, il y a une synthaxe spéciale pour construire en meme temps les 2 variables de TypeRotation

Il n'y aurait pas ":TypeRotation" après TypeBrassage::TypeBrassage?

[dalfab]

A priori en C++ ça n'a pas l'air suffisant ou y a t'il moyen de le faire ?

Ton constructeur de TypeBrassage oblige 3 paramètres, donc tes 2 membres doivent avoir ces données dès leur construction

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
class TypeBrassage
{   public: 
        TypeRotation RotationAller;
        TypeRotation RotationRetour;
        int          NbAllerRetour;
        TypeBrassage(int  intNbAllerRetour,
                     TypeRotation const& trAller,
                     TypeRotation const& trRetour);
};
TypeBrassage::TypeBrassage(int intNbAllerRetour,
                          TypeRotation const& trAller,
                          TypeRotation const& trRetour)
    : RotationAller(trAller)  // doit être construit avant le corps du constructeur
    , RotationRetour(trRetour)
    , NbAllerRetour(intNbAllerRetour)
{ 
}

[Bousk]

C'est la liste d'initialisation https://cpp.developpez.com/faq/cpp/?...-l-affectation

[krodelahaye]

Bon, ça compile mais je n'ai pas encore retester sur l'actionneur

Voici le code complet, j'ajouterai les "const" partout où les variables seront en lecture seule


Je pense peut-être créer les méthode Brasser et Tourner dans les classe TypeBrassage et TypeRotation
Brasser deviendrait Actionner pour TypeBrassage.Actionner
Tourner aussi Actionner pour TypeRotation.Actionner

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#include <Servo.h>
using namespace std;
 
 
const int TEMPS_MINIMUM=400;
Servo     srvPanier;
 
 
 
 
 
class TypeRotation
{
    public:
        int NbDegres;
        int Vitesse;
        int TempsArret;
        int Sens;
        TypeRotation(int  intDegres,
                     int  intVitesse,
                     int  intTempsArret);
};
 
 
 
 
 
TypeRotation::TypeRotation(int  intNbDegres,
                           int  intVitesse,
                           int  intTempsArret)
{
    NbDegres=intNbDegres; 
    Vitesse=intVitesse; 
    TempsArret=intTempsArret; 
}
 
 
 
 
 
class TypeBrassage
{
    public: 
        TypeRotation RotationAller;
        TypeRotation RotationRetour;
        int          NbAllerRetour;
        TypeBrassage(int          intNbAllerRetour,
                     TypeRotation Aller,
                     TypeRotation Retour);
};
 
 
 
 
 
 
TypeBrassage::TypeBrassage(int          intNbAllerRetour,
                           TypeRotation Aller,
                           TypeRotation Retour): RotationAller(Aller), 
                                                 RotationRetour(Retour)
{
    NbAllerRetour=intNbAllerRetour;
    RotationAller=Aller; 
    RotationRetour=Retour;        
}
 
 
 
 
 
void Attendre(int intTemps)
{
    delay(intTemps);
}
 
 
 
 
 
void Attacher(Servo srvMoteur,
              int   intPin)
{
    srvMoteur.attach(intPin);
}
 
 
 
 
 
void Detacher(Servo srvMoteur)
{
    srvMoteur.detach();
}
 
 
 
 
 
int Position(Servo srvMoteur)
{
    return(srvMoteur.read());
}
 
 
 
 
 
void Positionner(Servo srvMoteur,
                 int   intPosition,
                 int   intTempsAttente)
{
    srvMoteur.write(intPosition);
    Attendre(intTempsAttente);
}
 
 
 
 
 
 
void Initialiser(Servo srvMoteur)
{
    Positionner(srvMoteur,0,TEMPS_MINIMUM);
}
 
 
 
 
 
void Tourner(Servo        srvMoteur,
             TypeRotation Rotation)
{ 
    int intPositionDepart=Position(srvMoteur);
 
    for (int intCompteur=1;
         intCompteur<=Rotation.NbDegres;
         intCompteur++)
    {     
        Positionner(srvMoteur,intPositionDepart+(Rotation.Sens*intCompteur),Rotation.Vitesse);  
    }   
};
 
 
 
 
 
void Brasser(Servo        srvMoteur,
             TypeBrassage Brassage)
{
    for (int intCompteur=1;
         intCompteur<=Brassage.NbAllerRetour;
         intCompteur++)
    {      
        Tourner(srvMoteur,Brassage.RotationAller);
        Tourner(srvMoteur,Brassage.RotationRetour);
    }
};
 
 
 
 
 
void setup()
{
}
 
 
 
 
 
void loop()
{
    TypeRotation  RotationCourte(158,3,2);
    TypeRotation  RotationLongue(158,3,2);
    TypeBrassage  BrassageAmple(2,RotationLongue,RotationLongue);
    TypeBrassage  BrassageSerre(3,RotationCourte,RotationCourte);
 
    Attacher(srvPanier,8);
        Initialiser(srvPanier);
        Attendre(3000);
        Brasser(srvPanier,BrassageAmple);
        Attendre(3000); 
        Positionner(srvPanier,120,0);  
        Attendre(3000);
        Brasser(srvPanier,BrassageSerre);
    Detacher(srvPanier);
 
    exit(0);
}