Delphi: la Compréhension des constructeurs

Je vois deux raisons, la première série de déclarations ne devrait pas compiler proprement:

1. Il devrait y avoir un avertissement dans TCellPhone que son constructeur cache la méthode de la classe de base. C'est parce que la base de la méthode de classe est virtuel, et le compilateur soucis que vous êtes l'introduction d'un nouveau méthode avec le même nom sans écraser la base de la méthode de classe. Il n'importe pas que les signatures diffèrent. Si votre intention est en effet de cacher la méthode de la classe de base, alors vous devez utiliser reintroduce sur le descendant de la déclaration, comme l'un de vos angles devine a montré. Le seul but de cette directive est d'étouffer l'avertissement; il n'a pas d'effet sur le temps d'exécution de comportement.

   En ignorant ce qui se passe avec TIPhone plus tard, à la suite de TCellPhone déclaration est ce que vous voulez. Il cache l'ancêtre de la méthode, mais vous voulez qu'il soit aussi bien virtuelles. Il ne sera pas hérité de la virtualness de l'ancêtre de la méthode parce qu'ils sont deux choses complètement distinctes des méthodes qui venez d'arriver à avoir le même nom. Par conséquent, vous devez utiliser virtual sur la nouvelle déclaration.

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

   La base le constructeur de la classe, TComputer.Create, est également cacher une méthode de son ancêtre, TObject.Create, mais puisque la méthode dans TObject n'est pas du virtuel, le compilateur n'a pas prévenu à ce sujet. Cacher non-méthodes virtuelles arrive tout le temps et est généralement normaux.

2. Vous devriez obtenir un erreur dans TIPhone car il n'y a plus d'un argument du constructeur de remplacement. Vous vous êtes caché dans TCellPhone. Puisque vous voulez avoir deux constructeurs, reintroduce clairement n'était pas le bon choix pour une utilisation antérieure. Vous ne voulez pas masquer la base le constructeur de la classe; vous voulez l'augmenter avec un autre constructeur.

   Puisque vous voulez les deux constructeurs ont le même nom, vous devez utiliser le overload directive. Cette directive doit être utilisé sur tous les originaux des déclarations — la première fois à chaque signature est introduite déclarations subséquentes dans les descendants. Je pensais qu'il était nécessaire sur tous déclarations (même la classe de base), et il ne fait pas de mal de le faire, mais je suppose qu'il n'est pas nécessaire. Donc, vos déclarations devrait ressembler à ceci:

   TComputer = class(TObject)
   public
     constructor Create(Cup: Integer);
       overload; // Allow descendants to add more constructors named Create.
       virtual;  // Allow descendants to re-implement this constructor.
   end;
   
   TCellPhone = class(TComputer)
   public
     constructor Create(Cup: Integer; Teapot: string);
       overload; // Add another method named Create.
       virtual;  // Allow descendants to re-implement this constructor.
   end;
   
   TiPhone = class(TCellPhone)
   public
     constructor Create(Cup: Integer);
       override; // Re-implement the ancestor's Create(Integer).
     constructor Create(Cup: Integer; Teapot: string);
       override; // Re-implement the ancestor's Create(Integer, string).
   end;

Moderne de la documentation dit quel ordre, tout devrait aller dans:

réintroduire; surcharge; liaison; convention d'appel; résumé; avertissement

où liaison est virtuel, dynamique, ou remplacer; convention d'appel est registre, pascal, cdecl, stdcall, ou safecall; et avertissement est plate-forme, obsolète, ou bibliothèque.

Ces six catégories distinctes, mais dans mon expérience, il est rare d'avoir plus de trois sur toute déclaration. (Par exemple, les fonctions qui ont besoin de conventions d'appel spécifié ne sont probablement pas de méthodes, de sorte qu'ils ne peuvent pas être virtuel.) Je ne me souviens jamais de l'ordre; je ne l'ai jamais vu documenté jusqu'à aujourd'hui. Au lieu de cela, je pense qu'il est plus utile de se souvenir de chaque directive but. Lorsque vous vous souvenez de directives qui vous avez besoin pour les différentes tâches, vous vous retrouverez avec seulement deux ou trois, et ensuite c'est assez simple de faire des essais pour obtenir une commande valide. Le compilateur peut accepter plusieurs commandes, mais ne vous inquiétez pas — ordre n'est pas important dans la détermination du sens. Toute commande du compilateur accepte auront le même sens que tous les autres (sauf pour les conventions d'appel; si vous parlez plus d'un de ceux-ci, seul le dernier compte, afin de ne pas le faire).

Oui, alors vous avez juste à vous rappeler le but de chaque directive, et de penser à ceux qui ne font pas de sens ensemble. Par exemple, vous ne pouvez pas utiliser reintroduce et override en même temps, parce qu'ils ont des sens opposés. Et vous ne pouvez pas utiliser virtual et override ensemble parce que l'un implique l'autre.

Si vous avez beaucoup de directives accumulent, vous pouvez toujours couper overload hors de l'image pendant que vous travaillez le reste des directives dont vous avez besoin. Donnez à vos méthodes de noms différents, savoir qui de la autres directives dont ils ont besoin par eux-mêmes, puis ajouter overload dos pendant que vous leur donnez tous les mêmes noms.

C'est un travail de mise en œuvre de l'définitions voulais:

program OnConstructors;
{$APPTYPE CONSOLE}
uses
SysUtils;
type
TComputer = class(TObject)
public
constructor Create(Cup: Integer); virtual;
end;
TCellPhone = class(TComputer)
public
constructor Create(Cup: Integer; Teapot: string); reintroduce; overload; virtual;
end;
TiPhone = class(TCellPhone)
public
constructor Create(Cup: Integer); overload; override;
constructor Create(Cup: Integer; Teapot: string); override;
end;
{ TComputer }
constructor TComputer.Create(Cup: Integer);
begin
Writeln('Computer: cup = ', Cup);
end;
{ TCellPhone }
constructor TCellPhone.Create(Cup: Integer; Teapot: string);
begin
inherited Create(Cup);
Writeln('Cellphone: teapot = ', Teapot);
end;
{ TiPhone }
constructor TiPhone.Create(Cup: Integer);
begin
inherited Create(Cup);
Writeln('iPhone: cup = ', Cup);
end;
constructor TiPhone.Create(Cup: Integer; Teapot: string);
begin
inherited;
Writeln('iPhone: teapot = ', Teapot);
end;
var
C: TComputer;
begin
C := TComputer.Create(1);
Writeln; FreeAndNil(C);
C := TCellPhone.Create(2);
Writeln; FreeAndNil(C);
C := TCellPhone.Create(3, 'kettle');
Writeln; FreeAndNil(C);
C := TiPhone.Create(4);
Writeln; FreeAndNil(C);
C := TiPhone.Create(5, 'iPot');
Readln; FreeAndNil(C);
end.

avec les résultats:

Computer: cup = 1
Computer: cup = 2
Computer: cup = 3
Cellphone: teapot = kettle
Computer: cup = 4
iPhone: cup = 4
Computer: cup = 5
Cellphone: teapot = iPot
iPhone: teapot = iPot

La première partie est en conformité avec cette. La définition de la TiPhone deux constructeurs se déroule alors comme suit:

• Le premier constructeur de surcharge un des deux constructeurs hérité et dominante de son frère. Pour atteindre cet objectif, l'utilisation overload; override surcharger le TCellPhone un tout en substituant les autres constructeur.
• Qui fait, la deuxième constructeur a besoin d'un simple override afin de remplacer son frère.