Zeigerproblem

[nEmai]

Hiho,

Ich hab es (noch) nicht so mit Zeigern und daher keine Ahnung was Delphi nun wirklich von mir will.

Delphi-Quellcode:

  TBarGraph = class
    private
      PBitmap: ^TBitmap;
      FBars: Array of Integer;
      procedure Bar(const aPosition, aValue: Integer);
      procedure ArraySwap(const aPosition1, aPosition2: Integer);
      procedure BitmapSwap(const aPosition1, aPosition2: Integer);
    public
      constructor Create(var aImage: TImage; aForm: TForm);
      destructor Destroy; override;
      procedure Draw;
      procedure BubbleSort;
      procedure QuickSort(const aLow, aHigh: Integer);
  end;

var
  Form1: TForm1;
  bKill: Boolean;
  MyBarGraph: TBarGraph;

implementation
{$R *.dfm}

constructor TBarGraph.Create(var aImage: TImage; aForm: TForm);
const
  MAXRANDOM= 530;
  BARQUANTITY= 150;
var
  iCounter: Integer;
begin
  inherited Create;
  setLength(FBars, BARQUANTITY);
  for iCounter:= 0 to High(FBars) do
    FBars[iCounter]:= random(MAXRANDOM)+1;
  PBitmap:= @aImage.Picture.Bitmap; //<--------
  PBitmap^.Height:= MAXRANDOM+20;
  PBitmap^.Width:= (Length(FBars)*4)+8;
  aImage.Height:= PBitmap^.Height;
  aImage.Width:= PBitmap^.Width;
  aForm.Height:= PBitmap^.Height+130;
  aForm.Width:= PBitmap^.Width+100;
end;

Schmeißt bei Aufruf in der markierten Zeile den Fehler "Variable erforderlich".
Was ist daran falsch?

MfG.

[Muetze1]

Wozu brauchst du den Zeiger? Schmeiss das ^ bei der Deklaration raus und das @ bei der Zuweisung. Instanzenvariablen sind intern schon Zeiger, somit alles wie gehabt und keine Verrenkungen nötig.

[nEmai]

Und wenn ich es doch so machen wollte?
Ich will ja was bei lernen. Und dabei mein ich nicht unbedingt wie man es am besten macht. ^^

[Muetze1]

Zitat von nEmai:

Und wenn ich es doch so machen wollte?
Ich will ja was bei lernen. Und dabei mein ich nicht unbedingt wie man es am besten macht. ^^

Ok, aber dann bleibt die Frage: Warum ein Zeiger? Du versuchst einen Zeiger auf einen Zeiger zu bauen und dazu fällt mir gar keine Nutzung für ein.

Und zu deinem Problem Bitmap ist eine Property und somit kannst du davon keine Adresse ermitteln. Aus dem einfachen Grund da eine Property mit einem Getter, Setter oder einer direkten Variablenreferenz definiert werden kann. Somit kann er keine Adresse ermitteln.

[taaktaak]

Wenn du etwas über die Verwendung von Zeigern lernen möchtest, dann suche dir besser einen anderen Anwendungsfall: Vielleicht eine einfach oder doppelt verkettete Liste, da macht es Sinn und ist auch didaktisch besser (denke ich mir mal so)

[nEmai]

Nun ich wollte hier Zeiger einsetzen, weil ich mir die Bitmap an Image.Picture als Objekt TBitmap vorgestellt hab, mit dem ich arbeiten will.
Meine Logik sagt mir ich brauch nen Pointer darauf.
Aber ich hab es nun so gemacht und es geht. ^^

Delphi-Quellcode:

PBitmap: TBitmap;
..
PBitmap:= aImage.Picture.Bitmap;

Danke&MfG^^

[Muetze1]

Zitat von nEmai:

Meine Logik sagt mir ich brauch nen Pointer darauf.

Deine Logik ist richtig. Füge deinem Wissen einfach noch folgendes hinzu:

Zitat von Muetze1:

Instanzenvariablen sind intern schon Zeiger, ...

Damit hast du deinen Pointer und deine Logik ist vollkommen richtig.

[nEmai]

Ok, das heißt, wenn ich es richtig versteh:
Image.Picture.Bitmap ist ein Pointer auf eine Bitmap, also eine Speicheradresse.

Dann müsste

Delphi-Quellcode:

var
  ptrBitmap: ^TBitmap;
begin
  ptrBitmap:= Image.Picture.Bitmap;
end;

ja funktionieren.
Es kommt aber inkompatible Typen Pointer und TBitmap.
Wird das schon intern dereferenziert und wenn ja gibt es einen Befehl mit dem man es verhindern kann?
(Ich wüsste einfach gern ob und wie ich darauf einen eigenen Pointer machen kann.)

MfG^^

[Muetze1]

Zitat von nEmai:

Ok, das heißt, wenn ich es richtig versteh:
Image.Picture.Bitmap ist ein Pointer auf eine Bitmap, also eine Speicheradresse.

Dann müsste

Delphi-Quellcode:

var
  ptrBitmap: ^TBitmap;
begin
  ptrBitmap:= Image.Picture.Bitmap;
end;

ja funktionieren.
Es kommt aber inkompatible Typen Pointer und TBitmap.
Wird das schon intern dereferenziert und wenn ja gibt es einen Befehl mit dem man es verhindern kann?
(Ich wüsste einfach gern ob und wie ich darauf einen eigenen Pointer machen kann.)

MfG^^

Jain. Mal ein wenig ausführlicher:

Wir nehmen uns ein Objekt:

Delphi-Quellcode:

var
  a: TObject;

Dann hast du dort an der Stelle von a nicht direkt das komplette TObject mit allen seinen Methoden und Feldern sondern nur einen Zeiger. Dieser würde dann auf den Speicherbereich zeigen, wo die Felder, etc liegen. Wenn du diese Variable deklariert hast, kannst du ja mal mit SizeOf(a) deren Grösse ermitteln: du wirst 4 bekommen. 4 Bytes, also genau die Grösse eines Pointers.

Du musst, um das Objekt nutzen zu können, die eine Instanz erstellen. Diese erhälst du mit dem Konstruktor-Aufruf. Dieser reserviert den notwendigen Speicher für das Objekt und gibt dir den Zeiger genau auf diesen Speicherbereich zurück. Von daher kannst du es auch abfragen ob ein Objekt existiert, wenn die Variable ordentlich intialisiert wird. Du kannst mit einem Vergleich auf <> nil abprüfen, ob schon eine Adresse drinne steht (wie bei einem Pointer btw).

Deshalb haben auch viele Probleme mit den Objekten, wenn sie Free aufrufen und danach weiterhin auf das Objekt zugreifen und AV's bekommen und selbst Assigned() bzw. ein Vergleich auf Nil nichts bringt: Der Zeiger zeigt weiterhin auf die Adresse (hat ihm ja keiner was anderes gesagt), aber da ist nichts mehr. Somit: FreeAndNil() ruft Free auf und setzt den Zeiger auf NIL und somit klappen die Abfragen auch.

Anderes Beispiel:

Delphi-Quellcode:

var
  a, b: TStrings;
begin
  a := TStringList.Create;  // neue Instanz
  b := a;                   // Objekt wird nicht kopiert, nur der Zeiger!

  a.Text := 'erstes Object';

  ShowMessage(b.Text);
end;

Bei dem Beispiel erzeugst du nur ein Objekt. Wäre a und b jeweils intern kein Zeiger, dann müsste er das komplette Objekt kopieren, da es komplett eigene Speicherbereiche sind. Wenn dem so ist, dann müsste die ShowMessage() einen leeren String ausgeben. Tut er aber nicht, sondern er gibt "erstes Object" aus. Grund dafür: er kopiert nur die Adresse aus dem Pointer in den anderen. Somit zeigen beide auf das selbe Objekt im Speicher.

Also: Wenn du eine Objektvariable deklarierst, ist diese nur 4 Bytes gross, da es ein Zeiger ist.

Dies ist das interne Handling, somit geschieht auch die Dereferenzierung automatisch intern von Delphi. Und ausserdem ist Delphi recht typensicher (wie oft habe ich das in den letzten Tagen geschrieben...) und TBitmap und Pointer sind nunmal unterschiedliche Typen.

[Namenloser]

Nimm zum Üben einen Record bzw einen Pointer auf diesen Record. Objekte sind zum Üben von Pointern denkbar ungeeignet.