surcharge constructeur Form

Version imprimable

03/11/2006, 12h02
Pfeffer

surcharge constructeur Form
Bonjour,

Je souhaiterai passer un en paramètre à une Form un tableau!
Mais je n'arrive pas à surcharger le constructeur!

Comment est ce que je peux faire ?

Voici le code que je tente mais ça ne fonctionne pas!

dans le .h
Code:

1 2 __fastcall TFormResult(TComponent* Owner , TCompareResult * tabResult);
dans le .cpp de ma fenêtre
Code:

1 2 3 4 5 __fastcall TFormResult::TFormResult(TComponent* Owner , TCompareResult * tab) : TForm(Owner) { }
Merci
03/11/2006, 12h12
pottiez

Pourquoi ne pas simplement le déclarer come deuxieme constructeur, tu n'a plus qu'a mettre les bon parametre pour qu'il soit appeler a la place de l'autre.
03/11/2006, 12h13
bandit boy

Salut,
tu peux toujours déclarer dans ton .h le tableau en extern pour le passer d'une Form à une autre. Il y a un exemple ici.
03/11/2006, 14h51
Pfeffer

Encore une question:

J'ai donc fait deux constructeurs dans la fenêtre 2. Et ça fonctionne presque!

Seulement je passe en argument dans mon constructeur, un objet dont la classe est définie dans mon Unit1.cpp.

Dans mon Unit2.h je fais donc un include "Unit1.cpp" pour récupérer la définition de cette classe. Mais la j'ai une multitude d'erreur qui se génèrent.

Comment résoudre ce problème ?
03/11/2006, 15h59
Crayon

Normalement tu ne dois pas faire de include avec des .cpp seulement avec des .h (fichiers d'entête).

La définition de tes classes devrais toujours êtres dans un fichiers .h si tu veux quelles soient utilisées par d'autres classes.

Bonjour à tous,

Arrivant de C# je démarre un projet Borland C++ et bien entendu je suis complètement perdu dans cet environnement.

Je cherche à faire exactement ce que Pfeffer cherchait à faire.
J’ai opté pour la solution avec un constructeur de base, et un constructeur surchargé avec mon paramètre supplémentaire.

Là où je bute, c’est pour appeler mon constructeur surcharger.
Voici mon code et mon problème, ce qui sera de suite plus parlant pour tout le monde :

FrmContexte.h :
Code:

1 2 3 4 5 6 7 8 class TFormContexte : public TForm { __published: // Composants gérés par l'EDI public: // Déclarations utilisateur __fastcall TFormContexte(TComponent* Owner); __fastcall TFormContexte(TComponent* Owner, int p_iValeur);//Constructeur surcharger perso };
FrmContexte.cpp :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int l_iValeur; __fastcall TFormContexte::TFormContexte(TComponent* Owner) : TForm(Owner) { } //Définition du constructeur surcharger personnaliser __fastcall TFormContexte::TFormContexte(TComponent* Owner, int p_iValeur) : TForm(Owner) { l_iValeur = p_iValeur; }
Dans SDIMain.cpp (une page SDI de base avec un item de menu perso)
Code:

1 2 3 4 5 6 7 8 9 #include "FrmContexte.h" void __fastcall TSDIAppForm::Action_MenuTest_ContexteExecute(TObject *Sender) { //FormContexte->ShowModal();//Constructeur par def TFormContexte l_ptTFormContexte = new TFormContexte(NULL, 1); l_ptTFormContexte->ShowModal(); }
A l’ouverture de la parenthèse du new TFormContexte( je vois bien mes deux constructeurs. Par contre je ne sais pas ce que je dois mettre pour le Owner. J’ai essayé avec un NULL, mais bien entendu cela ne fonctionne pas:
[BCC32 Erreur] SDIMAIN.CPP(74): E2459 Les classes de style Delphi doivent être construites avec l'opérateur new

Est-ce que quelqu’un à une idée? Voir même mieux carrément un exemple?

Merci d’avance pour votre aide.

Bonjour,
ton problème ne viens pas de la surcharge de ton constructeur, mais de la manière dont tu déclare l'instance de ta fenêtre, les objet Borland doivent toujours être instancié avec des pointeur, il faut donc que ta variable soit du type TFormContexte*, sinon le reste est bon ;)
Code:

1 2 3 4 5 6 7 8 9 #include "FrmContexte.h" void __fastcall TSDIAppForm::Action_MenuTest_ContexteExecute(TObject *Sender) { //FormContexte->ShowModal();//Constructeur par def TFormContexte* l_ptTFormContexte = new TFormContexte(NULL, 1); l_ptTFormContexte.ShowModal(); }

18/07/2011, 15h46
ShaiLeTroll
Reprendre un sujet de 2006 ! Ce n'est pas bien !

Code:

TFormContexte l_ptTFormContexte = new TFormContexte(NULL, 1);

Toute petite erreur, il manque l'étoile, en C++, new implique un pointeur, cherche autour de "instanciation ou allocation statique" et "instanciation ou allocation dynamique"

:f1:
la Touche F1 si l'on sélectionne une erreur dans la liste fonctionne et propose un descriptif de l'erreur, google avec "E2459" comme mot clé te permet aussi de trouver la Documentation Wiki Embarcadero : Les classes de style Delphi doivent être construites en utilisant l'opérateur new (C++)

Code:

TFormContexte * l_ptTFormContexte = new TFormContexte(NULL, 1);

Pour NULL, il va peut-être rallé car void* n'est pas compatible avec TComponent* ...
Code:

1 2 TFormContexte * l_ptTFormContexte = new TFormContexte((TComponent*)NULL, 1); l_ptTFormContexte->ShowModal(); // -> c'est comme (*obj). déréférencement et accès au membre
otacon ghost ! Attention !
Tu tombes sur un cas plus subtile que celui de Pfeffer !
J'ai évoqué cela dans Méthodes Virtuelles appelés depuis un Constructeur - 11

Code:

__fastcall TForm(TComponent* Owner, int);

existe déjà !

Code:

/* TCustomForm.CreateNew */ inline __fastcall virtual TForm(Classes::TComponent* AOwner, int Dummy) : TCustomForm(AOwner, Dummy) { }

Tu vas donc surcharger le constructeur surnommé "CreateNew" !
Code:

1 2 3 __fastcall TFormContexte::TFormContexte(TComponent* Owner, int p_iValeur) : TForm(Owner) {
Dans cette surcharge de CreateNew tu appele le constructeur simple "Create"
mais Create appel CreateNew avec la spécificité de la VMT des objets Delphi, c'est bien ton CreateNew qui sera de nouveau appelé, alors même en apportant les corrections syntaxiques élémentaires, tu auras une erreur "débordement de pile" à cause d'une recursivité sans fin !

ta déclaration devra être de la forme suivant

Code:

HIDESBASE __fastcall TFormContexte(TComponent* AOwner, int p_iValeur);

HIDESBASE va "retirer" le virtual et donc l'override implicite, cela conservera intact le CreateNew de TForm !
18/07/2011, 16h05
otacon ghost

Merci à vous deux pour vos réponses hyper rapides.:D

Merci pour toutes c’est infos.
@ pottiez : J’ai corrigé ça devrais mieux marcher maintenant !
@ ShaiLeTroll : Je vais étudier ton sujet précédent. Avec toutes c’est infos précises, je devrais m’en sortir, je pense.

Pour l’aide en direct (F1) je ne savais pas que je pouvais faire ça dans la fenêtre de sortie.

Pour google, je suis bien tombé sur cette page, mais l’explication ne m’a pas aidé une seule seconde… En plus je reste souvent con dans l’aide de C++ Builder, du fait que l’on parle souvent Delphi alors que je suis en C++!!!

Reprendre un sujet de 2006 ! Ce n'est pas bien ! => J’ai hésité à faire un nouveau sujet, mais comme il y avait celui-là et que ma question me semblait correspondre à ce sujet je m’y suis raccroché !
Promis je ne le ferais plus lol :oops:
18/07/2011, 17h12
ShaiLeTroll

Le mieux est de créer un nouveau sujet
De décrire ton problème complètement (sans dépendance avec un autre sujet), ce que tu as très bien fait d'ailleurs !
Puis si l'envie se faire sentir d'ajouter un lien vers un autre sujet qui ressemble à ta problématique !

Pour HIDESBASE, je te conseille de tester avec et sans, cela te permettra de mieux comprendre !

Pour Delphi, pourtant ce dernier est plus proche du C# si l'on parle de la philosophie du langage (après tout, l'un fondateur du premier est aussi celui du second) mais avec une syntaxe C++ simplifé à la façon Java !

L'impact de Delphi est notable, car tout objet hérité du TObject dont la TForm ont des comportements très différents d'un objet C++ standard, tout simplement que le code compilé des objets c'est du Delphi et non du C++ !

Mieux vaut éviter de mélanger les deux !
Par habitude, Je préfixe mes classes par T pour la VCL et par C pour les C++ standard (surtout si je les utilise en allocation statique)
18/07/2011, 17h36
otacon ghost

:fleche: Petite question: Qu’est-ce que tu appelles « la VCL »?
Avec cette info je vais pouvoir comprendre ta notation des préfixes!

En fait je ne connais que C# (et toute la famille .NET, ainsi que Visual C++, VB5/6), je n’ai jamais touché de près ou de loin du Delphi…

:fleche: Maintenant je vais faire le gros lourd, car ça coince de nouveau :mur::
Après avoir compris le pourquoi du comment grâce à tes infos, j’ai rajouté le HIDESBASE.
Mais maintenant il m’envoi boulet :
[BCC32 Erreur] Forms.hpp(1063): E2241 Les classes de style Delphi ont besoin de destructeurs virtuels

Je n’ai pas fait deux fois le noob de base et je suis allez voir direct dans l’aide…
Qui m’indique que les destructeurs définis dans des classes VCL doivent être virtuels. Avec un exemple et tout… Soit. Je dois donc passer mon destructeur en virtuel…

Sauf que dans les classes de formulaire (fiche chez Borland), je n’ai pas de destructeur prédéfini. Et bien entendu si je déclare et implémente un destructeur il m’envoi encore boulet…

Bref, je suis de nouveau perdu… Tu pourrais me guider sur ce coup là?

Sachant que c’est la première étape… Car ensuite je sens que je vais créer un nouveau sujet, car je sors les rames…

Merci d’avance pour ton aide précieuse.:ccool:

Citation:

Envoyé par otacon ghost

:fleche: Petite question: Qu’est-ce que tu appelles « la VCL »?
Avec cette info je vais pouvoir comprendre ta notation des préfixes!

En fait je ne connais que C# (et toute la famille .NET, ainsi que Visual C++, VB5/6), je n’ai jamais touché de près ou de loin du Delphi…

VCL = Visual Component Library = La lib de C++Builder, tout ce qui hérite de TComponent ou de TControl
RTL = Run-Time Library = Autre partie de la la Lib C++Builder, c'est les classes de base et les diversions fonctions indispensables

On fait d'ailleurs souvent l'amalgame, moi le premier !
Savoir si c'est RTL ou VCL, souvent on s'en fout !
Pour toi, c'est comme les MFC en C++ ou le Framework .net !

Citation:

Envoyé par otacon ghost

:fleche: Maintenant je vais faire le gros lourd, car ça coince de nouveau :mur::
Après avoir compris le pourquoi du comment grâce à tes infos, j’ai rajouté le HIDESBASE.
Mais maintenant il m’envoi boulet :
[BCC32 Erreur] Forms.hpp(1063): E2241 Les classes de style Delphi ont besoin de destructeurs virtuels

Une erreur dans Forms.hpp ???
tu n'aurais pas modifié cette unité au lieu de TON unité ?
tu n'as pas un ~ qui traine ?
~ c'est comme en C#, c'est le destructor (appel par delete)

en théorie, ceci suffit
Code:

1 2 3 4 5 __fastcall TFormContexte(TComponent* Owner); HIDESBASE __fastcall TFormContexte(TComponent* Owner, int p_iValeur);//Constructeur surcharger perso __fastcall ~TFormContexte(); // Surtout pas de paramètre void __fastcall AfterConstruction(); // méthode virtuelle que l'on peut surchargée
à la base, je suis Delphiste, on a un mot clé override qui n'existe pas en C++ car implicite, du coup, je fais toujours ceci
Code:

1 2 3 4 5 /*constructor*/ virtual __fastcall TFormContexte(TComponent* Owner); /*constructor*/ HIDESBASE __fastcall TFormContexte(TComponent* Owner, int p_iValeur);//Constructeur surcharger perso /*destructor*/ virtual __fastcall ~TFormContexte(); // Surtout pas de paramètre /*override*/ virtual void __fastcall AfterConstruction(); // méthode virtuelle que l'on peut surchargée
j'ignore ce que tu as écrits pour avoir cette erreur, j'ai un peu de mal à t'aider !
Idem, l'aide est étrange, Destroy étant fourni par TObject, les destructeurs des classes héritées sont forcément virtuels !
Est-ce pour des classes façon VCL mais non TObject ??? je ne sais même pas si c'est possible !

19/07/2011, 09h40
otacon ghost

@ShaiLeTroll :
Merci encore pour toutes c'est explications et infos.:D
Au moins je commence un peut à comprendre la façon de faire sous Borland/C++...

Pour l'histoire du virtuel, je vais voir avec les infos que tu m'as donner.
Je vous tiens au jus !

@ShaiLeTroll :
Ok ça marche avec ce code ci:

FrmContexte.h :

Code:

1
2
3
4
5
6
7
8
9
10
class TFormContexte : public TForm
{
__published:	// Composants gérés par l'EDI
 
public:		// Déclarations utilisateur
	__fastcall TFormContexte(TComponent* Owner);
	HIDESBASE __fastcall TFormContexte(TComponent* AOwner, int p_iValeur);//Constructeur surchargé perso
	__fastcall ~TFormContexte();
 
};

FrmContexte.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//Définition du constructeur de base
__fastcall TFormContexte::TFormContexte(TComponent* Owner)
	: TForm(Owner)
{
}
 
//Définition du constructeur surchargé personnalisé
__fastcall TFormContexte::TFormContexte(TComponent* Owner, int p_iValeur)
	: TForm(Owner)
{
	l_iValeur = p_iValeur;
}
 
//Définition du destructeur de base
__fastcall TFormContexte::~TFormContexte(){
}

Je rajouterais les virtual pour faire propre ensuite...
Encore merci pour ton aide ;) ;) ;)

19/07/2011, 11h53
ShaiLeTroll

Citation:

Envoyé par otacon ghost

Je rajouterais les virtual pour faire propre ensuite...

Attention, c'est une habitude que j'ai pris en regardant les fichier HPP générés de C++Builder à partir des fichiers PAS !

Certains te diront que cela alourdi inutilement le code C++ !

Si tu travailles dans une équipe, tu devrais voir avec eux leur Charte de Code !
Si il n'y en as pas, il faudrait en définir une !