LANG: Memory Management in QuickBasic & Basic Compiler

Veralteter Haftungsausschluss für KB-Inhalte

Dieser Artikel wurde für Produkte geschrieben, für die Microsoft keinen Support mehr anbietet. Deshalb wird dieser Artikel im vorliegenden Zustand bereitgestellt und nicht mehr aktualisiert.

Zusammenfassung

Programmierer sollten verstehen, wie Microsoft QuickBasic und Microsoft Basic Compiler Speicher anordnen schreiben effizienter Programme Systemressourcen verwenden. QuickBasic Sprache bietet eine Vielzahl von Datentypen und modulare Codekonstrukte, mit denen Sie Daten verwalten und Code-Programme.

Weitere Informationen

Dieser Artikel behandelt die folgenden Themen:


  1. Verwaltung


    1. Modulare Programmierung
    2. Was wird auf Modulebene in einem Support-Modul
    3. ALLGEMEIN, ALLGEMEINE FREIGEGEBEN, FREIGEGEBEN, DIM FREIGEGEBENEN
  2. Datenmanagement


    1. $DYNAMIC und $STATIC metacommands
    2. Große arrays
Anhang A enthält ein Codebeispiel in diesem Artikel behandelten Themen veranschaulichen.


Anhang B erklärt die. MAP-Datei erstellt, wenn im Anhang A programmbeispiel verknüpft ist. Können Sie die LINK-Karte bestimmen, wie nahe jedes Modul nähert 64 KB Code und wie die. EXE-Programm statische Variablen abrufen auf 64 KB in der DGROUP.


Anhänge C und D beschreiben die Speicherzuordnung für Programme in die folgenden drei unterschiedlichen Umgebungen: QB. EXE-Editor eine kompilierte. EXE, das mit dem Laufzeitmodul und. EXE mit der eigenständigen-Option kompiliert.

Definitionen

"Module" bezeichnet eine einzelne Quelldatei mit grundlegenden Vorgehensweisen.


"Modulebenencode" bezeichnet die Anweisung innerhalb eines Moduls, die außerhalb einer SUB... END SUB FUNKTION... END FUNCTION oder DEF FN... Ende DEF Definitionsblock.


"Support-Modul" ist eine Quelldatei trennen das Hauptmodul, das zusätzliche SUB oder FUNCTION-Prozeduren enthält.

VERWALTUNG

Modulare Programmierung

Modulare Programmierung behandelt Programme in separate Module (z.B. separaten Quelldateien, SUB oder FUNCTION-Prozeduren) aufgeteilt. Gründe dafür sind die folgenden:


  1. Einmal haben Sie einem Codeblock als Modul geschrieben problemlos in zukünftigen Projekten integriert werden können.
  2. Debuggen ist einfacher. Probleme können schneller gefunden werden und können in einem bestimmten Bereich des Programms enthalten.
  3. Der Compiler (BC. (EXE) und die Umgebung (QB. (EXE) eine 64 KB Code Einschränkung pro Modul. Modulare Art der Programmierung können Sie Programme größer als 64 KB, da jedes Modul zwar ein Programm gehört kann bis zu 64 KB.
Wenn eine Anwendung groß ist, kann in mehrere Module aufteilen sein. Dies geschieht einfach SUB-Prozeduren oder Funktionen aus Hauptmoduls und Unterstützungsmodule versehen. Diese Module werden mit BC dann separat kompiliert werden. EXE und verknüpft mit Hauptmoduls wie im folgenden Beispiel.


Stellen Sie sich eine Programm Main.BAS, die in drei Module unterteilt:


  1. MAIN. BAS (die externe Prozeduren aufruft)
  2. "MODUL2". BAS (enthält SUB oder Funktion-Prozeduren)
  3. MODULE3. BAS (enthält SUB oder Funktion-Prozeduren)
Die drei Module sind jeweils separat erstellen die folgenden Objektdateien kompiliert:


  1. BC MAIN. BAS; ---> MAIN. OBJ
  2. BC MODUL2. BAS; ---> Modul2. OBJ
  3. BC MODULE3. BAS; ---> MODULE3. OBJ
Erstellt die ausführbare Datei (. (EXE) ausführen, die folgende Befehlszeile wird verwendet:
    LINK Main.OBJ+Module2.OBJ+Module3.OBJ; ---->  Main.EXE
Main.EXE ist das Programm beendet. Beim Kompilieren in QuickBasics-Umgebung (QB. (EXE), die Umgebung automatisch jedes Modul kompiliert und verknüpft zu diesem erzeugen. OBJ-Dateien und ausführbares Programm beendet.


Soll ein. Exe von QB. EXE Umgebung, gehen Sie folgendermaßen vor:


  1. Wählen Sie im Menü ausführen.
  2. Wählen Sie die Stellen EXE Datei... Option.
  3. Wählen Sie zum Erstellen einer eigenständigen Datei eigenständige EXE-Datei. Wenn diese Option nicht aktiviert ist, muss das Programm Laufzeitmodul BRUN4x.EXE zur Laufzeit vorhanden sein.
  4. Drücken Sie die EINGABETASTE.
QuickBasic-Umgebung bietet eine einfache Möglichkeit, die folgenden Vorgänge, die weiter unten beschrieben:


  1. Erstellen Sie ein neues Modul für Unterroutinen
  2. Unterroutinen und Module bearbeiten
  3. Unterroutinen löschen
  4. Unterroutinen von einem Modul in ein anderes Modul verschieben
In QB. EXE, ein getrenntes Modul (Quelldatei) für die Unterroutinen erstellen folgendermaßen vor:


  1. Wählen Sie im Menü Datei.
  2. Wählen Sie die Datei erstellen Option.
  3. Geben Sie den Namen des Moduls.
  4. Drücken Sie die EINGABETASTE.
Eine Datei wird dann erstellt mit dem Namen angegeben und werden im Arbeitsspeicher mit anderen Modul(e). Führen Sie folgende Schritte aus, um alle geladenen Module speichern:


  1. Wählen Sie im Menü Datei.
  2. Die Option Alle speichern.
Wenn die Module zusammen gespeichert werden, erstellt QuickBasic eine Datei (mit der Erweiterung. MAK) werden von nachverfolgt, die das Hauptmodul und anderen Modulen, die im Hauptfenster verwendet. Führen Sie folgende Schritte aus, um alle Module gleichzeitig zu laden:


  1. Wählen Sie im Menü Datei.
  2. Wählen Sie den Open... Option.
  3. Wählen Sie das Hauptmodul Programm wie die Datei geöffnet werden.
Anzeigen und SUBs zum Bearbeiten auswählen, führen Sie folgende Schritte aus:


  1. Wählen Sie im Menü Ansicht.
  2. Wählen Sie die SUBs... Option.
  3. Markieren Sie das Modul oder SUB, die Sie bearbeiten möchten.
  4. Zum Bearbeiten in aktive Registerkarte oder in Teilen bearbeiten.
  5. Drücken Sie die EINGABETASTE.
Gehen Sie wie folgt vor, um SUB zu löschen:


  1. Wählen Sie im Menü Ansicht.
  2. Wählen Sie die SUBs... Option.
  3. Markieren Sie die zu löschenden SUB.
  4. Registerkarte auf die Option löschen.
  5. Drücken Sie die EINGABETASTE.
Wenn SUB in ein anderes Modul verschieben möchten, führen Sie folgende Schritte aus:


  1. Wählen Sie im Menü Ansicht.
  2. Wählen Sie die SUBS... Option.
  3. Markieren Sie die zu verschiebende SUB.
  4. Registerkarte auf die Option zum Verschieben.
  5. Drücken Sie die EINGABETASTE.
  6. Wählen Sie das Modul SUB zu.
  7. Drücken Sie die EINGABETASTE.
Weitere Informationen zur Verwendung von QB. EXE Umgebung finden Sie im Handbuch "Microsoft QuickBasic: Lernen zu verwenden" Version 4.50, oder finden Sie im Handbuch "Microsoft QuickBasic 4.0: Lernen und verwenden" für Version 4.00 und 4.00b und die Version Basic Compiler 6,00 und 6.00b.

Was wird auf Modulebene in einem Support-Modul

Ein Support Modul kompiliert, erzeugt ein Objekt (. OBJ)-Datei, die mit Hauptmodul eine ausführbare Datei erstellen. Der Modulebene des Hauptmoduls der Code wird nur direkt vom QuickBasic ausgeführt. Die Modulebenencode Unterstützungsmodule nicht genannt, ausführen oder verkettete. Dieser Code auf Modulebene Module Support wird nur für verwendet:


  1. Ereignis oder Fehlerbehebung Handler
  2. Metacommands
  3. Typdefinitionen Sie, DIM und SHARED-Anweisung
Sie können einfügen auf Ereignis GOSUB und ON ERROR GOTO Trapping Anweisungen Teilprogramm Prozeduren [bedeutet ein Ereignis auf KEY(n), auf COM(n), TIMER(n) auf.]. Jedoch muss die Linie oder das Ziel der Ereignis- oder Traps GOTO oder GOSUB Zeilenmarke auf Modulebene Code im selben Modul wie dieses Teilprogramm sein. Dies ist QuickBasic nicht GOSUBs oder GOTOs von ein Unterprogramm an andere Module oder Unterprogramme zulassen und QuickBasic kann nur auf Ereignis GOSUB und ON ERROR GOTO Anweisungen ein Unterprogramm Modulebene Code zu springen.


Der Compiler Metacommands (REM $INCLUDE REM $STATIC und REM $DYNAMIC) kann auch auf Modulebene verwendet werden. REM $INCLUDE fügt zusätzliche in das Modul zur Kompilierzeit. REM $DYNAMIC und REM $STATIC deklarieren nachfolgende Arrays als $DYNAMIC (zur Laufzeit zugewiesen) oder $STATIC (zur Kompilierzeit zugewiesen).


Sie können... ENDTYP DIM und allgemeine SHARED Anweisungen im Code auf Modulebene. Variablen und Arrays können mit gemeinsamen FREIGEGEBENEN Anweisung auf Modulebene Module aufgeteilt werden.

Allgemein, allgemeine SHARED, SHARED und DIM freigegeben

SHARED-Anweisung gibt einen SUB oder FUNCTION-Prozedur Zugriff (ohne sie als Parameter) Ebene Hauptmodul Modul deklarierten Variablen. Es gibt nicht Zugriff auf Variablen, die in Unterstützungsmodule.


Gemeinsame Erklärung zur Verfügung Variablen auf Modulebene zwischen Modulen. SHARED-Attribut für die gemeinsame Erklärung (d. h. allgemeine freigegeben) muss die Variablen Unterprogramme oder Funktionen freigeben. Die Liste der Variablen in der allgemeinen und gemeinsamen FREIGEGEBENEN muss im gemeinsamen und gemeinsamen FREIGEGEBENEN Abschluss jedes Typs übereinstimmen.


Bei Verwendung der Anweisung gemeinsame (oder allgemeine SHARED) sind unterschiedlich, statische und dynamische Arrays nicht. Statische Arrays müssen gemeinsame dimensioniert vor COMMON Anweisung in allen Modulen dieser allgemeinen Aussage sein. Dynamische Arrays müssen gemeinsam dimensioniert nach COMMON Anweisung nur Hauptmoduls und sollten keine Unterstützungsmodule bemessen werden.


Es gibt zwei Unterschiede zwischen der SHARED-Anweisung und der Anweisung DIM freigegeben:


  1. Um eine Variable in einem Modul alle Unterprogramme zugänglich machen, verwenden Sie DIM SHARED auf Modulebene.
  2. Um eine Variable auf Modulebene mit bestimmten Teilprogramm freizugeben, legen Sie die Variable in einer SHARED-Anweisung das Unterprogramm. SHARED-Anweisung wird direkt nach der ersten Zeile das Unterprogramm.

DATENMANAGEMENT

$DYNAMIC und $STATIC-Arrays

Die Standardeinstellung für die Speicherung von Arrays ist REM-$STATIC, das alle Arrays in DGROUP (Datensegment Standard) speichert. Alle Basic. EXE-Programm DGROUP ist auf 64 KB beschränkt. Bei Verwendung von statischen Arrays erhalten mehr Speicher in DGROUP Sie mit Arrays dynamisch, die in den Heap verschoben. Um ein Array dynamisch zu gestalten, DIMension des Arrays nach metacommand REM $DYNAMIC oder der Array mit einer Variablen in der Index.


Alle dynamischen Arrays werden auf den Heap außer Arrays von Zeichenfolgen variabler Länge gespeichert. Zeichenfolgen variabler Länge Zeichenfolgenarrays und einfache Variablen werden immer in DGROUP gespeichert. Zum Speichern von Zeichenfolgen in den Heap müssen ein dynamisches Arrays von Zeichenfolgen fester Länge DIMension. Dimensionierung von Zeichenfolgen fester Länge in dynamische Arrays unterstützt, um Speicherplatz freizugeben, die sie sonst in DGROUP, hätte die ist auf 64 KB beschränkt.

Große Arrays

Große Arrays sind Arrays, die größer als 64 KB sind. Bei großen Arrays müssen Sie QB aufrufen. EXE-Editor und BC. EXE-Compiler mit der Option/AH. Das große Array muss als dynamisches Array, eine Variable in den Arrayfeldindex oder vorherigen metacommand REM $DYNAMIC auszulegen. Die Option/AH ermöglicht dynamische Arrays von benutzerdefinierten Typen, Zeichenfolgen fester Länge und numerische Daten aller verfügbaren Arbeitsspeicher belegen.


Die Anzahl der Bytes in einem einzigen Element eine sollte vorzugsweise eine Potenz von 2, damit verschwendet zu vermeiden und Arrays größer als 128 KB sein wie unten beschrieben.


Speicherplatz wird ein großes Array nacheinander in den Heap mit der Einschränkung, dass kein einzelnes Arrayelement (oder Datensatz) auf 64 KB-Grenze aufgeteilt werden reserviert. Wenn ein Datensatz eine Potenz von 2 steht, Array hoch gegenüber dem Array Basis Segmentadresse (zurückgegeben von der VARSEG-Funktion), versetzt zugeordnet, die Berandung exakt 64 k oberhalb der Basis Segment kein Arrayelement verteilt. Der Wert Statusblocks VARPTR für das erste Element des Arrays und gibt sowohl den Offset des Arrays sowie die Größe der Lücke in far-Heapspeicher. Diese Lücke Fragmente den Heap und vergeudet, nicht verwendeten Speicher. Die Größe des Zwischenraums ist gleich (65.536) MOD (Arraygröße Datensatz). [Im schlimmsten Fall kann der Abstand bis (Arraygröße Datensatz) minus 1 Größe werden.]


Ein "Index außerhalb des gültigen Bereichs" Fehler bei einer Vielzahl größer als 128 KB bei Arrayelemente Größe nicht sogar eine Potenz von 2. Arrays größer als 128K eine Elementgröße haben muss eine Potenz von 2 (2, 4, 8, 16, 32, 64, etc.), da Arrays zusammenhängend gespeichert und kein einzelnes Arrayelement auf 64 KB-Grenze aufgeteilt werden können.


Der letzte wichtige Aspekt QuickBasic Speicher-Management ist QuickBasic versucht, Speicher nutzen führen Zeichenfolgen variabler Länge, Zeichenfolge variabler Länge Arrays und dynamische Arrays im Speicher Anweisung zur Laufzeit verschieben kann. (Andere Variablen haben eine feste Position EXE Ladezeit bestimmt.) Darüber hinaus Wenn Sie eine Kette-Anweisung ausführen, können Daten in einem gemeinsamen übergeben verschieben. Dies bedeutet, dass die Ergebnisse der VARPTR, VARSEG, VARPTR$ oder SADD Funktion sollte immer verwendet nach Funktion aufgerufen wird.

ANHANG A: BEISPIELPROGRAMM

Dieses Beispielprogramm zeigt die in diesem Artikel behandelten Themen. Dieses Programm zeigt Arten DIMension Arrays und Variablen zwischen Modulen und Unterprogramme. Das Programm besteht aus zwei Modulen, jeweils ein Unterprogramm definiert.

Hauptmodul (EXAMPL1. BAS)

DECLARE SUB OtherModSub ()DECLARE SUB Subdemo ()

TYPE PowerOfTwo
I AS INTEGER ' 2 Bytes
L AS LONG ' 4 Bytes
S AS SINGLE ' 4 Bytes
D AS DOUBLE ' 8 Bytes
St AS STRING * 14 ' 14 Bytes

END TYPE ' 32 Bytes Total, a power of 2, 2^5

REM $STATIC
DIM A(100) AS INTEGER ' Static array, stored in DGROUP.

COMMON SHARED A() AS INTEGER ' Share the variables with the other
COMMON SHARED B AS STRING * 20 ' module and its SUBprograms.
COMMON SHARED X() AS INTEGER

REM $DYNAMIC
DIM X(100) AS INTEGER ' Dynamic array, stored in far heap.
DIM PTwo(4000) AS PowerOfTwo ' Dynamic huge array, stored in far heap
' Each element is a power of two, 2^5.

DIM NonFixedLen(10) AS STRING ' Dynamic array, but since it is not
' fixed length it is stored in DGROUP.

REM $STATIC
DIM SHARED M(100) AS LONG ' These variables are shared with all
DIM SHARED Equals AS STRING * 10 ' the SUBprograms in this module,
' and are stored in the DGROUP.

Num = 40

DIM DynArray(Num) AS SINGLE ' The array is dynamic since it is
' DIMensioned with a variable, so
' it is stored in far heap.

Plus$ = " + "
Equals = " = "
M(1) = 7
A(1) = 4

CALL Subdemo ' CALLs the SUBprogram of this module.
CALL OtherModSub ' CALLs the SUBprogram of the support module.
END

'SUBprogram of the Main Module:

SUB Subdemo

SHARED Plus$, NonFixedLen() AS STRING, Num

PRINT STR$(Num) + Plus$;
PRINT STR$(M(1))+ Equals + STR$(A(1));
A(1) = M(1)


END SUB

Supportmodul (EXAMPL2. BAS)

REM $STATIC
DIM A(100) AS INTEGER ' Only the static array is DIMensioned
COMMON SHARED A() AS INTEGER ' before the COMMON SHARED statement.
COMMON SHARED B AS STRING * 20
COMMON SHARED X() AS INTEGER ' The dynamic array is only DIMensioned
' in the main module.

Panic: ' The label for ON ERROR has to be at
resume next ' the module level.


' SUBprogram of the Support Module:

SUB OtherModSub
PRINT A(1)
ON ERROR GOTO Panic
END SUB

ANHANG B: LINK. ERLÄUTERUNG DER MAP-DATEI

Es folgt ein. Datei erstellt, wenn im Programm wird in Anhang A verknüpft ist. Die. Zuordnungsdatei über eine erfolgreiche Verknüpfung zeigt wie ein Modul Codesegment nähert 64 KB Code und wie schließen die statischen Variablen für die gesamte. EXE-Programm sind 64 KB in die DGROUP nähert. Zum Generieren einer Liste Zuordnung eines Programms umfassen Sie ein Dateiname im dritten Argument LINK-Befehl wie im folgenden Beispiel:
   LINK EXAMPL1.OBJ+EXAMPL2.OBJ,,EXAMPLE.MAP;
Hinweise für den Link. Karte weiter unten sind wie folgt:


  1. EXAMPL1_CODE ist der Code für EXAMPL1. BAS.
  2. EXAMPL2_CODE ist der Code für EXAMPL2. BAS.
  3. Das Codesegment jedes Moduls muss kleiner als 64 KB. Bei 64 KB Code-Segment nahe, teilen Sie das Modul in zwei oder mehrere Module auf. Die Länge eines Codesegments suchen Sie nach der Spalte Länge. Zum Beispiel die Länge des Codesegments für EXAMPL1. BAS ist 15A Hexadezimalbytes 346 in Dezimalschreibweise.
  4. FAR_MSG ist die weit, die Text der Fehlermeldungen enthält. Ist dies nicht den Heap. Zur Laufzeit wird der Heap reserviert.
  5. Nach Abschnitt Ursprung am unteren Rand der Link-Karte beginnt DGROUP zu 06DC:0, ist Absatz Adresse 06DC Hex mit einem Offset von 0. Dies entspricht Byte Adresse 06DC0 Hex (da Absatz 16 Byte enthält). Daher wird in diesem Beispiel DGROUP, BR_DATA gestartet.
  6. DGROUP endet bei stoppadresse des STAPELS.
  7. Erfahren Sie, wie groß das Programm DGROUP ist die Stop Adresse des Stapels und die Startadresse der ersten Datenelement in die DGROUP verkleinern. Beispielsweise ist die Größe des Programms DGROUP 7F9F Hex minus 6DC0 Hex (4575) 11DF Hexadezimalbytes entspricht.
  8. Alle Adressen in der. Karte sind relativ zum Start der. EXE-Programm. Die absolute Ladeadresse DOS nur zur Laufzeit bestimmt. VARSEG und VARPTR Anweisungen in Ihrem Programm zur Laufzeit lässt sich die absolute Adressen der Variablen.

EXAMPLE.MAP

 Start  Stop   Length Name                   Class
00000H 00159H 0015AH EXAMPL1_CODE BC_CODE
00160H 001C1H 00062H EXAMPL2_CODE BC_CODE
001C2H 03931H 03770H CODE CODE
03932H 03A0CH 000DBH INIT_CODE CODE
03A10H 041B2H 007A3H _TEXT CODE
041C0H 065EFH 02430H EMULATOR_TEXT CODE
065F0H 065F0H 00000H C_ETEXT ENDCODE
065F0H 065F7H 00008H FAR_HDR FAR_MSG
065F8H 06C44H 0064DH FAR_MSG FAR_MSG
06C45H 06C46H 00002H FAR_PAD FAR_MSG
06C47H 06C47H 00001H FAR_EPAD FAR_MSG
06C50H 06DBFH 00170H EMULATOR_DATA FAR_DATA

06DC0H 06DC0H 00000H BR_DATA BLANK
06DC0H 06DEFH 00030H BR_SKYS BLANK
06DF0H 06EFBH 0010CH COMMON BLANK
06EFCH 070E3H 001E8H BC_DATA BC_VARS
070E4H 070E9H 00006H NMALLOC BC_VARS
070EAH 070EAH 00000H ENMALLOC BC_VARS
070EAH 070EAH 00000H BC_FT BC_SEGS
070F0H 0710FH 00020H BC_CN BC_SEGS
07110H 07122H 00013H BC_DS BC_SEGS
07124H 07124H 00000H BC_SAB BC_SEGS
07124H 0712BH 00008H BC_SA BC_SEGS
0712CH 0712FH 00004H BC_SAE BC_SEGS
07130H 07345H 00216H _DATA DATA
07346H 0761FH 002DAH _BSS DATA
07620H 0771CH 000FDH BR_DATA DATA
0771EH 0771EH 00000H XIB DATA
0771EH 07741H 00024H XI DATA
07742H 07742H 00000H XIE DATA
07742H 0774DH 0000CH DBDATA DATA
0774EH 0775BH 0000EH CDATA DATA
0775CH 0775CH 00000H XIFB DATA
0775CH 0775CH 00000H XIF DATA
0775CH 0775CH 00000H XIFE DATA
0775CH 0775CH 00000H XPB DATA
0775CH 0775CH 00000H XP DATA
0775CH 0775CH 00000H XPE DATA
0775CH 0775CH 00000H XCB DATA
0775CH 0775FH 00004H XC DATA
07760H 07760H 00000H XCE DATA
07760H 07760H 00000H XCFB DATA
07760H 07760H 00000H XCF DATA
07760H 07760H 00000H XCFE DATA
07760H 0779FH 00040H CONST DATA
077A0H 077A0H 00000H BC_DATA BC_DATA
077A0H 077A0H 00000H XOB BSS
077A0H 077A0H 00000H XO BSS
077A0H 077A0H 00000H XOE BSS
077A0H 07F9FH 00800H STACK STACK

Origin Group
06DC:0 DGROUP
065F:0 FMGROUP
Program entry point at 03A1:00C8

Anhang c, QuickBasic 4.00, 4.00b, und 4.50 ihre ARRAYS

Besteht ein Unterschied im Arrayspeicher Programme wie kompiliert. EXE-Dateien und Programme ausführen, innerhalb der QuickBasic Version 4.00, 4.00b und 4.50 Umgebung (QB. (EXE). In QB. EXE Umgebung, ein Array, statische, nicht gemeinsam und nicht bestehend aus Zeichenfolgen variabler Länge werden in den Heap (statt wie in DGROUP. EXE-Programmen).


Dadurch Speicherverwaltungsfunktionen in Ihrem Programm, je nachdem, wo Sie das Programm ausführen.


Bei Programmen im Rahmen QuickBasic 4.00, 4.00b oder 4.50 (QB. (EXE) Arrays werden wie folgt gespeichert:


  1. Alle $STATIC Arrays gemeinsam in DGROUP gespeichert und können mit near Adressen verwiesen werden.
  2. Alle Arrays von Zeichenfolgen variabler Länge auch in DGROUP gespeichert und können auch in der Nähe von Adressen verwiesen werden.
  3. Alle Arrays als entfernte Objekte gespeichert und far-Adressen erfordern. Dazu gehören $STATIC-Arrays, die nicht in einer gemeinsamen Erklärung und diese Arrays können im Speicher wie $DYNAMIC Arrays verschieben.
QuickBasic 4.00, 4.00b und 4.50 Programme, die ausgeführt werden, wie kompiliert. EXE-Dateien, Arrays werden wie folgt gespeichert:


  1. Alle $STATIC-Arrays werden in DGROUP gespeichert und können mit near Adressen verwiesen.
  2. Alle $DYNAMIC Arrays von Zeichenfolgen variabler Länge auch in DGROUP gespeichert und können auch in der Nähe von Adressen verwiesen werden.
  3. Alle anderen $DYNAMIC-Arrays werden als entfernte Objekte gespeichert.

ANHANG D: SPEICHERTABELLEN

Dieser Anhang enthält eine allgemeine Zuordnung und drei detaillierte Laufzeit-Speicher zugeordnet.

Allgemeine Speicher-Diagramm

Das folgende Diagramm fasst zusammen, wie QuickBasic kompilierte Programme zur Laufzeit geladen werden:
          High Memory (640K maximum)
+-----------+
| | The far heap stores dynamic arrays. The far
| (Far) | heap consists of the rest of high memory
| Heap | available after MS-DOS and the Basic
| | program's DGROUP segment and code
--- +-----------+ segment(s) are allocated.

| | | The stack is used to store temporary data,
| | Stack | such as variables that are passed to a
DGROUP | | subprogram procedure. The default stack
Up to |- - - - - -| size is 2K.
64K | | The DGROUP (default data segment) is used
| | (Near) | to store all static arrays, strings,
| | Data | simple variables, and the stack. DGROUP
--- +-----------+ can be up to 64K in size.
:
+-----------+
| Code | The code segments store the executable code.
| Segments | Each module can have up to 64K for its
+-----------+ code segment.
Low Memory

Die folgenden Zahlen 1, 2 und 3 wird die Anordnung von Code und Daten im Speicher zur Laufzeit ausführlich beschrieben.

Abbildung 1

Die erste Figur (unten) zeigt die Laufzeit Arbeitsspeicher Karte bei Ausführung des Programms in QB. EXE Version 4.x-Umgebung:
                   +-------------+
| Quick |
| Library |
+-------------+
|Communication| User-specified size
| buffers |
+-------------+
| | This area contains items, such as
| FAR heap | large/huge arrays and user code,
| | dynamic arrays.
+-------------+

User Data ------->Run-time heap| Files buffers, etc.
End DS:xxxx +-------------+
| String heap |
+-------------+
| User Program|
DGROUP | Data |
+-------------+
UP to | User Stack |
64K +-------------+
| Quick Lib |
| Data |
+-------------+
| QuickBasic |
User Data | Static |
Start DS:0 ------->| Data |
+-------------+
| QuickBasic | QB.EXE
Low Memory ------->| Code |
+-------------+
| MS-DOS | MS-DOS Operating System
+-------------+
0000:0000 ------->

Abbildung 1 (oben): Memory Map für QB. EXE 4.x Umgebung

Abbildung 2

Diese zweite Abbildung (siehe unten) zeigt die Laufzeit-Speicher Karte angezeigt wird, wenn das Laufzeitmodul BRUN4x.EXE mit separaten Kompilierungsverfahren (stellen EXE File...) verwendet wird:
                   +-------------+
| BRUN4x.EXE | Separately loaded run-time code
+-------------+
|Communication| User-specified size
| buffers |
+-------------+
| | This area holds less-frequently-
| | used items, such as dynamic
| FAR heap | arrays, the user environment
| | table.
| |
| |
+-------------+
User Data ------->Run-time heap|
End DS:xxxx +-------------+
| String heap |
+-------------+
| User Stack | Preset to 2K
+-------------+
| Named | Named COMMON areas
| COMMON |
DGROUP +-------------+

| BC_DATA | User program variables
Up to +-------------+
64K | BC_CONST | User program constants
+-------------+
| Blank COMMON|
+-------------+
| _DATA | QuickBasic run-time data areas,
User Data | CONST | used during user code execution
Start DS:0 ------->| _BSS |
+-------------+
| User Code | User program separately linked
Low Memory ------->| | with BRUN4x.LIB
+-------------+
| MS-DOS | MS-DOS Operating System
+-------------+
0000:0000 ------->

Abbildung 2 (oben): der BRUN4x.EXE Laufzeitmodul Speicher ein. EXE

Abbildung 3

Dritte (siehe unten) Siehe Abbildung Laufzeit-Memory-Karte mit der separaten Kompilierung (stellen EXE File...) wird die Standby - Option allein Library (BCOM4x.LIB):
                   +-------------+
|Communication| User specified size
| buffers |
+-------------+
| | This area contains less frequently
| | used items, such as large
| FAR heap | numeric arrays, the user
| | environment table, dynamic
| | arrays.
| |
+-------------+

User Data ------->|Run-time heap| Files, buffers, etc.
End DS:xxxx +-------------+
| String heap |
+-------------+
| User Stack | Preset to 2K bytes
+-------------+
| Named | Named COMMON areas
| COMMON |
DGROUP +-------------+
| BC_DATA | User program variables
Up to +-------------+
64K | BC_CONST | User program constants
+-------------+
| Blank COMMON| Library and user definitions
+-------------+
| _DATA | QuickBasic run-time data areas,

User Data | CONST | used during user code execution
Start DS:0 ------->| _BSS |
+-------------+
|Run-time code| Run-time code linked into file
+-------------+
| User Code | User program separately linked
Low Memory ------->| | with BCOM4x.LIB
+-------------+
| MS-DOS | MS-DOS Operating System
+-------------+
0000:0000 ------->

Abbildung 3 (oben): eigenständigen (BCOM4x.LIB Library) Speicher ein. EXE
Eigenschaften

Artikelnummer: 45850 – Letzte Überarbeitung: 16.01.2017 – Revision: 1

Feedback