Initialisation d'un composant d'une forme

Bonjour,

Une des formes de mon application (un descendant de TFrame) a, parmi ses composants, un autre descendants de TFrame, dont j'ai surchargé le constructeur. Donc j'ai un composant enfant et un composant, avec une entete du genre

Code:

---

1 2 3 4 5 6 7 8 9 10

class TMonEnfant : public TFrame { public: TMonEnfant(TComponent *owner, int param=0): TFrame(owner){...} }   class TMonParent : public TFrame { __published: TMonEnfant *enfant; }

---

Actuellement le composant enfant est créé automatiquement quand on crée son parent, et le constructeur de TMonEnfant est bien appelé, avec le second paramètre par défaut (à zéro dans l'exemple)

Maintenant, je voudrais changer ce paramètre dans le constructuer, en passant une liste d'initialisation au parent:

Code:

---

1 2	TMonParent(TComponent *owner) : TFrame(owner),enfant(owner,1) {}

---

Et là j'ai deux questions :

1- ca me donne un message : ne peut convertir int en TMonEnfant*, donc apparemment, l'initialisation de la liste enfant(owner,1) ne reconnait pas le constructeur, pourquoi?
2- est ce bien "owner" qu'il faut passer? ou (TComponent *)this?

Merci d'avance,
Francois

Comment est créé la TMonEnfant ?
Via l'IDE en Design Time
Par le code par un new en RunTime ?
__published sous-entend un chargement par DFM, tu es sur de cela ? j'en doute !
Si Enfant est présent en DesignTime dans Parent, attention à ne pas créer deux fois l'Enfant :
- une fois par DFM, Stream.ReadComponentRes et ses amis
- une fois par constructeur manuel !

ensuite, tu n'as pas redéfini le constructeur de TMonParent !
Soit cohérent AOwner est le paramètre dans le constructeur de TFrame, reprend le même nom !
A comme Argument, permettant de différencier de Owner la propriété !
Tu n'as pas mentionné le __fastcall, dans la redéfinition (virtual), cela ne provoque-t-il pas un warning de méthode masquée (voir W8022 et HIDESBASE)

Je n'aime pas trop les constructeurs inline sauf pour les exceptions

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class TMonEnfant : public TFrame { public: __fastcall virtual TMonEnfant(TComponent *AOwner, int param = 0); }   class TMonParent : public TFrame { private: TMonEnfant *FEnfant; public: __fastcall virtual TMonParent(TComponent *AOwner);   property TMonEnfant *Enfant = {read=FEnfant}; // garanti qu'on peut accéder à Enfant sans pouvoir changer la référence ! }

---

Ensuite, tu ne peux pas initialiser enfant sans un new

soit comme ceci façon C++

Code:

---

1 2 3 4 5 6

__fastcall TMonParent::TMonParent (TComponent *AOwner) : TFrame(AOwner), FEnfant(new TMonEnfant(AOwner, 1)) {   }

---

soit comme ceci façon C++ VCL

Code:

---

1 2 3 4 5

__fastcall TMonParent::TMonParent(TComponent *AOwner) : TFrame(AOwner) { FEnfant() = new TMonEnfant(AOwner, 1); }

---

Sinon effectivement, this pourrait être plus approprié que AOwner

Code:

---

1 2 3 4 5

__fastcall TMonParent::TMonParent(TComponent *AOwner) : TFrame(AOwner) { FEnfant() = new TMonEnfant(this, 1); // pas besoin de préciser (TComponent*)this }

---

ou même NULL et un destructeur !

Code:

---

1 2 3 4 5 6 7 8 9 10 11

__fastcall TMonParent::TMonParent(TComponent *AOwner) : TFrame(AOwner) { FEnfant = new TMonEnfant((TComponent*)NULL, 1); }   __fastcall TMonParent::~TMonParent() { delete FEnfant; FEnfant = NULL; }

---

et pour finir TMonEnfant

Code:

---

1 2 3 4 5

__fastcall TMonEnfant::TMonEnfant (TComponent *AOwner, int param = 0) : TFrame(AOwner) { ... param ... }

---

Citation:

---

Envoyé par ShaiLeTroll

Comment est créé la TMonEnfant ?
Via l'IDE en Design Time
Par le code par un new en RunTime ?
__published sous-entend un chargement par DFM, tu es sur de cela ? j'en doute !

---

TMonEnfant est créé via l'IDE. Le TMonParent est créé par un new, qui instancie automatiquement ses membres, en en particulier TMonEnfant. C'est sur cette instanciation automatique que je voudrais intervenir.

En gros, tu as qq part dans le code un appel du genre

Code:

---

1 2	new TMonParent(owner);

---

qui va appeler le constructeur de TMonParent, qui va construire ses enfants, et en particulier TMonEnfant. C'est cet appel implicite au constructeur de TMonEnfant que je voudrais rendre paramétrable, soit en passant un second paramètres au constructeur de TMonParent, soit sur la base d'une variable externe.

Je ne crois pas que je puisse le faire en surchargeant le constructeur de TMonParent: à ce moment, TMonEnfant est déjà instancié. Pour un membre de classe normal, je le ferais en passant une liste d'initialisation. C'est ce que j'essaye de faire ici, et qui n'a pas l'air de marcher.

Citation:

---

Envoyé par ShaiLeTroll

Tu n'as pas mentionné le __fastcall, dans la redéfinition (virtual), cela ne provoque-t-il pas un warning de méthode masquée

---

Non, je l'ai viré en récrivant l'exemple, il est dans le code d'origine. Mais je pense que c'est par là qu'il faudrait chercher. En essayant de tracer le constructeur à deux paramètres de TMonEnfant, je me suis rendu compte qu'il n'était apparemment pas généré...

Francois

N'inclu pas TMonEnfant dans TMonParent via la Conception !

Effectivement, c'est le DFM qui va dans ce cas va appeler le constructeur virtuel (oui ça en théorie ça n'existe pas en C++, c'est une bidouille pour supporter les fonctionnalités Delphi)
C'est ce que j'évoquais en mentionnant Stream.ReadComponentRes et ses amis

Si tu reste en mode Conception :
Ajoute une propriété à TMonEnfant que TMonParent pourra modifier lors de son constructeur
Plus exactement durant AfterConstruction ou peut être même TComponent.Loaded

Avec un TForm, j'aurais aucun problème, le Constructeur de la TForm a été appelé AVANT le constructeur de sa propre classe, le DFM est chargé, les objets sont instanciés !
La TFrame, je ne maîtrise pas (une TForm Parented fait très bien la même chose en plus souple)
Je pense que le constructeur est appelé pendant le chargement de la DFM, du coup, possible que FEnfant ne soit pas encore créer !

Code:

---

1 2 3 4

__fastcall TMonParent::Loaded() { FEnfant.Dummy = 1; }

---

Code:

---

1 2	__property int Dummy = {read=FDummy, write=SetDummy};

---

SetDummy sera automatiquement appelé par l'affectation et tu pourras y déporter le traitement prévu dans le constructeur !

Si tu retire TMonEnfant de TMonParent, tu pourras faire ton New !

Merci beaucoup, c'est très clair.

Si je passe par les DFM, je perds la main sur le processus d'instanciation de la forme (ou de la frame), et je dois intervenir à la fin de celui ci. Si j'instancie à l'exécution, ben, c'est comme en C++.

Francois