Pointer dereferenzieren

[Josef Sniatecki]

Ich selbst habe nichts dagegen, dass nur ein einziges Sternchen für Zeigernamen möglich ist. Nur das diese für Member einer Struktur ignoriert werden ist natürlich... unsystematisch

Würde zwar eine gigantische Umgewöhnung sein, aber ich bin eher ein Fan davon, dass ein Sternchen nur bei der Deklaration einer Variable benutzt wird und danach der Compiler selbst zwischen einem Pointer und einer normalen Variable unterscheidet, ohne ständig ein Sternchen bei der Verwendung anzuhängen.
In C setzt man ja nur eines, um auf den Inhalt der Adresse eines Zeigers zuzugreifen.

Würde also folgendermaßen aussehen:

Code: Alles auswählen

Define Number.i = 42
Define *Pointer.Integer = @Number

Debug Pointer\i ;= 42
; oder noch besser (was ich in Operno erlaubt habe)
Debug Pointer\ ;= 42 - weil nur ein Member vorhanden ist

Aber wie gesagt: Eine solche Änderung wäre wirklich gewöhnungsbedürftig.

[PMV]

Das war auch für mich am anfang unverständlich, warum einerseits:

Code: Alles auswählen

*Test = 1
Test = 2

Bei Structuren aber das * "einfach weggelassen wird" und es somit nicht möglich ist:

Code: Alles auswählen

Structure Uii
 *Test
 Test.i
EndStructure

Vermutlich wegen der Lesbarkeit. Ich zumindest find es so am praktischsten,
letzten endes ist es aber wohl ne einfache Meinungsfrage und damit obliegt es
der Entscheidung des Entwicklers (Fred), was er uns präsentiert.

Wichtig ist nur, das man bedenken muss, das ein Zeiger bei der definition
immer nur den Speicher für den Zeiger reserviert, aber nicht für die dahinter
liegende Struktur.

Code: Alles auswählen

Structure MeineStructure
  Quad.q
  Long.l
  Word.w
  Byte.b
EndStructure
Structure PointerTest
 *pTest.MeineStructure
EndStructure

Structure ValueTest
 Test.MeineStructure
EndStructure

Debug SizeOf(PointerTest)
Debug SizeOf(ValueTest)

wegen den *** ... , jo wäre schön,
Aber derzeit kann man sich ja auch mit __ zufrieden geben:

Code: Alles auswählen

Define *Pointer.Integer = @Integer
Define *_Pointer.AllTypes = @*Pointer
Define *__Pointer.AllTypes = @*_Pointer

Es geht vermutlich nicht, weil das * genauso wir das $ bei Strings nichtim eigentlichen Sinne zum Variablennamen gehört, also kein zugelassenes Zeichen ist wie zb der Unterstrich.

Das * ist in C im prinzip ein extra Datentyp, nur behandelt C diesen so wie
PB Strukturen. Gibt man bei der Variablendefinition in C zusätzlich ein * an,
referenziert C gleich zwei Speicherblöcke, ein mal den Zeigern und ein mal
die tatsächlichen Daten, wobei der Zeiger natürlich auf die Speicheradresse
der Daten verweist. Während man in C somit einfach

Code: Alles auswählen

int *width
*width = 34

schreiben kann, muss man in PB

Code: Alles auswählen

*width.INTEGER = AllocateMemory(Sizeof(Integer))
*width\i = 34

schreiben. Das * bei PB ist somit eher ein einfacher Datentyp wie .i oder .s.
Eine Variable kann immer nur einen einfachen Datentyp haben, deswegen
ist ein *Variable.i auch nach wie vor Quatsch und ein Zeiger kann auch nicht
gleichzeitig zu zwei unterschiedlichen Speicheradressen zeigen. Das *
hat in C eine Sonderrolle, während PB das * nur in verbindung mit komplexen
Datentypen (Strukturen) eine Sonderrolle zu spricht.

Der @-Operator kann ebenfalls nicht verdoppelt werden, weil dieser die
Adresse der dahinter stehenden Variable zurück gibt. Und eine
Speicheradresse selber hat meist keine weitere Adresse, aber selbst wenn,
so weis die Speicheradresse garantiert nicht, welche Zeiger auf sie verweisen.


Konnte mir irgend jemand folgen?


MFG PMV

[Marvin]

Während man in C somit einfach

Code: Alles auswählen

int *width
*width = 34

schreiben kann

Man kanns zumindest versuchen…

Erinnert mich an dieses Lied:
„Got a segfault—and you're to blame, darling, coding in C is a damn shame!“

EDIT: Und natürlich (wie konnte ich das vergessen) an: Pointer Fun with Binky

[DarkDragon]

Ich finde wie es in PB ist voll logisch...

Code: Alles auswählen

; Pointer
Define *pValue, *ppValue
; Value
Define Value.i = 100

; Adresse von Value
*pValue = @Value

; Adresse von Pointer auf Adresse von Value
*ppValue = @*pValue

Debug Value
Debug PeekI(*pValue)
Debug PeekI(PeekI(*ppValue))

Was ist denn das für ein gemischter Code-Stil? Da kann man ja gleich allen Religionen gleichzeitig zugehören . Statt dem doppelten p wär mir ein weiterer Stern lieber. Und so mag ich keinen Code haben wenn er bei manchen Variablennamen klein anfängt und bei anderen groß.

[mk-soft]

@DarkDragon

Au man,

Das ist doch nur ein Beispiel...
... p für Pointer und pp für pointer auf ein Pointer.

[inc.]

*pointer = Zeiger
**pointer = meist Zeiger auf ein Array an Zeigern

Code: Alles auswählen

Structure pArray
  *p[0]
EndStructure

*p.pArray

*p\p[x] = *Pointer_an_Stelle_x

[DarkDragon]

@DarkDragon

Au man,

Das ist doch nur ein Beispiel...
... p für Pointer und pp für pointer auf ein Pointer.

Ja klar, aber dennoch geht es hier um die Darstellung von Zeiger auf Zeiger auf Zeiger auf ... und deine Darstellung ist eben nicht einheitlich, desshalb würde ich es begrüßen, wenn man mehrere Sterne zulassen würde.

[es_91]

Ich hoffe, die Frage ist nicht zu absurd. Entschuldige mich für's Ausgraben recht alter Threads!

Ich glaube, im Text vor mir wurden strukturierte Typen nicht angesprochen. Gibt es denn eine Chance, strukturierte Daten aufzeigende Pointer ebenfalls zu dereferenzieren?

Wie like...

Code: Alles auswählen

structure stringShadow
  text. s
  memory. i
endStructure

procedure stringOut (*myString.stringShadow)

  debug *myString\ text
  debug peekS (*myString\ memory)
  
  ; /?/ meineZeichenfolge.stringShadow = *myString\ ; ?
  ; debug meineZeichenfolge\ text
  ; debug peekS (meineZeichenfolge\ memory)
endProcedure

newString. stringShadow
newString\ memory = @"Hallo, Welt!"
newString\ text = peeks (newString\ memory)

stringOut (newString)
; End.

Habe ich einen Denkfehler und geht's hier nur um die Form? Ist das vielleicht gar nicht notwendig?

In PureBasic lassen sich, glaube ich, Pointer wie Variablen handhaben. Aber in C gibt es doch auch einen dereferenzierenden Weg. Warum, wenn es keine Vorteile bringt, frag ich mich?

*Anfänger ^^..

[Nino]

Gibt es denn eine Chance, strukturierte Daten aufzeigende Pointer ebenfalls zu dereferenzieren?

Ich werde aus deinem gesamten Beitrag nicht ganz schlau, aber vielleicht suchst du sowas?

Code: Alles auswählen

Structure Person
   Name$
   Age.b
EndStructure

Define.Person Fred, *any

Fred\Name$ = "Fred"
Fred\Age = 25

*any = @Fred
Debug *any\Name$
Debug *any\Age

[es_91]

Code: Alles auswählen

*any = @Fred
Debug *any\Name$
Debug *any\Age

Hey!

Was Du da oben macht nennt man doch Referenzierung, oder irre ich?

Was ich suche währe das:

Code: Alles auswählen

Fred2 = peekStruct(*any)
debug Fred2\Name$
debug Fred2\Age

Geht das?

---------------

Mir fällt gerade mal so eine Lösung ein ... Makros.

Code: Alles auswählen

macro Fred2: *any: endMacro

Das wäre aber ja immernoch keine Dereferenzierung?