Fonction amie étant méthode d'une autre classe
Bonjour,
Je suis en train d'écrire un petit programme pour entretenir le peu de niveau que j'ai en C++ et je suis bloqué.
Avant d'expliquer, voici les fichiers que j'ai (.h et .cpp) :
Interface.h :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#ifndef DEF_INTERFACE
#define DEF_INTERFACE
#include "Piece.h"
class Interface{
public:
void grosseMethode();
private:
int trouverLigneAtterissage() const;
Piece* p_;
};
#endif |
Interface.cpp :
Code:
1
2
3
4
5
6
7
8
9
10
11
| #include "Interface.h"
void Interface::grosseMethode() {
// ...
// Fonction à ajouter
}
int Interface::trouverLigneAtterissage() const{
// Calculs
return ligneAtterissage;
} |
Piece.h :
Code:
1
2
3
4
5
6
7
8
9
| #ifndef DEF_PIECE
#define DEF_PIECE
class Piece{
protected:
int ligneOrigine_;
};
#endif |
Ce que je cherche à faire, c'est créer une méthode setAltitudeFinale que j’appelerai dans grosseMethode(), qui utilise trouverLigneAtterissage() et qui modifie ligneOrigine_ MAIS je voudrais éviter de créer une méthode publique setLigneOrigine() dans la classe pièce car je veux que seule cette méthode setAltitudeFinale puisse toucher à l'attribut ligneOrigine_ à l'extérieur de la classe Piece.
J'ai donc pensé à utiliser les friend :
J'ai ajouté la méthode void setAltitudeFinale(Piece* p); dans la classe Interface et je l'ai déclaré comme amie dans la classe Piece :
Interface.h :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| #ifndef DEF_INTERFACE
#define DEF_INTERFACE
#include "Piece.h"
class Interface{
public:
void grosseMethode();
private:
int trouverLigneAtterissage() const;
void setAltitudeFinale(Piece* p);
Piece* p_;
};
#endif |
Interface.cpp :
Code:
1
2
3
4
5
6
7
8
9
10
11
| #include "Interface.h"
void Interface::grosseMethode() {
// ...
setAltitudeFinale(p_);
}
int Interface::trouverLigneAtterissage() const{
// Calculs
return ligneAtterissage;
} |
Piece.h :
Code:
1
2
3
4
5
6
7
8
9
10
| #ifndef DEF_PIECE
#define DEF_PIECE
class Piece{
protected:
friend void Interface::setAltitudeFinale(Piece* p);
int ligneOrigine_;
};
#endif |
Alors déjà première question, mais je ne sais pas si je dois faire l'implémentation de la méthode setAltitudeFinale dans Interface.cpp ou dans Piece.cpp, j'aurais tendance à la faire dans Interface mais je suis pas sûr à 100% donc si vous pouviez me le confirmer ça serait génial ! Dans tous les cas, l'implémentation donne :
Code:
1
2
3
4
| void Interface::setAltitudeFinale(Piece* p) {
int ligneAtterissage = trouverLigneAtterissage();
p->ligneOrigine_ = ligneAtterissage;
} |
Quand j'essaie de faire ça, si je mets l'implémentation dans Interface.cpp, Visual Studio me souligne ligneOrigine_ et me dit que ce membre est inaccessible.
Si je déplace l'implémentation dans Piece.cpp, il ne reconnait pas la classe Interface (et il m'empêche d'utiliser ligneOrigine_ et trouverLigneAtterissage). Quand j'ajoute #include "Interface.h" dans Piece.h, Visual Studio ne me souligne plus rien mais quand je compile, j'ai plein d'erreurs qui viennent (selon moi) du fait que Piece.h inclus Interface.h et que Interface.h inclus Piece.h.
J'avais pensé à faire l'inverse, à créer la méthode setAltitudeFinale() dans la classe Piece mais vu que cette méthode ne prendrait pas d'Interface en paramètre, je voyais pas comment appeler trouverLigneAtterissage().
J'espère que j'ai été assez clair sur ce que j'ai envie de faire. Si vous pouvez m'aider ça serait vraiment super, j'espère au moins que ce que j'essaie de faire est possible.
Si jamais vous voyez une meilleure façon de le faire (c'est à dire appeler une fonction/méthode dans grosseMethode() qui peut appeler trouverLigneAtterissage() et modifier ligneOrigine_), ou une autre façon de voir les choses au niveau conceptuel, je suis preneur !
Merci d'avance !
