Discussion :

[deubelte]

Bonjour,

Dans le livre de Scott Meyers à l'item 26, on a le code suivant:

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
 
class B;//forward déclaration for class B
class A{
private:
	int o;
public:
 
	A(const B& X); //an A can be constructed from a B
};
 
class B{  
private:
		int o;
public:
	 operator A() const;//a B can be converted to an A
};

On voit que le constructeur par copie de A permet de construire un objet A a partir d'un objet B. Alors j'ai voulu définir ce constructeur de A
comme ceci:

Code :

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

 A(const B&X):o(X.o)

mais bien sur, o étant privé, on ne peut pas accéder aux données membres de B dans une fonction de la classe A.

Je ne veux pas faire de classe dérivée, et déclarer les membres de B comme protected (ou l'inverse).

Alors y a t il un moyen pour acceder à l'élément o de l'objet-argument autrement que par un accesseur déclaré comme ceci dans la classe A:

Code :

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

friend int getteur (const B& );

et défini comme ceci dans la classe B:

Code :

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

int getteur(const B& X){return X.o;};

Merci

[white_tentacle]

Pourquoi ne pas déclarer A en friend de B directement ?

Avec ton friend getter, tu exposes ta propriété à tout le monde (pas seulement A) --> autant mettre directement le getter public dans la classe.

[deubelte]

En fait, j'ai fait ca: J'ai déclaré friend à l'intérieur de la classe A.
Ce code compile:

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
class B;//forward déclaration for class B
 
class B{  
 
private:
		int o;
public:
	B(int x):o(x){};
	int getteur()const {return o;} ;
	 //operator A() const;//a B can be converted to an A
};
 
class A{
	friend class B; 	
private:
	int o;
public:
 	A();
	  friend int getteur( ) ;
	A(const B& X) {
		int o=X.getteur();
	}
	 //A(const B&);  
	  //an A can be constructed from a B
};

Alors que si j'inverse les deux classes, j'ai comme erreur:
error C2027: use of undefined type 'B'
alors que j'ai bien déclaré la classe B tout au début, avant la définition de la classe A. :???

[koala01]

Salut,

Une petite remarque de sémantique...

Ici, tu ne définis pas un constructeur par copie, mais bien un constructeur... prenant une référence constante sur un objet de type B.

La diffrérence tient, simplement, au fait que tu... ne crée pas une copie de ton objet A, vu qu'à la base, tu as un objet B

Autrement, la solution passe sans doute effectivement par l'amitié, ainsi que l'a fait valoir white_tentacle

[deubelte]

Autrement, la solution passe sans doute effectivement par l'amitié, ainsi que l'a fait valoir white_tentacle

J'ai essayé une seconde fois, en utilisant l'amitié comme conseillé, cela marche effectivement.
Je suis d'accord, il ne s'agitpas de constructeur par copie.
En revanche, s'agit t il d'une référence sur une constante, ou d'une référence constante?

[koala01]

J'ai essayé une seconde fois, en utilisant l'amitié comme conseillé, cela marche effectivement.
Je suis d'accord, il ne s'agitpas de constructeur par copie.
En revanche, s'agit t il d'une référence sur une constante, ou d'une référence constante?

Bien qu'il s'agisse en réalité d'un abus de langage, cela revient strictement au même...

Certains pinaillent sur le fait qu'une fois qu'une référence est définie, elle ne peut plus représenter un autre objet que celui référencé pour dire qu'une référence est d'office constante, et préfèrent donc parler de "référence sur un objet constant".

D'un autre coté, on peut faire valoir que ce n'est pas forcément parce qu'un

Code :

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

const Type & ref=var;

fait que ref considère l'objet référencé (ici var) comme constant que l'objet est effectivement constant (il pourrait très bien avoir été déclaré comme... Type var )

Ce qui est sur, quel que soit la manière dont on présente les choses, c'est que les deux termes signifient que l'on s'engage à ne pas modifier l'objet au travers de la référence

[metagoto]

En revanche, s'agit t il d'une référence sur une constante, ou d'une référence constante?

Le truc c'est de lire de la droite vers la gauche. Ca donne:

Code :

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

const B& X

--> X est une référence sur un B constant

Ce qui est la meme chose que:

Code :

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

B const& X

--> X est une référence sur un constant B

Code :

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

B& X

--> X est une référence sur un B

Je te laisse deviner ce que ça donne avec des pointers qui ont un degré de constness en plus par rapport aux références (&const est implicite) :

Code :

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

1
2
3
4
5
6
B const* X
const B* X
B* const X
const B* const X
B const * const X
const B const * const X // bonus