Discussion :

[méphistopheles]

bonjour.

J'ai défini une petite classe comme suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
class solid_pos: public point
{
    angle<SOLID_ANGLE_PREC> dir;
 
    public:
    solid_pos(const point & pt=point(),angle<SOLID_ANGLE_PREC> agl=angle<SOLID_ANGLE_PREC>());
    solid_pos(const solid_pos & pos);
    inline solid_pos & operator-()const;
 
};

or dans l'implémentation de operator -:

Code :

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

1
2
3
4
inline solid_pos & solid_pos::operator-()const
{
    return solid_pos(point::operator-(),-dir); //plante ici
}

il me fait l'erreur suivante sur le return:

...solid_pos.h|28|erreur: invalid initialization of non-const reference of type ‘solid_pos&’ from a temporary of type ‘solid_pos’|

ce que j'ai du mal à comprendre vu qu'une référence doit forcément s'initialiser à partir d'un objet...

bref, un éclairement serait bienvenu.


merci.

[hiura]

Tu ne peux pas retourner une référence sur un objet qui n'existe plus.

Par contre, tu peux retourner une référence sur un objet constant, car le C++ s'arrange pour ne pas le supprimer tant <wrong>qu'il y a une référence dessus.</wrong> que la référence constante est en vie.

[méphistopheles]

Tu ne peux pas retourner une référence sur un objet qui n'existe plus.

Par contre, tu peux retourner une référence sur un objet constant, car le C++ s'arrange pour ne pas le supprimer tant qu'il y a une référence dessus.

heu, qu'apelle-tu exactement un objet constant ? un objet revoyé avec une fonction const ? si oui, c'est déjà le cas...

[Lucien63]

car le C++ s'arrange pour ne pas le supprimer tant qu'il y a une référence dessus.

Le C++ Aurait-il un ramasse miettes ?

[hiura]

heu, qu'apelle-tu exactement un objet constant ? un objet revoyé avec une fonction const ? si oui, c'est déjà le cas...

Non, mais par une fonction qui retourne un objet const :

Code :

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

const T& f(...);

Le C++ Aurait-il un ramasse miettes ?

J'avais lu le principe du ramasse miettes y a vraiment longtemps, mais d'après ce que je me souviens il ne s'agit pas de ça.
Soit le code :

Code :

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

1
2
3
4
T f(void);
void g(void) {
  const T& = f();
} // T est détruit, l'objet auquel il fait référence aussi.

Le C++ va, dans ce cas particulier, garder en mémoire l'objet const retourné par f en mémoire et le détruire que quand la référence sera détruite.

Lire http://herbsutter.wordpress.com/2008...portant-const/

EDIT : ce code est faux, voir mon prochain message ( bien plus bas ) .

[Lucien63]

Code :

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

1
2
3
4
5
T f(void);

void g(void) {
  const T& = f(); // ou est le type et ou est le nom de la variable ?
} // T est détruit, l'objet auquel il fait référence aussi.

T est un type ou une variable ?

T est détruit, l'objet auquel il fait référence aussi

Par quel artifice l'objet est-il détruit ?

[Goten]

Le C++ Aurait-il un ramasse miettes ?

Pas du tout..

[Lucien63]

Le C++ Aurait-il un ramasse miettes ?

Pas du tout.

Ça je savais, mais je disais cela en rapport à la reponse de hiura.
Car je n'ai jamais vu que la destruction de toutes les références sur un objet fesait que c++ détruisait l'objet auquel elle fesaient références.

T est un type ou une variable ?

T est un type.

Je m'en doutais, mais je ne savait pas "que l'on pouvait détruire un Type" :

// T est détruit,

C'est pour cela que je posait la question !

La portée

Idem que plus haut. La variable référence est détruite ok, mais comment peut tu dire que l'objet auquel elle fait référence est détruit ?