Delphi: comment cacher les constructeurs d'ancêtres?

mise à jour: vidé la question avec un exemple plus simple, qui n'est pas répondu par la réponse initialement acceptée

étant donné la classe suivante, et son ancêtre:

TComputer = class(TObject)
public
   constructor Create(Teapot: string='');
end;

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

en ce moment TCellPhone a 3 constructeurs visibles:

• Cup: Integer
• tasse: entier; théière: corde
• Théière: string = "

Que dois-je faire pour TCellPhone de sorte que le constructeur ancêtre ( Teapot: string = '' ) n'est pas visible, ne laissant que les constructeurs déclarés:

• Cup: Integer
• tasse: entier; théière: corde

Note : habituellement le simple fait de ayant un constructeur descendant se cache l'ancêtre:

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

• Cup: Integer

et si vous voulu de garder à la fois les le constructeur ancêtre et le descendant, vous marqueriez le descendant comme un overload :

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

• Cup: Integer
• théière: string = "

dans cette question exemple de code, Delphi se trompe sur mes mots-clés overload :

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

penser que:

• je veux surcharger mes constructeurs avec le ancêtre ,
• quand vraiment je veux le surcharger avec le frère

Comment cacher le constructeur ancêtre?

Note: Il pourrait être impossible de cacher l'ancêtre, non-virtuelle, constructeur en utilisant le langage Delphi, tel qu'il est actuellement défini. "impossible" est une réponse valide.

---

tentative de réponse (échec)

I essayé marquage des constructeurs descendants avec reintroduce (retombant à mon mode d'ajouter des mots-clés au hasard jusqu'à ce qu'il fonctionne):

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

mais ça n'a pas marché, les trois constructeurs sont encore visibles. : (

---

Question Initiale

j'ai un objet qui descend d'une classe qui possède les constructeurs ne veulent pas voir:

TEniac = class(TObject)
   constructor Create(PowerCord: TPowerCord=nil); //calls inherited Create

TComputer = class(TEniac) ...
   constructor Create(PowerCord: TPowerCord=nil); //calls inherited Create(nil)

TCellPhone = class(TComputer)
   constructor Create(sim: TSimChip; UnlockCode: Integer); //calls inherited Create(nil)

TiPhone = class(TCellPhone)
   constructor Create(sim: TSimChip); //calls inherited Create(sim, 0)

Note: il s'agit d'un exemple hypothétique. Comme dans le monde réel, les objets ancêtre ne peuvent pas être changés sans briser le code existant.

Maintenant, quand quelqu'un est à l'aide de TiPhone je ne veux pas encore être en mesure de voir le constructeur de TEniac :

iphone := TiPhone.Create(powerCord);

pire encore: s'ils appellent ce constructeur, ils ratent complètement mon constructeur, et tout ce qui se fait entre les deux. Il est assez facile d'appeler le mauvais constructeur, Tous sont visibles dans le code IDE-completion, et vont compiler:

TiPhone.Create;

et ils obtiennent un objet complètement invalide.

je pouvais changer TCellPhone pour lancer une exception dans ces constructeurs:

TCellPhone.Create(PowerCord: TPowercord)
begin
   raise Exception.Create('Don''t use.');
end;

mais les développeurs ne réaliseront pas qu'ils appellent le mauvais constructeur jusqu'à ce que le client trouve l'erreur Un jour et nous amende des milliards de dollars. En fait, je suis essayer pour trouver partout j'appelle le mauvais constructeur - mais je ne peux pas comprendre comment faire Delphi me dire!