private, public und der Rest

[Hansa]

Hi,

hier ist eine grundsätzliche Frage aufgetaucht : private, protected usw. ist klar. Aber was ist mit dem Rest ? Also die Deklarationen oben in den Forms ? Habe eine Eigenschaft als private deklariert um was zu testen => Zugriffsverletzung. Nach Verschieben in den oberem Bereich ist die Fehlermeldung weg. Wie hängt das alles zusammen ? Bzw. was muß da hin ?

[Khabarakh]

ohne Angabe => published (ergo für die RTTI greifbar).

[edit] Etwas genauer:

Zitat:

Zitat von OH

Die Elemente am Anfang einer Klassendeklaration ohne explizite Sichtbarkeitsangabe werden standardmäßig als published deklariert, wenn die Klasse im Status {$M+} compiliert oder von einer mit {$M+} compilierten Klasse abgeleitet wurde. Andernfalls erhalten sie das Attribut public.

[/edit]

[Der_Unwissende]

HI,
alles was ohne eigenen Bezeichner in einer Klasse (insbesondere Forms und Frames) steht, solltest du eigentlich immer schön in Ruhe lassen. Hier gehört der Code hin, den Delphi selbst verwaltet (alle Elemente auf dem Form und alle behandelten Ereignisse). Wie Khabarakh schon sagte, entspricht die Sichtbarkeit dem published, aber eigene Zeilen sollten deshalb trotzdem unter published aufgeführt werden.

Ok, auch wenn die Hilfe OH es nicht explizit sagt, bin ich mir doch recht sicher, dass Delphi irgendwo mal behauptet hat, dass dieser Bereich für den automatischen Code vorgesehen ist.

Gruß Der Unwissende

[mkinzler]

private : Sichtbar nun in Methoden dieser Klasse und in abgeleiteten Klassen, die in der selben Unit definiert sind.
protected: Sichtbar in Merthoden der eigenen Klasse und in den Methoden aller abgeleiteten Klassen
public: Auch von anderen Klassen bzw. "Globalcode" sichtbar, wenn Unit in Uses.
published: wie schon erwähnt, zusätzliche Registrierung RTTI(Runtime Type Information). Properties von in der IDE registrierten Komponenten, kann man im Objektinspektor manipulieren.

Nachtrag: Interessant wieviel Tippfehler ich in ein paar Sätzen produzieren kann ;-)

[Hansa]

Zitat:

Zitat von Der_Unwissende

aber eigene Zeilen sollten deshalb trotzdem unter published aufgeführt werden.
...
Ok, auch wenn die Hilfe OH es nicht explizit sagt, bin ich mir doch recht sicher, dass Delphi irgendwo mal behauptet hat, dass dieser Bereich für den automatischen Code vorgesehen ist.

Habe es getetest : public reicht tatsächlich nicht. Mit published oder oben deklarieren geht alles. Nur wo ist jetzt der Unterschied ? Ist es egal, oder @Unwissender : warum ist Deklaration unter published besser ? Die OH gibt da wirklich nicht viel her. Meine Vermutung geht dahin, daß oben die ohnehin als published (also im OI sichtbaren) Sachen deklariert sind und das published unnötig ist. Meine Sachen sind aber sehr OOP (in diesem Falle : lastig), so daß die Frage noch wichtig werden könnte.

[Der_Unwissende]

Also wenn du sehr OOP lastig programmierst, dann ist es natürlich vollkommen egal welchen der beiden Bereiche du wählst ;-) Der einfache Grund, warum du deine eigenen Zeilen eine Sichtbarkeit explizit zuordnen solltest, ist die Eindeutigkeit.
Es ist einfach sauberer (imho), wenn jeder sofort sehen kann, welche Sichtbarkeit explizit vorgesehen wurde (und gerade in Delphi wird so ziemlich alles explizit ausgezeichnet).
Und wie gesagt, der von Delphi selbst verwaltete Code landet immer in dem nicht weiter benannten Bereich. Hier kommt also Code hinzu und wird entfernt und das alles automatisch, da dies nicht für deinen Code gilt, denke ich ist es einfach schöner, den richtigen Bereich zu wählen.
An der eigentlichen Sichtbarkeit wird sich sicherlich nicht viel ändern und unter dem Aspekt betrachtet ist es egal.

Gruß Der Unwissende

[_SolidSnake_]

Hallo.

Es tut mir leid wenn ich nochmal nachfragen muss, aber ich hab es leider nicht ganz verstanden :oops:

Ich habe als Grundlage den Thread über die MySQL-Verbindung ohne Komponenten von Chewie genommen und für meine Zwecke ein wenig erweitert.

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
      _myCon: PMySQL;       //unseren Verbindungsdeskriptor
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

wo ist der Unterschied ob ich die "_myCon: PMySQL" unter private, public oder einfach bei var deklariere ?
Ich hab sie bereits in alle drei Bereiche verschoben und die Anwendung funktioniert bei allen drei Möglichkeiten.
Sollte mich ja eigentlich freuen das es funktioniert, aber ich würde gerne wissen warum und ob das wirklich egal ist wo sie steht.

Gruß
Micha

[mkinzler]

Bei Verwendung in Methoden der Klasse ist es wirklich "egal" in welchem Bereich deklariert wurde. Von "außen" macht es aber einen Unterschied. Siehe meinen ersten Post in diesem Thread.

[Sharky]

Hai _SolidSnake,

ich hoffe das ich es richtig zusammen bekomme ;-) Ansonsten einfach mal in der Onlinehilfe schauen :stupid:

Zitat:

Zitat von _SolidSnake_

...wo ist der Unterschied ob ich die "_myCon: PMySQL" unter private, public oder einfach bei var deklariere ?...

Wenn Du eine Var deklarierst ist dies eine Globale Variable die in der gesamten Unit vorhanden ist.
Wenn Du es unter private deklarierst ist es ein Member deiner Klasse (TForm1) und auch nur in dieser sichtbar.
Wenn Du es als public ist es auch ausserhalb der Klasse sichtbar.

[Lemmy1]

Zitat:

Zitat von mkinzler

private : Sichtbar nun in Methoden dieser Klasse und in abgeleiteten Klassen, die in der selben Unit definiert sind.
protected: Sichtbar in Merthoden der eigenen Klasse und in den Methoden aller abgeleiteten Klassen
public: Auch von anderen Klassen bzw. "Globalcode" sichtbar, wenn Unit in Uses.
published: wie schon erwähnt, zusätzliche Registrierung RTTI(Runtime Type Information). Properties von in der IDE registrierten Komponenten, kann man im Objektinspektor manipulieren.

Nachtrag: Interessant wieviel Tippfehler ich in ein paar Sätzen produzieren kann ;-)

Private ist auch sichtbar in Klassen derselben Unit, die keine Nachfahren sind :) generell heisst private einfach "innerhalb der Unit". Gibt aber auch "strict private", dann isses nur innerhalb der Klasse sichtbar.

Grüße ;)

[_SolidSnake_]

Hallo.

Erstmal vielen Dank für die schnellen Antworten :)

Wenn ich das richtig verstehe, dann ist es erstmal egal wo ich "_myCon" deklariere (am besten aber in private) solange ich die Verbindung nur in dieser Unit aufbaue. Wenn ich aber die z.B. "_myCon" in Form1 deklariere und die Verbindung dort aufbaue aber eine SQL-Abfrage in Form2 starte wuzu ich dort ja auch "myCon" benötige dann muss ich diese unter var deklarieren, richtig ?
Form2 ist eine zweite Unit die ich über ein Menü in Form1 öffnen kann.

Tut mir leid wenn ich da noch nicht so richtig hinter steige, aber ich hab bis vor kurzem mit PHP gearbeitet und da war alles etwas einfacher was die Variablen anging.

Gruß
Micha

[xaromz]

Hallo,

Zitat:

Zitat von _SolidSnake_

...(am besten aber in private) solange ich die Verbindung nur in dieser Unit aufbaue.

Genau. Die Regel lautet: Nur soviel Sichtbarkeit, wie unbedingt nötig. Wenn Du die Variable nur in Form1 brauchst, dann ist private richtig.

Zitat:

Zitat von _SolidSnake_

Wenn ich aber die z.B. "_myCon" in Form1 deklariere und die Verbindung dort aufbaue aber eine SQL-Abfrage in Form2 starte wuzu ich dort ja auch "myCon" benötige dann muss ich diese unter var deklarieren, richtig ?

Nicht ganz. In Diesem Fall solltest Du die Variable unter public definieren, dann kannst Du mittels Form1.Variablenname darauf zugreifen. Eleganter wäre aber folgendes:

Delphi-Quellcode:

TForm1 = class(TForm)
private
  FmyCon: PMySQL;
  function GetmyCon: PmySQL; // Der Getter
public
  property myCon: PmySQL read GetmyCon; // Lesen mit Getter
end;

function TForm1.GetmyCon: PmySQL;
begin
  Result := FmyCon;
end;

Damit erlaubst Du es, dass die Variable öffentlich zugänglich ist (per Property), aber nur gelesen werden kann. So kann jeder die Variable benutzen, aber den Wert nicht ändern.
Wenn Du den Wert ändern willst, kannst Du das auch so machen:

Delphi-Quellcode:

TForm1 = class(TForm)
private
  FmyCon: PMySQL;
  FStatus: Integer;
  function GetmyCon: PmySQL; // Der Getter
  procedure SetmyCon(const Value: PmySQL); // Der Setter
public
  property myCon: PmySQL read GetmyCon write SetmyCon; // Lesen und Setzen mit Getter und Setter
  property Status: Integer read FStatus; // Direktes Lesen der Variablen
end;

function TForm1.GetmyCon: PmySQL;
begin
  Result := FmyCon;
end;

procedure TForm1.SetmyCon(const Value: PmySQL);
begin
  ShowMessage('Die Variable ändert sich!');
  FmyCon := Value;
end;

Da kannst Du beim Setzen der Variable z. B. noch Überprüfungen durchführen.
Das Ganze nennt sich Kapselung. Es ist immer besser, Properties zu verwenden und die Variable in private zu verstecken. Wenn Du Dir die VCL-Quellen anschaust, siehst Du, dass Borland das nie anders macht.

Zitat:

Zitat von _SolidSnake_

aber ich hab bis vor kurzem mit PHP gearbeitet und da war alles etwas einfacher was die Variablen anging.

Wenn man in PHP mit Klassen arbeitet, dann funktioniert das (fast) genauso. Es gibt z. B. auch private und public :zwinker: .

Gruß
xaromz

[_SolidSnake_]

Hallo xaromz :)

Das hilft mir weiter. Vielen Dank :-D

Gruß
Micha