référence et constructeur par défaut...

Bonjour,

Je dois actuellement modifier un gros programme, dont l'auteur a disparu
dans la nature...
Pour l'instant, mon but est de réussir à le porter (Windows->Linux) sans
trop de casse (cad ne me dites pas de revoir complètement l'architecture
générale, je le ferais, mais plus tard, quand j'aurais à peu près compris
comment ça marche ;))
Ca passe impec, sauf un petit problème avec G++ qui ne veut pas compiler
quelque chose qu'apparement Visual C++ acceptait. J'en ai fait un simple
résumé sur le code source suivant:

class Padawan {
public:
Padawan() { }
};

class Instructor {
Padawan& m_bizut;

Si vous réussissez à me donner une piste (autre que "recode tout"), je vous
en serait éternellement reconnaissant

  D'autant que là, tu cherches à avoir une référence sur un
temporaire.
J'ai bien compris que le problème venait d'ici ;)

  Donc, choisi ton camps: Padawan ou Padawan*.
Comme je l'ai dit, le programme est déjà fait. Je choisirais mon camps quand

--------- Version Padawan (composition en UML) -----
class Padawan {
public:
        Padawan() { }
};

class Instructor {
        Padawan m_bizut;

public:
        Instructor(const Padawan& p): m_bizut(p) { }
};

class Jedi: protected Instructor {
public:
        Jedi(): Instructor(Padawan()) { }
};

Très bien. Supposons que Instructor aie à modifier Padawan. Jedi s'en

--------- Version Padawan* (aggrégation en UML) -----
class Padawan {
public:
  Padawan() { }
};

class Instructor {
  Padawan* m_bizut;

public:
  Instructor(Padawan* p): m_bizut(p) { }
};

class Jedi: protected Instructor {
public:
        Jedi(): Instructor( new Padawan()) { }
};
Oui, mais dans ce cas, qui doit détruire m_bizut ?

        Jedi(): Instructor( new Padawan()) { }
qui me donnera une belle fuite de mémoire...

  Donc, choisi ton camps: Padawan ou Padawan*.
Comme je l'ai dit, le programme est déjà fait. Je choisirais mon camps quand

il tournera et que je pourrais tester si mes modifications font tout
planter ou pas - quand je pourrait vraiment debugger, là je suis seulement
dans la phase le faire compiler. Si je modifie trop de trucs avant de
tester si ça marche, je pourrais pas savoir ce qui a tout pété. Je n'ai, à
l'heure actuelle, aucun moyen de mesurer les conséquences du changement de
Padawan& et Padawan ou Padawan...

--------- Version Padawan (composition en UML) -----
class Padawan {
public:
        Padawan() { }
};

class Instructor {
        Padawan m_bizut;

public:
        Instructor(const Padawan& p): m_bizut(p) { }
};

class Jedi: protected Instructor {
public:
        Jedi(): Instructor(Padawan()) { }
};

Très bien. Supposons que Instructor aie à modifier Padawan. Jedi s'en

contrefout, mais on peut imaginer une fonction de ce type:
void instruct(Padawan& p) {
        Instructor i(p);
        i.learn_mathematics(); // modifie p
}
Avec la version Padawan&, pas de problème, le padawan connaitra les maths.
Avec la version Padawan, aucune chance...

--------- Version Padawan* (aggrégation en UML) -----
class Padawan {
public:
  Padawan() { }
};

class Instructor {
  Padawan* m_bizut;

public:
  Instructor(Padawan* p): m_bizut(p) { }
};

class Jedi: protected Instructor {
public:
        Jedi(): Instructor( new Padawan()) { }
};
Oui, mais dans ce cas, qui doit détruire m_bizut ?

Bon, vivement que ça tourne, que je puisse modifier tout ça ;)

PS: désolé d'avoir répondu par mail, je me suis planté d'icone (j'aime pas
akregator ;))

class Padawan {
public:
Padawan() { }
};

class Instructor {
Padawan& m_bizut;

public:
Instructor(Padawan& p): m_bizut(p) { }
};

class Jedi: protected Instructor {
public:
Jedi(): Instructor(Padawan()) { }
};

Quelqu'un aurait il une idée un peu plus belle que remplacer
Jedi(): Instructor(Padawan()) { }
par
Jedi(): Instructor(*(new Padawan)) { }
pour le faire compiler par G++ ? (parce ma méthode, en plus d'être moche,
donne des fuites de mémoire)

Oui, mais dans ce cas, qui doit détruire m_bizut ?
Ben, celui qui le construit, c'est à dire Jedi.

Ya des jours où je me sens bête, et ya des jours tout les jours, comme