Delphi: comprendre les constructeurs

je cherche comprendre

"

• virtuel
• remplacer
• surcharge
• réintroduit

lorsqu'elle est appliquée aux constructeurs d'objets. Chaque fois que j'ajoute des mots-clés au hasard jusqu'à ce que le compilateur ferme - et (après 12 ans de développement avec Delphi) je préfère savoir ce que je fais, plutôt que d'essayer les choses au hasard.

donné un ensemble hypothétique d'objets:

TComputer = class(TObject)
public
    constructor Create(Cup: Integer); virtual;
end;

TCellPhone = class(TComputer)
public
    constructor Create(Cup: Integer; Teapot: string); virtual;
end;

TiPhone = class(TCellPhone)
public
    constructor Create(Cup: Integer); override;
    constructor Create(Cup: Integer; Teapot: string); override;
end;

la façon dont je veux qu'ils se comportent est probablement évidente d'après les déclarations, mais:

• TComputer a le constructeur simple, et les descendants peuvent l'outrepasser
• TCellPhone a un constructeur alternatif, et les descendants peuvent le remplacer
• TiPhone l'emporte sur les deux constructeurs, appelant la version héritée de chaque

maintenant que le code ne se compile pas. je veux comprendre pourquoi ça ne fonctionne pas. je veux aussi comprendre la bonne façon d'outrepasser les constructeurs. Ou peut-être que vous ne pourriez jamais outrepasser les constructeurs? Ou peut-être est-il parfaitement acceptable d'outrepasser les constructeurs? Peut-être ne devriez-vous jamais avoir plusieurs constructeurs, peut-être est-il parfaitement acceptable d'avoir plusieurs constructeurs.

je veux comprendre le pourquoi . Le réparer serait alors évident.

voir aussi

• Delphi: Comment masquer ancêtre des constructeurs?
• rétablissement des fonctions dans le Delphi
• Delphi: comment ajouter un constructeur différent à un descendant?

Edit: je suis également à la recherche pour obtenir un certain raisonnement sur l'ordre de virtual , override , overload , reintroduce . Car en essayant toutes les combinaisons de mots-clés, le nombre de combinaisons explose:

• virtuel; surcharge;
• virtuel; override;
• override; surcharge;
• override; virtual;
• virtuel; outrepasser; surcharge;
• virtuel; surcharge; override;
• surcharge; virtual; override;
• override; virtual; surcharge;
• override; surcharge; virtual;
• surcharge; override; virtual;
• etc

Edit 2: je suppose que nous devrions commencer par " est la hiérarchie de l'objet même possible? " Si non, pourquoi pas? Par exemple, est-il fondamentalement incorrect d'avoir un constructeur à partir d'un ancêtre?

TComputer = class(TObject)
public
    constructor Create(Cup: Integer); virtual;
end;

TCellPhone = class(TComputer)
public
    constructor Create(Cup: Integer; Teapot: string); virtual;
end;

je pense que TCellPhone a maintenant deux constructeurs. Mais je ne trouve pas la combinaison de mots-clés dans Delphi pour lui faire penser que c'est une chose valide à faire. Je suis fondamentalement tort de penser que je peux avoir deux constructeurs, ici dans TCellPhone ?

---

Note: Tout ce qui est en dessous de cette ligne n'est pas strictement nécessaire pour répondre à la question-mais cela aide à expliquer ma pensée. Peut-être que vous pouvez voir, basé sur mes processus de pensée, ce que une pièce fondamentale qui me manque. tout devient clair.

Or ces déclarations ne compilent pas:

//Method Create hides virtual method of base type TComputer:
TCellPhone = class(TComputer)
   constructor Create(Cup: Integer; Teapot: string);  virtual;

//Method Create hides virtual method of base type TCellPhone:
TiPhone = class(TCellPhone)
public
   constructor Create(Cup: Integer); override;
   constructor Create(Cup: Integer; Teapot: string); overload;  <--------
end;

---

donc d'abord je vais essayer de réparer TCellPhone . je vais commencer par hasard ajouter le mot-clé overload (je sais que je ne veux pas reintroduce parce que cela cacherait l'autre constructeur, que je ne veux pas):

TCellPhone = class(TComputer)
public
   constructor Create(Cup: Integer; Teapot: string); virtual; overload;
end;

mais qui échoue: Field definition not allowed after methods or properties .

je sais par expérience que, même si je n'ai pas de champ après une méthode ou une propriété, si j'inverse l'ordre du virtual et overload mots clés: Delphi se fermera:

TCellPhone = class(TComputer)
public
   constructor Create(Cup: Integer; Teapot: string); overload; virtual; 
end;

mais j'obtiens toujours l'erreur:

Méthode "Créer" des peaux de méthode virtuelle de la base type 'TComputer'

donc j'essaie de supprimer les deux mots clés:

TCellPhone = class(TComputer)
public
   constructor Create(Cup: Integer; Teapot: string);
end;

mais j'obtiens toujours l'erreur:

Méthode "Créer" des peaux de méthode virtuelle de la base type 'TComputer'

alors je me résigne à essayer MAINTENANT reintroduce :

TCellPhone = class(TComputer)
public
   constructor Create(Cup: Integer; Teapot: string); reintroduce;
end;

et maintenant TCellPhone compile, mais il a fait les choses bien pire pour TiPhone:

TiPhone = class(TCellPhone)
public
   constructor Create(Cup: Integer); override; <-----cannot override a static method
   constructor Create(Cup: Integer; Teapot: string); override; <-----cannot override a static method
end;

les deux se plaignent que je ne peux pas les annuler, donc je supprime le override mot clé:

TiPhone = class(TCellPhone)
public
   constructor Create(Cup: Integer);
   constructor Create(Cup: Integer; Teapot: string);
end;

mais maintenant le 2nd create dit qu'il doit être marqué avec surcharge, ce que je fais (en fait je marquerai les deux comme surcharge, puisque je sais ce qui se passera si Je ne le fais pas):

TiPhone = class(TCellPhone)
public
   constructor Create(Cup: Integer); overload;
   constructor Create(Cup: Integer; Teapot: string); overload;
end;

tout est bon dans le interface section. Malheureusement, mes implémentations ne fonctionneront pas. Mon seul constructeur de paramètre de TiPhone ne peut pas appeler le constructeur hérité:

constructor TiPhone.Create(Cup: Integer);
begin
    inherited Create(Cup); <---- Not enough actual parameters
end;