Discussion :

[julieng31]

Bonjour, j'aimerais améliorer la lisibilité d'un de mes codes par d'autres développeurs et je me pose une question sur la visibilité d'une fonction.

Voici un code simplifié :

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
class A {
	A() {}
	B & getB(unsigned int index) {return B[index];}
	void update() {
		// update internal value
		for(B & element:m_data)
			element.updateParam3()*;
	}
private:
	vector<B> m_data;
}
 
class B {
	B() {}
	updateParam1() { // some code }
	updateParam2() { // some code }
	updateParam3() { // some code }
}

Je peux accéder aux éléments B qui sont dans A::m_data avec A::getB(index).updateParamX() pour les paramètres 1 et 2. C'est bien le comportement que j'attends.

Pour B::updataParam3(), j'aimerais interdire l'accès en passant directement par A::getB(index).updateParam3() car je veux garder un état interne dans A suite à la modification de mon paramètre 3. Donc j'aimerais forcer tout développer à appeler A::update() à la place. En d'autres termes, j'aimerais que B::updateParam3() soit privé sauf quand je l'appelle depuis la classe A. Est-ce que ceci est possible ?

Merci d'avance !

[pjlan]

Oui avec l'amitié, regarde le mot clé friend.

[julieng31]

Merci, je découvre ce mot-clé ! J'ai essayé le code suivant mais j'ai une erreur de compil :

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
 
class A {
public:
	A() {}
        friend void B::updateParam3();
	B & getB(unsigned int index) {return B[index];}
	void update() {
		// update internal value
		for(B & element:m_data)
			element.updateParam3()*;
	}
private:
	vector<B> m_data;
}
 
class B {
public:
	B() {}
	void updateParam1() { // some code }
	void updateParam2() { // some code }
private:
	void updateParam3() { // some code }
}

La fonction B::updateParam3() n'est donc plus visible mais le compilateur me dit qu'elle est privée donc non accessible. Je n'ai pas du tout comprendre... Est-ce possible de m'aiguiller un peu plus ? Merci !

[pjlan]

Il y a peut être un problème si A ne connait pas intégralement B. Que te sors le compilateur ?

[pjlan]

A non pardon en fait tu dois déclarer dans B que A::update() est ton amie pas l'inverse.

[julieng31]

Merci, ça progresse ! Quand je fais ça, ça marche :

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
 
class A {
public:
	A() {}
	B & getB(unsigned int index) {return B[index];}
	void update() {
		// update internal value
		for(B & element:m_data)
			element.updateParam3()*;
	}
private:
	vector<B> m_data;
}
 
class A;
class B {
public:
        friend class A;
	B() {}
	void updateParam1() { // some code }
	void updateParam2() { // some code }
private:
	void updateParam3() { // some code }
}

J'ai essayé de réduire un peu l'exposition (une fonction plutôt que la classe) mais dans mon projet, j'ai 2 headers séparés. Et je tombe sur un problème sur les include à mon avis ("unterminated conditional directive"). Comment m'en sortir si les 2 classes doivent se connaître mutuellement ?

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
#ifndef A
#define A
#include "B.h" -> nécessaire pour m_data

class A {
public:
	A() {}
	B & getB(unsigned int index) {return B[index];}
	void update() {
		// update internal value
		for(B & element:m_data)
			element.updateParam3()*;
	}
private:
	vector<B> m_data;
}
#endif

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
 
#ifndef B
#define B
#include "A.h" -> nécessaire pour le friend

class A;
class B {
public:
        friend void A::update();
	B() {}
	void updateParam1() { // some code }
	void updateParam2() { // some code }
private:
	void updateParam3() { // some code }
}

#endif [UPDATE/EDIT]