String Variable komplett löschen

[nalor]

Hallo!

Kann man irgendwie eine String Variable komplett löschen? So als hätte es sie nie gegeben?

Wenn man einfach versucht

Code: Alles auswählen

Test="Zeichenfolge"

zu verwenden gibts klarerweise eine Fehlermeldung weil Test kein String ist.

Wenn man aber 1x

Code: Alles auswählen

Test.s="Zeichenfolge"

verwendet hat dann ist und bleibt die Variable "Test" ein String...

Ich hätte sie gerne wieder komplett gelöscht!

Aber wenn ich z.B. Versuche einfach

Test.i=0

zu machen dann erhalte ich nur die Meldung, dass die Variable schon mit einem anderen Typ deklariert ist...

Wie kann man Test.s komplett aus dem Speicher tilgen?

[Kaeru Gaman]

die Namen werden zur Compilezeit in pointer übersetzt, zur Laufzeit sind sie garnicht vorhanden.
was nicht existiert, kann man auch nicht tilgen.

den Speicher den ein String verwendet hat kannst du wieder freigeben, indem du ihm den Wert "" zuweist.

identische Variablennamen für unterschiedliche Variablen kannst du nur in unterschiedlichen Scopes verwenden, also in verschiedenen Procedures zum Beispiel.

ansonsten dient der Variablenname dazu, den Speicherort für dich, den Programmierer, eindeutig zu bezeichnen, damit du weißt wofür der da ist.
einen Variablennamen für zwei Variablen unterschiedlichen Typs im selben Scope zu verwenden ergibt nicht den geringsten Sinn.

also, nenne sie zu Beginn TestString.s, und beim nächsten mal TestInteger.i, dann funktioniert das.

[dysti]

nalor, irgendwie sehe ich hier kein Sinn.
Erst erstellst du eine Variable Test vom Typ als "String", dann die Gleiche als "Zahl".

Kann es sein, das du Werte aus ein Stringgadget auslesen willst und damit weiterrechnen?

Vielleicht helfen dir diese Beispiele aus der Hilfe von PB:

Code: Alles auswählen

c$ = "Test"
a$ = Left(c$,1)
a$ = Mid(c$,3, 1)

a.l = Val("-121212")

MessageRequester("PureBasic", "Welcome: "+Mid(Str(a),2,3)+" "+a$, 0)

Code: Alles auswählen

value.q = 100000000000000001
  Debug "Ergebnis: " + Str(value)

....und ein komplettes Beispiel:

Code: Alles auswählen

If OpenWindow(0, 0, 0, 322, 205, "StringGadget Flags", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
    StringGadget(0, 8,  10, 306, 20, "40")
    StringGadget(1, 8,  35, 306, 20, "10", #PB_String_Numeric)
    StringGadget(2, 8,  60, 306, 20, "", #PB_String_Numeric)

    
    test.i=Val(GetGadgetText(0)) + Val(GetGadgetText(1))
    
    SetGadgetText(2,Str(test))
    
    Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow
  EndIf

[nalor]

Nein - mir geht es um etwas ganz anderes - im Posting http://forums.purebasic.com/german/view ... p?p=247032

Findet man folgendes Beispiel:

Code: Alles auswählen

Text.s = "Ein String ..."
*Text = @Text
*pText.String = @*Text

Debug "Text.s und *pText\s verweisen auf denselben Speicherbereich!"
Debug "*pText\s = " + *pText\s
Debug "Adresse Text:     >"+Str(@Text)+"<"
Debug "Adresse *pText:   >"+Str(@*pText)+"<"
Debug "Adresse *pText\s: >"+Str(@*pText\s)+"<"
Debug "Text = " + Text
Debug ""

*pText\s = "Ein viel längerer String ..." + Space(1000)

Debug "Da *pText\s mit einem neuen Text belegt wurde und ein neuer"
Debug "Speicherbereich für den String angelegt wurde, wird der alte"
Debug "Speicherbereich freigegeben!"
Debug "Die String-Variable Text verweist jedoch immer noch auf den"
Debug "alten (nicht mehr gültigen) Speicherbereich."
Debug "*pText\s = " + *pText\s
Debug "Adresse Text:     >"+Str(@Text)+"<"
Debug "Adresse *pText:   >"+Str(@*pText)+"<"
Debug "Adresse *pText\s: >"+Str(@*pText\s)+"<"
Debug "Text = " + Text
Debug ""


Debug "Einige String-Variablen beschreiben, damit die String-Verwaltung"
Debug "etwas zu tun hat ..."
For i = 1 To 1000
  Text1.s = "Text 1" + Space(i)
  Text2.s = "Text 2" + Space(i)
  Text3.s = "Text 3" + Space(i)
  Text4.s = "Text 4" + Space(i)
  Text5.s = "Text 5" + Space(i)
  Text6.s = "Text 6" + Space(i)
  Text7.s = "Text 7" + Space(i)
  Text8.s = "Text 8" + Space(i)
Next i
Text9.s = "... ein neuer String ..."
Debug "Wenn die String-Verwaltung den freigegebenen Speicherbereich"
Debug "anderweitig belegt, dann verweist Text auf einen Speicher-"
Debug "bereich, der nicht mehr sicher ist!"
Debug "*pText\s = " + *pText\s
Debug "Adresse Text:     >"+Str(@Text)+"<"
Debug "Adresse *pText:   >"+Str(@*pText)+"<"
Debug "Adresse *pText\s: >"+Str(@*pText\s)+"<"
Debug "Text = " + Text
Debug ""

Am Ende ist die Variable "Text" eine Leiche die man zu nichts mehr verwenden kann - deswegen hätte es mich interessiert ob man sie nicht irgendwie komplett löschen kann um sie dann neu anzulegen und ihr erneut den Text in "*pText\s" zuweisen kann.

Dass es nicht möglich ist den Pointer in "Text" auf die geänderte Adresse zu aktualisieren habe ich schon irgendwo gelesen, daher habe ich diesen Ansatz nicht weiter verfolgt.

Ich dachte mir nur wenn man "Text" quasi zu einem Integer umwandeln kann, dann kann man sie bestimmt danach auch wieder in einen String wandeln und der wird dann bestimmt neu angelegt und man kann ihn auch wieder zu etwas verwenden

[Kaeru Gaman]

die Problematik war höchstens ein Bug-Report, dass der Stringhändler dafür sorgen muss, die alten Stringvariablen wieder freizugeben oder mit umzubiegen,
oder aber ein grundsätzlicher Hinweis, dass man solchen Unsinn eben unterlassen soll um keine Speicherlecks zu produzieren.

wenn du als Programmierer sowas verzapfst, darfst du eben den alten Namen nicht mehr verwenden.
es besteht auch gar kein Grund dazu das zu versuchen, weil der herumliegende pointer nur 4 oder 8 byte belegt, und für einen Prozess nur 16KB-weise oder so Speicher angefordert wird.

[STARGÅTE]

Abgeleitet aus dem Ergebnis von hier:
String ByReference an Procedure übergeben

Gibt es diese Variante einen String wirklich wieder zu entfernen:

Code: Alles auswählen

Test.String

Debug @Test\s ; Noch Null, String existiert noch nciht

Test\s = "Hallo"

Debug @Test\s ; Irgendwo ist ein String

Test\s = ""

Debug @Test\s ; der String ist immer noch da, nur halt sehr klein ^^

ClearStructure(@Test, String)

Debug @Test\s ; wieder Null, also komplett weg

[mk-soft]

Das mischen von Variablentypen fürt irgendwann immer bei falscher Anwendung zu fehlern und Speicherlecks.
Wenn der Type der Variable erst zur Laufzeit bekannt ist, verwende die Strukturvariable Variant (Windows Only)

Code: Alles auswählen

;- Type Conversion Helper

; ***************************************************************************************

;-T_BSTR
Procedure helpSysAllocString(*Value)
  ProcedureReturn SysAllocString_(*Value)
EndProcedure
Prototype.l ProtoSysAllocString(Value.p-unicode)

Global T_BSTR.ProtoSysAllocString = @helpSysAllocString()

; ***************************************************************************************

Global var1.VARIANT

; Verwendung als Text
var1\vt = #VT_BSTR
var1\bstrVal = T_BSTR("Hallo Welt")

Debug PeekS(var1\bstrVal, #PB_Any, #PB_Unicode)

; Verwendung als Zahl

; Vorher Speicher freigeben (Long)
VariantClear_(var1)

var1\vt =#VT_I4
var1\lVal = 1001
Debug var1\lVal

Mit VariantHelper_Include http://www.purebasic.fr/english/viewtop ... 14&t=40150

Code: Alles auswählen

IncludeFile ".\funktionen\VariantHelper_Include.pb"

Global var1.VARIANT
Global var2.VARIANT

V_STR(var1) = t_bstr("Hallo Welt")
V_FLOAT(var2) = 100.5

Debug "Text: " + vt_str(var1)
Debug "Zahl: " + vt_str(var2) ; Typewandlung automatisch

[Little John]

Abgeleitet aus dem Ergebnis von hier:
String ByReference an Procedure übergeben

Gibt es diese Variante einen String wirklich wieder zu entfernen:

Eine andere Möglichkeit -- die Kaeru Gaman schon erwähnt hat -- ist, eine Variable zu benutzen die nur innerhalb einer Prozedur gültig ist. Nach Ende der Prozedur existiert sie dann ja auch nicht mehr:

Code: Alles auswählen

Procedure Temp ()
   Protected Test$

   Debug "-- Prozedurbeginn"
   Debug @Test$
   Test$ = "Hallo"
   Debug @Test$     ; Irgendwo ist ein String
   Debug "-- Prozedurende"
EndProcedure


Temp()
Debug @Test$
Temp()
Debug @Test$

Gruß, Little John