PRIVATE (UDT)

FreeBASIC-Referenz » Alphabetische Befehlsreferenz » P » PRIVATE (UDT)

Syntax:

TYPE TypeName
   PRIVATE:
   ' Deklaration privater Records

   PUBLIC:
   ' Deklaration öffentlicher Records
END TYPE

Typ: Schlüsselwort
Kategorie: Programmorganisation

Dieses Schlüsselwort ist in dieser Form nur dann zulässig, wenn mit der Kommandozeilenoption

-lang fb

kompilliert wird; siehe FB-Dialektformen.

Legt fest, dass folgende UDT-Records PRIVATE sein sollen, d.h. dass ein Zugriff nur von TYPE-eigenen Prozeduren aus zulässig sein soll.

Seit mit FreeBASIC v0.17 die objektorientierte Programmierung möglich ist, existiert die Möglichkeit, den Zugriff auf UDT-Records (siehe TYPE (UDT)) einzuschränken. Der Zweck liegt darin, dass der Zugriff auf den entsprechenden Record nur noch über userdefinierte Prozeduren ermöglicht wird, die eventuelle Fehler schon beim Zugriffsversuch abfangen, den Wert in ein besser verwertbares Format umwandeln, etc.

Der Type wird dazu regulär definiert.
Innerhalb der Typen-Deklaration wird die Zeile

PRIVATE:

eingefügt, sobald ein Record private sein soll, d.h. wenn der Zugriff darauf eingeschränkt werden soll. PRIVATE gilt innerhalb des TYPEs so lange, bis es durch ein PUBLIC-Schlüsselwort abgelöst wird.
Standardmäßig sind alle Records PUBLIC. Dies ist auch dann der Fall, wenn eine vorhergehende Typendeklaration mit PRIVATE abgeschlossen wurde.

Auf PUBLIC-Records kann aus jeder Programmsituation zugegriffen werden; auf PRIVATE-Records dürfen nur TYPE-eigene Prozeduren (SUBs, FUNCTIONs, PROPERTYs, OPERATORs, Klassen-Konstruktoren und Klassen-Destruktoren) zugreifen.
Beachten Sie, dass auch die Prozeduren eines TYPEs PRIVATE oder PUBLIC sein können.
Ein Zugriff auf einen privaten Record von außerhalb einer TYPE-eigenen Prozedur führt zu der Compiler-Fehlermeldung

Illegal member access

Als generelle Merkregel kann dienen: Auf private Records kann nur über das THIS-Schlüsselwort zugegriffen werden.


Es ist erlaubt, innerhalb eines TYPEs beliebig viele PRIVATE- und PUBLIC-Blöcke einzurichten.

Beispiel:

Type SecureIntArray
   Private:
   _ubound As Integer
   _lbound As Integer
   _data   As Integer Ptr

   Public:
   Declare Property datas (index As Integer ) As Integer
   Declare Property datas (index As Integer, new_value As Integer)

   Declare Sub Redim (low As Integer, up As Integer)

   Declare Constructor ()
   Declare Destructor  ()
End Type

Constructor SecureIntArray()
   With This
      ._ubound = 0
      ._lbound = 0
      ._data   = Allocate(4)
   End With
End Constructor

Destructor SecureIntArray()
   DeAllocate This._data
End Destructor

Property SecureIntArray.datas (index As Integer) As Integer
   With This
      If (index < ._lbound) Or (index > ._ubound) Then Return 0

      Return ._data[index - ._lbound]
   End With
End Property

Property SecureIntArray.datas (index As Integer, new_value As Integer)
   With This
      If (index < ._lbound) Or (index > ._ubound) Then Return

      ._data[index - ._lbound] = new_value
   End With
End Property

Sub SecureIntArray.Redim (low As Integer, up As Integer)
   If low > up Then Return

   With This
      DeAllocate ._data

      ._ubound = up
      ._lbound = low
      ._data   = Allocate( (up - low + 1) * 4 )

   End With
End Sub

Dim As SecureIntArray mySecInt
Dim As Integer i

mySecInt.Redim 0, 20             ' Wir erstellen ein Array mit den Indizes 0 bis 20...
For i = 0 To 24                  ' und versuchen, bis zum Index 24 werte einzufügen.
   mySecInt.datas(i) = 2 * i     ' Die Property wird diesen Versuch abblocken.
Next

For i = 0 To 24                  ' Genauso, wie auch die abfrage von Werten außer der Array-Dimensionen fehlschlägt.
   Print i, mySecInt.datas(i)
Next

Sleep

'Print mySecInt._data            ' Der Pointer ist nicht verfügbar, da es sich um ein PRIVATE-Feld handelt.

Unterschiede zu QuickBASIC und VisualBASIC:

Unterschiede zu älteren FreeBASIC-Versionen:

Siehe auch:
PRIVATE, PUBLIC (UDT), PROTECTED, TYPE (UDT), THIS, SUB, FUNCTION, PROPERTY, CONSTRUCTOR (Klassen), DESTRUCTOR (Klassen), EXTENDS