Discussion :

[Lawyer666]

Bonjour à tous,

J'ai le code suivant avec une classe Daughter qui dérive d'une classe Mother, et une fonction qui prend comme argument une référence de pointeur de Daughter. La fonction doit en effet changer l'adresse de l'objet Daughter passé en paramètre en fournissant une adresse de Daughter récupérée depuis un pool de Daughter:

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
class Mother
{
public:
	Mother() {attrMother = 0;}
private:
	int attrMother;
};
 
class Daughter : public Mother
{
public:
	Daughter() {attrDaughter = 1;}
private:
	int attrDaughter;
};
 
void refpointerfunction(Daughter*& param)
{
}
 
int main()
{
	Mother* objM;
	refpointerfunction((Daughter*)objM); //error C2664: 'refpointerfunction'*: impossible de convertir le paramètre 1 de 'Daughter *' en 'Daughter *&'
	refpointerfunction((Daughter*&)objM); //ça passe
}

Vous allez surement me dire que mon code n'est propre, mais d'une part je dois utiliser un objet de type Mother pour une question de généricité du code, et d'autre part la fonction refpointerfunction() ne peut pas prendre un objet de type Mother* en paramètre ce qui serait l'idéal bien sur.
Et je suis assuré que le type réel de objM est bien Daughter*, voilà pourquoi il n'y a pas de risque.

Le truc que je comprends pas, c'est pourquoi le 1er appel me sort une erreur de compil. Quand j'ai une fonction qui prend en paramètre un int&, je lui passe un int et il n'y a aucun problème.
Mais la je suis obligé de caster en référence de pointeur de Daughter, la cast en pointeur de Daughter ne suffit pas.

Si vous pouviez éclairer ma lanterne, merci par avance.

[Invité]

Si je ne me trompe pas, une code comme celui-ci ne fonctionne pas non plus pour la même raison:

Code :

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

1
2
3
4
5
6
7
8
9
 
void foo(int&)
{
}
 
int main()
{
   foo(1);
}

On ne peut pas assigner une objet temporaire à une reférence non-constante(et le résultat d'un cast est un objet temporaire). D'ailleurs à propos de cast il vaudrait sans doute mieux utiliser un cast C++ien, non?

EDIT: Pour modifier le pointeur objM, il faut passer par un pointeur de Daughter auquel on affecte objM(uniquement si la fonction refpointerfunction en a besoin, bien sûr!), que l'on passe comme paramètre à la fonction, puis qui est affecté à objM.

[Lawyer666]

Effectivement ton code ne va pas fonctionner, mais ce n'est pas pour la même raison si je ne m'abuse. Le "1" que tu passes en paramètre va faire que la fonction va créer temporairement une variable sur la pile dont la durée de vie sera celle de la fonction, ce qui est incompatible avec le passage par référence effectivement.

Dans mon cas je passe un pointeur que j'ai déclaré avant l'appel de la fonction qui existe donc avant et qui existera après l'appel de la fonction, donc pas de problème de ce côté là.

Oui c'est vrai pour la cast, je devrais utiliser le static_cast, plus propre. Mais la le but n'est pas forcément d'avoir un code propre (je sais c'est mal), mais vraiment de comprendre l'erreur de compil.

Mon pointeur objM est bien modifié par le second appel qui compile lui, donc je n'ai pas de problème de ce coté là.
J'aimerais vraiment comprendre pourquoi le 1er appel ne compile pas.

Merci en tout cas.

[3DArchi]

Salut,
Pour l'explication, revenons à la source (c'est moi qui souligne ):

The result of the expression (T) cast-expression is of type T. The result is an lvalue if T is a reference type, otherwise the result is an rvalue.

If T is a pointer type, v shall be an rvalue of a pointer to complete class type, and the result is an rvalue of type T. If T is a reference type, v shall be an lvalue of a complete class type, and the result is an lvalue of the type referred to by T.

The result of the expression static_cast<T>(v) is the result of converting the expression v to type T. If T is a reference type, the result is an lvalue; otherwise, the result is an rvalue.

Moi, je m'y prendrais comme ça pour éviter toutes subtilités et ambigüités :

Code :

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

1
2
3
4
5
 
	Mother* objM;
        Daughter*objD = dynamic_cast<Daughter*>(objM);
	refpointerfunction(objD);
        ObjM = ObjD;

Bon, je me dois quand même de parler :
-> du fait qu'un downcast est souvent révélateur de problème de design ;
-> et que des pointeurs nus, c'est dangereux pour la santé.

[Lawyer666]

Ouccchh j'avais complétement oublié ce sujet .

Merci beaucoup pour la réponse. En fait si je comprends bien, une fonction qui prend une référence comme argument attend une lvalue, et les opérateurs de cast renvoient des ravlue ?

Je le mets en résolu du coup. Encore merci.