Pascal: Zeiger

[RedGuy]

Hi !

Kennt sich jemand mit Pascal aus ?
Es dreht sich um pointer in Pascal:

Code: Alles auswählen

var

Zeiger1,Zeiger2 : ^integer; {dies sind zwei Zeigervariablen}

begin
Zeiger1 := Zeiger2;
Zeiger2 := Zeiger1;
end.

Dieses Beispiel müsste doch zu einer zyklischen Abhängigkeit führen oder ?
Also Zeiger1 zeigt auf Zeiger2 und umgekehrt.

Den Inhalt, also das Ziel einer Zeigervariablen bekommt man ja z.B. mit Zeiger1^ bzw. Zeiger2^ .

oder verstehe ich da etwas falsch ?


Fragt mich nicht, warum ich mit Pascal programmiere :D ...

Gruss
RedGuy

[Schrompf]

Pascal ist bei mir extrem lange her, aber ich vermute mal, das Konzept ist wie bei allen anderen auch. Und damit machst Du eigentlich folgendes:

- Du legst zwei Zeiger an, die ins Nirgendwo zeigen.
- Dann kopierst Du Z2 in Z1, also Z1 zeigt dann auf die selbe Stelle wie Z2.
- Danach kopierst Du Z1 in Z2, also zeigt Z2 dann an die selbe Stelle wie Z1.

Beide zeigen vorher wie nachher ins Nirgendwo. Nix mit zyklischer Abhängigkeit.

Stell Dir Zeiger vor wie kleine Zettel, auf denen "Buch SoUndSo, Seite 314, fünfte Zeile, drittes Wort" steht. Eine Zeigerzuweisung "kopiert" den Zeiger, wie als ob jemand das, was auf dem einen Zettel steht, auf dem zweiten Zettel abschreibt. Danach steht auf beiden Zetteln das selbe. Und das Wort, was auf den beiden Zetteln eigentlich benannt wird, ist von all dem nicht betroffen.

[RedGuy]

Hi !

Ok !
Hab vergessen den Variablen etwas zu zuweisen.

Also entsteht hier eine zyklische Abhängigkeit:

Code: Alles auswählen

var

Zeiger1,Zeiger2 : ^integer; {dies sind zwei Zeigervariablen}

begin
Zeiger1^ = 5; {eine Kleinigkeit zuweisen}
Zeiger2^ = 6;

Zeiger1 := Zeiger2;
Zeiger2 := Zeiger1;
end.

Gruss
Red

[Schrompf]

Nein. Nix dergleichen. Ein Zeiger zeigt. Wortwörtlich. Anstatt einem Menschen, der mit seinem Zeigefinger auf einen einen Apfel auf dem Tisch zeigt, hast Du dann halt zwei Menschen, die jeweils mit ihrem Zeigefinger auf den selben Apfel zeigen. Du kannst auch fünf Leute nebeneinander stellen und auf den Apfel zeigen lassen - das interessiert den Apfel nicht.

Eine zyklische Abhängigkeit wäre, wenn der Apfel zurückzeigen würde. Du merkst schon am Typen, dass das nicht geht. Erfinde eine Struktur Bla, die einen ^Bla enthält, dann kannst Du zwei Instanzen davon anlegen und jeweils auf das Gegenüber zeigen lassen. Das wäre dann tatsächlich ne zyklische Abhängigkeit.

[Goderion]

Ich bin irritiert.

RedGuy, auf der einen Seite arbeitest Du an für mich krass kompliziert klingenden Sachen wie z.B. https://zfx.info/viewtopic.php?t=4123, auf der anderen Seite "scheinst" Du nicht die Funktionsweise von Zeigern verstanden zu haben.
Wie Schrompf schon sagt, ein Zeiger zeigt nur.
Ein integer-Zeiger kann nur auf einen integer zeigen. Ein integer-Zeiger kann nicht auf einen integer-Zeiger zeigen.
Ein integer-Zeiger-Zeiger kann auf einen integer-Zeiger zeigen.
Wenn ich einem integer-Zeiger einen integer-Zeiger zuweise, dann übernimmt der integer-Zeiger nur die Adresse, auf die der andere integer-Zeiger zeigt.

Vielleicht kann dir das weiterhelfen:
http://wiki.freepascal.org/Pointer/de
http://www2.informatik.uni-halle.de/leh ... s6ptr.html
https://www.google.de/#q=pascal+zeiger

PS: Deine Facebook-Aussage "Das ist MEIN Forum!!!" mit Verweis auf zfx.info könnte man falsch interpretieren und denken, dass das Forum dir gehört, dass du der Hoster bist. Gehört dir dieses Forum oder ist das nur unglücklich ausgedrückt? Und warum immer so viele Ausrufezeichen?

[RedGuy]

Hi !

also ich weiß schon was Zeiger sind. Nur kenne ich mich wohl mit der Syntax von Pascal noch nicht so aus :(, da ich gerade beim Aufrischen/Lernen bin.
Das bei facebook war wohl eher als Kommentar gedacht. Wohl etwas unglücklich ausgedrückt :( .

Gruss
RedGuy

[joggel]

Ich wollt schon sagen. Wir müssen uns da absprechen, nicht das das zu Widersprüchen kommt. Ich erzähle nämlich auch das ZFX *mein* Forum ist^^

[antisteo]

Hi !

Ok !
Hab vergessen den Variablen etwas zu zuweisen.

Also entsteht hier eine zyklische Abhängigkeit:

Code: Alles auswählen

var

Zeiger1,Zeiger2 : ^integer; {dies sind zwei Zeigervariablen}

begin
Zeiger1^ = 5; {eine Kleinigkeit zuweisen}
Zeiger2^ = 6;

Zeiger1 := Zeiger2;
Zeiger2 := Zeiger1;
end.

Gruss
Red

Hi !

also ich weiß schon was Zeiger sind. Nur kenne ich mich wohl mit der Syntax von Pascal noch nicht so aus :(, da ich gerade beim Aufrischen/Lernen bin.
Das bei facebook war wohl eher als Kommentar gedacht. Wohl etwas unglücklich ausgedrückt :( .

Gruss
RedGuy

Die beiden Quotes widersprechen sich. Du weißt definitiv nicht, was Zeiger sind.

Noch mal deinen Code zusammengefasst:
- du legst 2 Zeiger-Variablen an; deren Inhalt ist nicht initialisiert
- du vergleichst, ob Zeiger1 auf einen Integer zeigt, der auf den Wert 5 zeigt
- an dieser Stelle dürfte schon die erste Zugriffsverletzung passieren, da Zeiger1 irgendwo hin zeigt
- (es könnte aber auch sein, dass der Optimierer deinen sinnlosen Vergleich rauschmeißt, dann passiert natürlich nix)
- Auf derselben Zeile kommentierst du, dass du den Wert angeblich zuweisen willst ....

Ich gebe dir mal einen Beispiel-Code, der funktionieren würde:

Code: Alles auswählen

var
integer1, integer2: integer;
Zeiger1,Zeiger2 : ^integer; {dies sind zwei Zeigervariablen}

begin
integer1 := 5;
integer2 := 6;
Zeiger1 := @integer1;
Zeiger2 := @integer2;

// jetzt dein komischer Code
Zeiger1 := Zeiger2;
Zeiger2 := Zeiger1;
end.

Und jetzt die Antwort auf deine Frage: nein, es gibt keine zirkuläre Abhängigkeit. Die Anweisungen können genau in dieser Reihenfolge abgearbeitet werden. Zeiger2 und Zeiger1 zeigen anschließend beide auf integer2.

Die Frage, die übrig bleibt: Was willst du mit deinem Code überhaupt programmieren? (btw: in modernem objektorientiertem Pascal braucht man Zeiger nicht wirklich mehr, wenn man alles sauber programmiert hat)

[RedGuy]

Hi !

Wie gesagt: Ich weiß, was Zeiger sind.

Zeiger sind Variablen, die Speicheradressen beinhalten. Dies wird von der Programmiersprache so gehandhabt.

Jetzt noch einmal zu meinem -nun vollständigen- Code:

Code: Alles auswählen

var
Zeiger1,Zeiger2 : ^integer; {dies sind zwei Zeigervariablen}

begin
new (Zeiger1); {Zeigerkonstrukt generieren}
new (Zeiger2);
Zeiger1^ = 5; {eine Kleinigkeit zuweisen}
Zeiger2^ = 6;

Zeiger1 := Zeiger2;
Zeiger2 := Zeiger1;
end.

In diesem Beispiel ist am Ende folgendes:

Zeiger1 zeigt auf die Adresse von Zeiger2. Zeiger2 wiederrum zeigt auf die Adresse von Zeiger1.

Adressmäßig gesehen handelt es sich um einen Zyklus.
Dies liegt doch auf der Hand :idea: .

Also liegt pointer-mäßig ein Zyklus vor.

Was die verwendete Pascal-Variante jetzt daraus macht ist die andere Frage.
Es kann sein, dass diese keinen Compiler-Fehler bringt und zur Laufzeit nur einen Zyklus in den Sachverhalt durchgeht und dann einen "remnant" (garbage) Daten ausgibt.

Ich möchte nochmals betonen, dass man hier keinen @ - Operator benötigt, um die Pointer pointen zu lassen !!!

Gruss
RedGuy

[Schrompf]

Immernoch Quatsch. Aber ich gebe auf. Besser hinschreiben als oben kann ich es nicht mehr.

[dunc]

Wie gesagt: Ich weiß, was Zeiger sind.

Zeiger sind Variablen, die Speicheradressen beinhalten.

...aber nicht beliebige Speicheradressen. Das ist der Punkt, der Dir offenbar entgeht.

Wenn Du einen Zeiger deklarierst, legts Du explizit fest, auf welche "Art" von Speicheradresse er zeigen kann.

In Deinem Fall hast Du Zeiger deklariert, welche ausschließlich auf "integer" variablen Zeigen können. Ein solcher Zeiger kann nicht auf einen anderen Zeiger zeigen. Geht nicht. Punkt. Im Gegensatz zu z.B. C++ gibt es in Pascal keine "unbestimmten" (void) Zeiger, also solche, denen die Frage "auf was zum Geier kann ich eigentlich zeigen?" egal ist.

Was passiert also bei sowas hier, wenn nicht das von Dir erwartete "Zeiger auf Zeiger"?

Code: Alles auswählen

Zeiger1 := Zeiger2;

Anfangs enthält Zeiger1 die Memory-Adresse der Integer-Variablen (5), auf die er "zeigt". Analog enthält Zeiger2 die Memory-Adresse der Integer-Variablen (6), auf die er "zeigt".

Mit "Zeiger1 := Zeiger2;" wird nicht die Memory-Adresse von Zeiger 2 selbst nach Zeiger1 kopiert, sondern die Memory-Adresse, welche in Zeiger2 enthalten ist.

Somit enthält Zeiger1 jetzt die gleiche Memory-Adresse der Integer-Variablen (6), auf die Zeiger2 schon zeigt.

Oder nochmal anders ausgedrückt: Du sagst nicht "Zeiger 1, zeige bitte auf Zeiger 2", sondern "Zeiger 1, zeige bitte auf das, auf wasauchimmer Zeiger 2 gerade zeigt".

PS & O/T:
Ist mein erster Post, daher erstmal ein freundliches "Hallo" an alle! :)[/i]

[Alexander Kornrumpf]

Ich erinnere mich noch gut, dass eine der ersten Lektionen in einem der ersten Programmierbücher, auf die ich in meiner Jugend Zugriff hatte, darin bestand, dass (Pseudocode)

foo:=bar
bar:=foo

nicht den Inhalt der Variablen tauscht.

Zehre ich heute noch von :)

[CrystalCoder]

Simple as that:



Hier das Beispiel im online Compiler: http://rextester.com/REO61636

Edit: Dass nichts zylkisch ist, ergibt sich hoffentlich aus dem Kontext.

[Schrompf]

Wow, sogar mit Illustrationen. Danke für Deine Arbeit! Vielleicht kommt die Nachricht jetzt an.

[Zudomon]

Das Thema habe ich damals irgendwie übersehen, aber dank Spambot ist es ja jetzt wieder hoch gekommen.
Bin zwar mit Delphi unterwegs, aber da es ja auf Pascal basiert, sollte es in dem Punkt gleich sein.

Eigentlich wurde auch schon alles gesagt, aber um mal wirklich eine zirkulare Referenz zu erzeugen:

Code: Alles auswählen

var
  Zeiger1, Zeiger2: Pointer;

begin
  Zeiger1:=@Zeiger2;
  Zeiger2:=@Zeiger1;
end;

Das sollte erwähnte zirkulare Referenz erzeugen. Allerdings bricht da wohl leider nicht gerade die Raumzeit zusammen, wenn man nun anfängt das zu dereferenzieren. Zeiger sind ja wie schon erwähnt einfach Adressen... soweit ich weiß DWord bei 32-Bit Systemen... nun hat ein dereferenzieren nur zur Folge, statt den Inhalt der Zeigervariable auszugeben, der Inhalt der Adresse auf dem der Zeiger zeigt auszugeben wird...

Also in den Zeigern stehen hier nun jeweils die Adresse des anderen Zeigers. Gibt man den Inhalt von Zeiger1 durch dereferenzieren aus, erhält man also den Wert, der in Zeiger2 gespeichert ist... in dem Fall die Adresse von Zeiger1... interessanter ist es, wenn Zeiger2 nun auf einen echten Wert zeigt... da würde man dann beim dereferenzieren von Zeiger1 die Speicheradresse von dem Wert bekommen. Um an den Wert selbst zu kommen, müsste man also doppelt dereferenzieren.

Beim dereferenzieren von zirkular abhängigen Pointer erhält man eben das Ergebnis, je nachdem, wie oft man dereferenziert. Und zwar bei einer ungeraden Anzahl an Dereferenzierungen die eigene Adresse der Zeigervariable und bei geraden die Adresse der anderen Zeigervariable.

Naja, für StoneQuest habe ich sowas aber bisher nicht gebraucht. Antisteo hat es ja schon gesagt, die ganze Pointer Geschichte ist in Delphi sowieso recht gut verborgen, so dass man sich darum kaum Gedanken machen muss.
Aber wenn man einen eigenen Computer baut, ist das sicher interessant. Da könnte man ja einbauen, dass da Platinen durchbrennen, wenn man anfängt zirkular abhängige Pointer zu programmieren :lol: