PureBoard
https://www.purebasic.fr/german/

Unterschied: *p.s vs *p\String vs v\s vs v\String
https://www.purebasic.fr/german/viewtopic.php?f=9&t=24318
Seite 1 von 2

Autor:  DrShrek [ 20.05.2011 11:52 ]
Betreff des Beitrags:  Unterschied: *p.s vs *p\String vs v\s vs v\String

Mag das jemand von unseren PureBasic Gurus genauer erklären?
Code:
Debug  "defines variables"
Define *ps.s
Define *pString.String
Define vS.s
Define vString.String

Debug "Show values"
Debug *p
Debug *pString
Debug vS
Debug vString

Debug "Show adresses"
Debug @*p
Debug @*pString
Debug @vS
Debug @vString


Output:
Code:
defines variables
Show values
0
0

4393932
Show adresses
4393936
4393924
0
4393932

Autor:  ts-soft [ 20.05.2011 11:58 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

DrShrek hat geschrieben:
Mag das jemand von unseren PureBasic Gurus genauer erklären?
ganz einfach:
Code:
; defines variables
Define *ps.s ; undefinierte Syntax
Define *pString.String ; strukturierter Pointer
Define vS.s ; String
Define vString.String ; strukturierter Typ

Autor:  DrShrek [ 20.05.2011 11:59 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

Danke.
Für den 1ten Fall wünsche ich mir von PureBasic eine Fehlermeldung beim Compilieren.
Und für den 3ten Fall einen Hinweis in der Onlinehilfe (bzgl: Pointer Adresse ist Null wenn die Variable nur deklariert wurde)

Autor:  STARGÅTE [ 20.05.2011 12:03 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

Was willst du da für eine Erklärung ?
*ps.s ist ein Pointer (Typ egal), und wenn dieser kein Wert hat, ist er NULL.
Seine Adresse @*ps gibt an, wo dieser Pointer gespeichert wird.

*pString.String ist ebenfalls ein Pointer (Typ egal), analo zu oben.

vS.s ist ein String, sein Inhalt ist am Anfang immer Leer "" und seine Adresse ist noch unbestimmt (NULL)

vString.String ist eine Struktur-Variable mit der Struktur: s.String.
Sie kann selber kein Inhalt haben, sodass vString = @vString ist ...
Dabei wird die Speicheradresse der Variablen zurück gegeben, die gereits definiert ist.

BTW: vString\s wäre wieder "" und @vString\s wäre Null

Autor:  ts-soft [ 20.05.2011 12:08 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

DrShrek hat geschrieben:
Für den 1ten Fall wünsche ich mir von PureBasic eine Fehlermeldung beim Compilieren.

Warum, solange Du weißt, was der Compiler draus macht, kannste Du es doch verwenden, auch wenn die Syntax nicht
festgelegt wurde, auf eigene Gefahr eben. In der Hilfe steht nirgends geschrieben, das dies eine gültige Syntax wäre,
da sie ja auch ziemlich unlogisch ist.
Ansonsten nutze diese Syntax nicht, weil man draus ja sowieso nicht erkennen kann, was es sein soll.
Vorne Hui (Pointer) und hinten Pfui (String) :lol:

Autor:  bobobo [ 20.05.2011 12:25 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

darf ich das auch gleich sperren ? :mrgreen:

Autor:  helpy [ 20.05.2011 12:36 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

Hallo,

Von mir etwas ausführlicher ... und hoffentlich verständlich und so halbwegs fehlerfrei!

1. *VariablenName.s
Das ist etwas, was man so in PureBasic nicht verwenden sollte!
Nie! Niemals! ... auch nicht mit anderen Datentypen!

In der Doku von PureBasic steht folgendes:
PureBasic Hilfe hat geschrieben:
Das Verwenden von Pointern (Zeigern) ist möglich, indem Sie einen * vor den Variablen-Namen schreiben. Ein Zeiger ist eine Variable, welche eine Speicheradresse beinhaltet und generell mit einer Struktur verknüpft wird.
==> siehe: http://www.purebasic.com/german/documen ... emory.html

==> D.h. Dein Beispiel ist nicht repräsentativ, weil *VariablenName.s nicht verwendet werden soll!

.s ist keine Struktur, sondern ein Basis-Datentyp!


2. [VariablenName.s]
Das ist eine String-Variable! Mit @ kann man die Adresse des Speicherbereichs herausfinden!
Wenn @VariablenName Null ist, dann wurde der String noch nicht initialisiert, also noch kein Speicherbereich zugewiesen. In diesem Fall wird der Inhalt der String-Variablen von PureBasic als Leer-String interpretiert.
Ist @VariablenName ungleich Null, dann beginnt an der angegebenen Adresse der String!

PureBasic-Strings sind Null-terminiert, d.h. Jeder String endet mit einem Chr(0)

Abhängig vom gewählten Compiler-Modus (Unicode oder nicht Unicode), werden Strings als ASCII (1 Byte je Zeichen) oder Unicode (2 Byte je Zeichen) verarbeitet!

Noch ein Hinweis:
von mir hat geschrieben:
In PureBasic gibt es nichts, was mit dem "ByRef VariablenName As String" in Visual Basic vergleichbar ist!

Ja! Man kann String-Pointer an PureBasic Proceduren übergeben (@VariablenName)!
Ja! Man kann in solchen Proceduren diese Strings auf verschiedene Weise auslesen!
Ja! Man kann in solchen Proceduren diese Strings z.B. mit PokeS verändern, aber nur unter der Bedingung, dass der String nicht länger wird als der Original-String!
Nein! Man kann in solchen Proceduren diese Strings nicht wie normale String-Variablen behandeln/verwenden.
Nein! Man kann in solchen Proceduren auch die Standard PureBasic String-Funktionen nicht für diese Strings verwenden (nur unter Einschränkungen und mit dem Bewusstsein, dass man damit das interne String-Management durcheinander bringen könnte)!

Der einzige Weg PureBasic Strings ByRef an Prozeduren zu übergeben, ist innerhalb von Strukturen. Siehe Beispiel:
Code:
Procedure AppendString( *First.String, *Second.String )
   *First\s + *Second\s
EndProcedure
Procedure ClearString( *aString.String )
   *aString\s = ""
EndProcedure

First.String
Second.String

First\s = "Hello"
Debug First\s

Second\s = ", this was appended to the orignial string without any problems :-)"
AppendString( First, Second )
Debug First\s

Second\s = #CRLF$ + #CRLF$ + "Und noch mehr" + RSet("",1024,"-")
AppendString( First, Second )
Debug First\s

ClearString( First )
Debug #DQUOTE$ + First\s +#DQUOTE$
... also doch was vergleichbares zu ByRef ;-)



3. VariablenName.String
Hier wird eine Struktur-Variable definiert, mit folgender Struktur (bereits in PB vordefiniert):
Code:
Structure String
   s.s
EndStructure
Dabei ist zu Beachten, dass die Größe der Struktur SizeOf(String) in diesem Fall der Größe eines Integers entspricht, weil Innerhalb der Struktur nur der Zeiger auf den Speicherbereich abgelegt wird!

Wird solch eine Struktur-Variable an eine Funktion oder Procedure übergeben, wird immer nur die Basisadresse der Struktur übergeben. D.h. In diesem Fall ist VariablenName identisch mit @VariablenName.

Beispiel:
Code:
Define VariablenName.String

Debug VariablenName        ; gibt die Basis-Adresse der Struktur aus!
Debug @VariablenName       ; gibt die Basis-Adresse der Struktur aus!
Debug VariablenName\s      ; gibt den Inhalt des Strings aus (noch leer)!
Debug @VariablenName\s     ; gibt die Adresse des Strings aus. Null, weil noch leer!
Debug PeekI(@VariablenName); gibt ebenfalls die Adresse des Strings aus! Null, weil noch leer!

VariablenName\s = "Hallo"

Debug VariablenName        ; gibt die Basis-Adresse der Struktur aus!
Debug @VariablenName       ; gibt die Basis-Adresse der Struktur aus!
Debug VariablenName\s      ; gibt den Inhalt des Strings aus!
Debug @VariablenName\s     ; gibt die Adresse des Strings aus.
Debug PeekI(@VariablenName); gibt ebenfalls die Adresse des Strings aus!


4. *VariablenName.String
Pointer auf eine Struktur-Variable!

Hinweis: Die Struktur-Variable existiert damit noch nicht! Diese muss erst angelegt werden! Das kann auf unterschiedliche Art und Weise geschehen! Beispiel:
Code:
Define VariablenName.String
Define *pVariablenName.String

*pVariablenName = @VariablenName

Debug VariablenName           ; gibt die Basis-Adresse der Struktur aus!
Debug *pVariablenName         ; gibt den Inhalt der Pointer-Variablen aus!
                              ; und damit die Adresse der Struktur-Variablen!
Debug @*pVariablenName        ; gibt die Adresse der Pointer-Variablen aus!
Debug *pVariablenName\s       ; gibt den Inhalt des Strings aus (noch leer)!
Debug @*pVariablenName\s      ; gibt die Adresse des Strings aus. Null, weil noch leer!
Debug PeekI(*pVariablenName)  ; gibt ebenfalls die Adresse des Strings aus! Null, weil noch leer!
Debug PeekI(@*pVariablenName) ; gibt den Inhalt der Pointer-Variablen aus
Debug ""

*pVariablenName\s = "Hallo"

Debug VariablenName           ; gibt die Basis-Adresse der Struktur aus!
Debug *pVariablenName         ; gibt den Inhalt der Pointer-Variablen aus!
                              ; und damit die Adresse der Struktur-Variablen!
Debug @*pVariablenName        ; gibt die Adresse der Pointer-Variablen aus!
Debug *pVariablenName\s       ; gibt den Inhalt des Strings aus!
Debug @*pVariablenName\s      ; gibt die Adresse des Strings aus.
Debug PeekI(*pVariablenName)  ; gibt ebenfalls die Adresse des Strings aus!
Debug PeekI(@*pVariablenName) ; gibt den Inhalt der Pointer-Variablen aus
Damit kann ich über den Pointer auf die Struktur-Variable zugreifen und zwar mit derselben Syntax, wie bei der Struktur-Variablen selbst (also mit ...\s).

Ich hoffe, das reicht erst mal!
Damit hast Du mal genug Stoff, um ein wenig zu testen und zu grübeln ;-)

lg,
guido

Autor:  ts-soft [ 20.05.2011 12:49 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

bobobo hat geschrieben:
darf ich das auch gleich sperren ? :mrgreen:

Ja, direkt vor diesem Beitrag und dann auf Wichtig setzen, so das guidos Beitrag erhalten bleibt.
Oder den in die FAQ setzen. Mir egal, irgendwas damit machen, das es jeder findet!

Autor:  DrShrek [ 20.05.2011 13:02 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

ts-soft hat geschrieben:
bobobo hat geschrieben:
darf ich das auch gleich sperren ? :mrgreen:

Ja, direkt vor diesem Beitrag und dann auf Wichtig setzen, so das guidos Beitrag erhalten bleibt.
Oder den in die FAQ setzen. Mir egal, irgendwas damit machen, das es jeder findet!

Ja bitte sperren. Oder noch besser: Am besten nur die Antwort von Guido aufheben und alles andere hier löschen.

Autor:  NicTheQuick [ 20.05.2011 14:49 ]
Betreff des Beitrags:  Re: Unterschied: *p.s vs *p\String vs v\s vs v\String

Ist noch niemandem aufgefallen, dass der allererste Code hier im Thread einen Fehler hat? >:)
Code:
Define *ps.s
...
Debug *p

Seite 1 von 2 Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
http://www.phpbb.com/