Delphi: Wann wird reintroduce verstecken Vorfahren und wann es ihnen zeigen?

Question

Heute Zuletzt auf Stackoverflow i gelernt, dass:

• reintroduce auf verwendet verbergen Vorfahren Konstrukteurs
• reintroduce auf zeigen Vorfahren Konstrukteurs

Ich habe versucht, einen Sinn zu machen alles, ist so hier eine andere, ganz konkrete Frage, Unterstützung meine Hauptfrage Umgang mit Konstrukteuren .

---

Update: ersetzt die gesamte Frage:

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;

Wenn TCellPhone Konstruktion, 3 Konstrukteure sind avaible:

• Cup: Integer
• Cup: Integer; Teekanne: string
• [Teekanne: String = '']

Frage: Warum ist constructor(Teapot: string='') nicht versteckt

---

Jetzt habe ich einen dritten Nachkomme:

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;

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

Wenn TiPhone Konstruktion vier Konstrukteure stehen zur Verfügung:

• Cup: Integer
• Cup: Integer
• Cup: Integer; Teekanne: string
• [Teekannen: string = '']

Warum gibt es vier Bauer? i overrode eine der drei bestehenden. Edit: Dies ist ein Fehler in der Code-Einsicht sein mag, es zeigt mir vier - doch wie könnte ich nenne möglicherweise dann, wenn zwei gleich sind

.

---

Mit dem ursprünglichen Code wieder:

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;

es ist bereits bekannt, dass TCellPhone hat drei Konstrukteure:

• Cup: Integer
• Cup: Integer; Teekanne: string
• [Teekanne: String = '']

Wie verändern ich die Erklärung von TCellPhone den Vorfahren Konstruktor zu verbergen? z.B. so dass:

TNokia = class(TCellPhone)
end;

nur zwei Konstrukteure haben:

• Cup: Integer
• Cup: Integer; Teekanne: string

---

Jetzt für den Fall, in dem reintroduce verwendet, um einen nicht-virtuellen Vorfahren zu verstecken. Im vorherigen Fall TiPhone vier Konstrukteuren hat (im Idealfall gäbe es nur zwei sein - mit TComputer irgendwie seine Vorfahren versteckt). Aber selbst wenn ich kann nicht fix TComputer, i TiPhone nur hat eine ändern können:

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;

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

Jetzt TiPhone hat nur einen Konstruktor:

• Cup: Integer

Reintroduce wird normalerweise nur verwendet, um die Warnung zu verbergen virtuelle Vorfahren zu unterdrücken. In diesem Fall:

Create(Teapot: string = '')

ist nicht virtuell -. Doch ich kann noch reintroduce verwenden, es zu verbergen

---

Aber jetzt , wenn ich einen anderen zu TiPhone überlastet hinzufügen:

TiPhone = class(TCellPhone)
public
   constructor Create(Cup: Integer); reintroduce; overload;
   constructor Create(Handle: String); overload;
end;

Dann plötzlich die (vorher versteckt) Vorfahren kommen zurück:

• TiPhone.Create (7);
• TiPhone.Create ( 'pink');
• TiPhone.Create (7, 'rosa');
• TiPhone.Create ();

Wie Sie sehen, ich bin zu kämpfen, die Logik

verstehen

• , wenn etwas versteckt
• Wie zu verbergen etwas
• , wenn etwas gezeigt
• , wie etwas zeigen

Answer 1

Sie haben keine reintroduce verwenden ein Verfahren zur Herstellung eines Vorfahren Klasse zu verstecken. Sie tun das, indem einfach eine Methode mit dem gleichen Namen wie ein in der Vorgängerklasse deklarieren, ohne zwingenden oder Überlastung. Sie verwenden reintroduce die Warnung zu unterdrücken, dass Delphi stellt sich, wenn die Methode der Vorgängerklasse (die versteckt) virtuell ist.

Wenn die Methode des Nachkommen Überschreibungen die Vorfahren, dann versteckt es nicht. Anrufe auf die Methode der Vorfahren sind geroutet der Nachkomme ist statt.

Wenn die Methode des Nachkommen Überlastungen die Vorfahren, dann ist es auch nicht versteckt. Beide sind auf Abruf zur Verfügung.

Answer 2

Sie können keine Methode überschreiben, die nicht virtuell ist, so dass Sie nichts zu verbergen. Deshalb keine Warnung gibt.

bearbeiten: ich meine Behauptung zurückziehen würde "Du bist nichts zu verstecken" . Ich glaube, ich verstehe nicht ganz die Bedeutung hier zu verstecken. Ich habe gebeten, eine quesiton zu diesem Thema.

Update:
Basierend auf dem Antwort ich habe, würde ich mag-Sätze wieder auf meine Antwort: Da TComputer.Constructor ist nicht virtuell deklariert, haben Sie bereits versteckt, dass Verfahren aus abgeleiteten Klassen. So TCellPhone Bauer kann sich nicht verstecken, was überhaupt nicht sichtbar gewesen, daher keine Compiler-Warnung.

Answer 3

Nun, es scheint, dass Sie nicht eine Methode / Konstruktor in einer Klasse verbergen können, wo man es auch überlasten. Ich kam mit diesem winzigen „Hack“ zu verwalten den Konstruktor von TComputer zu verbergen

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

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

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

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

In diesem exemple wird TiPhone hat nur 1 Konstruktor zur Verfügung. Es bricht den Polymorphismus aber (einen Preis zu zahlen, um den zweiten Konstruktor von TCellPhone zu verstecken). Ich würde gerne wissen, ob jemand eine Möglichkeit, dies zu tun, ohne zu brechen den Polymorphismus gefunden hat.

Auch zur Kenntnis nehmen, dass es nicht, weil der Code Einsicht zeigen Ihnen 4 „Konstrukteure“, dass es in der Tat ist 4 zur Verfügung. Ich stellte fest, dass für jeden „überschreiben“ des contructor, würde ich 1 Konstruktor im Code Einsicht aufgelistet hat. Aber nur der Nachkomme Konstruktor wird in dieser Situation aufgerufen werden.

Dieses exemple wird sich beschweren, dass der zweite Konstruktor TCellPhone das eine vom THackComputer verstecken, aber ich denke, es ist eine falsch positive als derjenige von THackComputer in TCellPhone außer Kraft gesetzt wird. (Corner Fall Fehler, den ich denke, da dies nicht ein sehr verbreiteter Code strucure ist)

Answer 4

Ich wollte dies Rob Kennedy Antwort als Kommentar setzen, aber da kann ich nicht, hier gehe ich ..

  

Die ganze Zeit gibt es keine Warnung über versteckt Vorfahren Konstrukteuren.

Ganz einfach, weil Sie nicht tun.

  

Wenn ich die Vorfahren bin versteckt, warum gibt es keine Warnung? Ich habe keine reintroduce.

Wieder, einfach weil man nicht verstecken nichts.

Sie sah den Beweis, dass man nicht verstecken nichts tut. Es sind die drei verfügbaren Konstrukteuren, dass Sie überprüft haben, ist der Beweis.

  

Warum verwendet werden kann, wieder einführen, die Vorfahren zu verbergen?

Wie Rob erwähnt, reintroduce lediglich unterdrückt den Compiler Hinweis / Warnung. Es gibt keine wirkliche Technisierung hinter diesem Wort. So müssen Sie nicht verstecken nichts mit reintroduce.

Ich möchte meine Gedanken bringen, wie man verstecken, aber ich stimme mit Sertac, zuerst muss ich wissen, was ist Ihre Definition von Versteck in diesem Fall.

Edit:   Ich habe gerade gelesen, die Beiträge, die Sie erwähnt, ich glaube, Sie die Konzepte falsch verstanden haben. Hier ist meine kurze Erklärung.

  

reintroduce wird zu verstecken verwendet Vorfahren Konstrukteurs

Die Antwort dieser Beitrag nicht anzeigt, dass. Die eine, die wirklich Vorfahren Konstruktor versteckt ist die NEW CONSTRUCTOR des Nachkommen mit dem gleichen Parameter mit dem Vorfahren. Das Schlüsselwort reintroduce wird einfach Compiler-Warnung unterdrückt wird.

  

reintroduce verwendet Vorfahren zeigen Konstrukteuren

In der Antwort von diesem Posten, es ist das Schlüsselwort, das ÜBERLASTUNGS Vorfahren Konstruktor noch zur Verfügung stellt.

ADDITION als Reaktion auf Ians Frage in seinem Kommentar unter:

Der erste Schritt, um Ihre Verwirrung zu lösen, ist die wirklichen Probleme zu identifizieren. Wenn wir Sie sorgfältig Beiträge untersuchen, wird es offensichtlich, dass Sie tatsächlich in einem Schritt lösen zwei Probleme wollten. Die beiden Probleme sind:

1. Um Vorfahren Konstruktor mit bestimmten Namen
verstecken
2. Um mehr Konstruktor mit dem gleichen bestimmtem Namen in dem Nachkommen hat.

Obwohl sie einfache Probleme scheinen mag, aber eine sorgfältige Prüfung wird sofort den Kopf geschlagen, dass ihre Natur sind genau entgegengesetzt zueinander. Problem 1 will ein Verfahren / Konstruktor während Problem 2 will verstecken zeigen, nicht nur, aber mehr Verfahren / Baumeister. Also, wenn Sie sie zusammen mischen in einem Schritt , sie werden auf jeden Fall jede andere aufheben. Kein Wunder, sie geben Ihnen Kopfschmerzen ...:)

Die Grundregel diese beiden Probleme zu lösen, ist sie nicht in einem Schritt zu mischen. Das heißt, wir brauchen eine Zwischenklasse Problem 1 zu lösen und die Überlastung in Nachkommen dieser Zwischenklasse zu tun. So etwas wie folgt aus:

type
  TComputer = class(TObject)
  private
    FCaller: TConstructorCaller;
  public
     constructor Create(Teapot: string=''); virtual;

     property Caller: TConstructorCaller read FCaller;
  end;

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

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

  TiPhone = class(TCellPhone)
  public
    constructor Create(Cup: Integer); reintroduce; overload;
    constructor Create(Handle: String); reintroduce; overload;
  end;

Aus dem obigen Code ist TBaseCellphone die Zwischenklasse. In diesem Szenario ist die Aufgabe Erstellen von TComputer allein der Konstruktor zu verstecken. Bitte beachten Sie, dass Sie darf nicht Verwendung Überlastung Begriff hier, oder das Versteck abgebrochen. Jetzt, nachdem das Versteck geschehen ist, jetzt können Sie frei Ihre Überlastung Schlüsselwort in seinen Nachkommen Spam mehrere Konstruktor mit dem gleichen Namen zu erhalten.

Um zu überprüfen, können Sie sehen, dass der folgende Code nicht kompiliert:

   TCellPhone.Create('My Teapot');