493.txt ************************************************************************ * Edit v1.000 from 2022-05-30 to 2022-06-01 by HSc * ************************************************************************ C++ mit dem Borland C++Builder Richard Kaiser Springer 2002 3-540-62994-7 Seite Auszug ======================================================================== 1 1 Die Entwicklungsumgebung ------------------------------------------------------------------------ 2 1.1 Visuelle Programmierung: Ein erstes kleines Programm ------------------------------------------------------------------------ 6 1.2 Erste Schritte in C++ ------------------------------------------------------------------------ 9 1.3 Der Quelltexteditor ------------------------------------------------------------------------ 12 1.4 Projekte, Projektdateien und Projektoptionen ------------------------------------------------------------------------ 15 1.5 Einige Tipps zur Arbeit mit Projekten ------------------------------------------------------------------------ 16 1.6 Die Online-Hilfe ------------------------------------------------------------------------ 17 1.7 Das lokale Menue ------------------------------------------------------------------------ 18 1.8 Die Symbolleiste ------------------------------------------------------------------------ 19 1.9 Programmierhilfen ------------------------------------------------------------------------ 20 1.10 Packages und eigenstaendig ausfuehrbare Programme ------------------------------------------------------------------------ 23 2 Die Komponentenpalette ------------------------------------------------------------------------ 23 2.1 Die Online-Hilfe zu den Komponenten ------------------------------------------------------------------------ 27 2.2 Namen ------------------------------------------------------------------------ 30 2.3 Labels und Datentypen ------------------------------------------------------------------------ 35 2.4 Funktionen, Methoden und die Komponente TEdit ------------------------------------------------------------------------ 40 2.5 Memos, ListBoxen, ComboBoxen und die Klasse TStrings ------------------------------------------------------------------------ 44 2.6 Buttons und Ereignisse ------------------------------------------------------------------------ 47 2.7 CheckBoxen, RadioButtons und einfache z/-Abfragen ------------------------------------------------------------------------ 49 2.8 Die Container GroupBox, Panel und RadioGroup ------------------------------------------------------------------------ 52 2.9 ScrollBar ------------------------------------------------------------------------ 55 2.10 Hauptmenues und Popup-Menues ------------------------------------------------------------------------ 58 2.11 Die Komponenten der Seite Dialoge ------------------------------------------------------------------------ 61 2.12 Der Aufruf von eigenen Formularen und modale Fenster © ------------------------------------------------------------------------ 66 2.13 Die Komponenten der Seite "Zusaetzlich" © ------------------------------------------------------------------------ 72 2.14 Einige Komponenten der Seiten Win32 und Win 3. l ------------------------------------------------------------------------ 73 2.14.1 Mehrseitige Dialoge © ------------------------------------------------------------------------ 74 2.14.2 ImageList undListView © ------------------------------------------------------------------------ 76 2.14.3 Komponenten zur Anzeige hierarchischer Datenstrukturen © ------------------------------------------------------------------------ 78 2.14.4 Komponenten zur Groeszenanpassung anderer Komponenten © ------------------------------------------------------------------------ 79 2.14.5 Formatierte Texte ------------------------------------------------------------------------ 80 2.14.6 Statusanzeigen © ------------------------------------------------------------------------ 81 2.14.7 Weitere Komponenten © ------------------------------------------------------------------------ 84 2.15 Einige Komponenten der Seite System © ------------------------------------------------------------------------ 87 2.16 ActiveX-Komponenten © ------------------------------------------------------------------------ 92 2.17 Vordefinierte DialogBoxen© ------------------------------------------------------------------------ 95 3 Elementare Datentypen und Anweisungen ------------------------------------------------------------------------ 95 3.1 Windows-Programme und Units ------------------------------------------------------------------------ 97 3.2 Syntaxregeln ------------------------------------------------------------------------ 100 3.3 Variablen und Bezeichner ------------------------------------------------------------------------ 103 3.4 Ganzzahldatentypen ------------------------------------------------------------------------ 106 3.4.1 Die interne Darstellung von Ganzzahlwerten ------------------------------------------------------------------------ 109 3.4.2 Der Datentyp von Ganzzahlliteralen ------------------------------------------------------------------------ 111 3.4.3 Zuweisungen und Standardkonversionen bei Ganzzahlausdruecken ------------------------------------------------------------------------ 114 3.4.4 Operatoren und die ueblichen arithmetischen Konversionen" ------------------------------------------------------------------------ 120 3.4.5 Der Datentyp bool ------------------------------------------------------------------------ 125 3.4.6 Die c/?ar-Datentypen und der ASCII- und ANSI-Zeichensatz ------------------------------------------------------------------------ 132 3.4.7 Der Datentyp _int64 ------------------------------------------------------------------------ 132 3.5 Kontrollstrukturen und Funktionen ------------------------------------------------------------------------ 133 3.5.1 Die if- und die Verbundanweisung ------------------------------------------------------------------------ 134 3.5.2 Wiederholungsanweisungen ------------------------------------------------------------------------ 135 3.5.3 Funktionen und der Datentyp vo/W ------------------------------------------------------------------------ 140 3.6 Der integrierte Debugger ------------------------------------------------------------------------ 146 3.7 Gleitkommadatentypen ------------------------------------------------------------------------ 147 3.7.1 Die interne Darstellung von Gleitkommawerten ------------------------------------------------------------------------ 150 3.7.2 Der Datentyp von Gleitkommaliteralen ------------------------------------------------------------------------ 151 3.7.3 Implizite Konversionen ------------------------------------------------------------------------ 157 3.7.4 Mathematische Funktionen ------------------------------------------------------------------------ 162 3.8 Syntaxregeln fuer einfache Deklarationen ------------------------------------------------------------------------ 164 3.9 Zeiger, Strings und dynamisch erzeugte Variablen ------------------------------------------------------------------------ 165 3.9.1 Die Definition von Zeigern ------------------------------------------------------------------------ 167 3.9.2 Der Adressoperator, Zuweisungen und generische Zeiger ------------------------------------------------------------------------ 171 3.9.3 Dynamisch erzeugte Variablen: new und delete ------------------------------------------------------------------------ 175 3.9.4 Zeiger als Parameter und die Zeigertypen der Windows-API ------------------------------------------------------------------------ 177 3.9.5 Zeigerarithmetik ------------------------------------------------------------------------ 178 3.9.6 Nullterminierte Strings und Zeiger auf char ------------------------------------------------------------------------ 184 3.9.7 Zeiger aufzeiget auf Zeiger auf ------------------------------------------------------------------------ 185 3.9.8 Referenztypen und Referenzparameter ------------------------------------------------------------------------ 189 3.10 Konstanten ------------------------------------------------------------------------ 193 3.11 Deklarationen mit typedefund typeid-Ausdmcke ------------------------------------------------------------------------ 195 3.12 Aufzaehlungstypen ------------------------------------------------------------------------ 200 3.13 Kommentare und interne Programmdokumentation ------------------------------------------------------------------------ 204 3.14 Praeprozessoranweisungen ------------------------------------------------------------------------ 204 3.14.1 Die mc/Mj und die Funktion _matheir® ------------------------------------------------------------------------ 537 5.10.10DieKlasseaM?oj7fr (+) ------------------------------------------------------------------------ 539 5.10.11 Exception-Spezifikationen ------------------------------------------------------------------------ 540 5.10.12 Die Funktion tenninate ® ------------------------------------------------------------------------ 541 5.10.13 Das Win32-Exception-Handling mit tty-__except® ------------------------------------------------------------------------ 543 6 Funktionen ------------------------------------------------------------------------ 544 6.1 Die Definition und der Aufruf von Funktionen ------------------------------------------------------------------------ 548 6.2 Die Verwaltung von Funktionsaufrufen ueber den Stack ------------------------------------------------------------------------ 550 6.3 Funktionen mit Parametern ------------------------------------------------------------------------ 552 6.3.1 Werteparameter ------------------------------------------------------------------------ 554 6.3.2 "Call by reference" mit Referenzparametern ------------------------------------------------------------------------ 557 6.3.3 Zeiger als Parameter ------------------------------------------------------------------------ 559 6.3.4 Konstante Parameter ------------------------------------------------------------------------ 562 6.3.5 Seiteneffekte und die Reihenfolge von Auswertungen ------------------------------------------------------------------------ 566 6.3.6 Default-Argumente ------------------------------------------------------------------------ 568 6.3.7 Der Datentyp einer Funktion ------------------------------------------------------------------------ 570 6.3.8 Zeiger auf Funktionen ------------------------------------------------------------------------ 579 6.3.9 Unspezifizierte Anzahl von Argumenten © ------------------------------------------------------------------------ 580 6.3.10 Die Funktionen main bzw. WinMain und ihre Parameter ------------------------------------------------------------------------ 582 6.3.11 Der Aufruf von Funktionen aus Delphi im C++Builder © ------------------------------------------------------------------------ 584 6.3.12 Traditionelle K&R-Funktionsdefinitionen © ------------------------------------------------------------------------ 585 6.3.13 Aufrufkonventionen© ------------------------------------------------------------------------ 585 6.4 Schrittweise Verfeinerung als Entwurfstechnik ------------------------------------------------------------------------ 589 6.5 Etwas Programmierlogik und -stil fuer Funktionen ------------------------------------------------------------------------ 595 6.6 Rekursion ------------------------------------------------------------------------ 600 6.6.1 Quicksort ------------------------------------------------------------------------ 605 6.6.2 Ein rekursiv absteigender Parser ------------------------------------------------------------------------ 608 6.6.3 Rekursiv definierte Kurven © ------------------------------------------------------------------------ 610 6.6.4 Indirekte Rekursion © ------------------------------------------------------------------------ 614 6.6.5 Rekursive Datenstrukturen und binaere Suchbaeume ------------------------------------------------------------------------ 619 6.6.6 Rekursive Datenstrukturen in der Standardbibliothek von C++ ------------------------------------------------------------------------ 622 6.7 Inline-Funktionen ------------------------------------------------------------------------ 624 6.8 UEberladene Funktionen ------------------------------------------------------------------------ 633 6.9 UEberladene Operatoren mit globalen Operatorfunktionen ------------------------------------------------------------------------ 634 6.9.1 Globale Operatorfunktionen ------------------------------------------------------------------------ 636 6.9.2 Die Inkrement- und Dekrementoperatoren ------------------------------------------------------------------------ 636 6.9.3 Referenzen als Funktionswerte ------------------------------------------------------------------------ 639 6.9.4 Die Ein- und Ausgabe von selbst definierten Datentypen ------------------------------------------------------------------------ 643 7 Modulare Programmierung und Namensbereiche ------------------------------------------------------------------------ 644 7.1 Separate Kompilation und statische Bibliotheken ------------------------------------------------------------------------ 644 7.1.1 Projekte im C++Builder © ------------------------------------------------------------------------ 645 7.1.2 Bindung © ------------------------------------------------------------------------ 647 7.1.3 Deklarationen und Definitionen © ------------------------------------------------------------------------ 649 7.1.4 Die "One Definition Rule" © ------------------------------------------------------------------------ 651 7.1.5 Header-Dateien und Bibliotheken © ------------------------------------------------------------------------ 653 7.1.6 Der Aufruf von in C geschriebenen Funktionen © ------------------------------------------------------------------------ 657 7.2 Dynamic Link Libraries (DLLs) ------------------------------------------------------------------------ 657 7.2.1 DLLs erzeugen © ------------------------------------------------------------------------ 659 7.2.2 Implizit geladene DLLs © ------------------------------------------------------------------------ 660 7.2.3 Explizit geladene DLLs © ------------------------------------------------------------------------ 662 7.2.4 Hilfsprogramme zur Identifizierung von Funktionen in DLLs © ------------------------------------------------------------------------ 663 7.2.5 DLL-Funktionen mit visuell gestalteten Komponenten © ------------------------------------------------------------------------ 664 7.2.6 Projektgruppen © ------------------------------------------------------------------------ 666 7.2.7 Batch-Dateien © ------------------------------------------------------------------------ 667 7.3 Namensbereiche ------------------------------------------------------------------------ 669 7.3.1 Die Definition von benannten Namensbereichen ------------------------------------------------------------------------ 671 7.3.2 Die Verwendung von Namen aus Namensbereichen ------------------------------------------------------------------------ 675 7.3.3 Aliasnamen fuer Nainensbereiche ------------------------------------------------------------------------ 675 7.3.4 Unbenannte Namensbereiche ------------------------------------------------------------------------ 677 7.3.5 Module und das Geheimnisprinzip ------------------------------------------------------------------------ 681 8 Objektorientierte Programmierung ------------------------------------------------------------------------ 682 8.1 Klassen ------------------------------------------------------------------------ 682 8.1.1 Datenelemente und Elementfunktionen ------------------------------------------------------------------------ 686 8.1.2 Der Gueltigkeitsbereich von Klassenelementen ------------------------------------------------------------------------ 688 8.1.3 Objekte und die Zugriffsrechte private und public ------------------------------------------------------------------------ 694 8.1.4 Der Aufruf von Elementfunktionen und der f/i/s-Zeiger ------------------------------------------------------------------------ 696 8.1.5 Konstruktoren und Destruktoren ------------------------------------------------------------------------ 709 8.1.6 OO Analyse und Design: Der Entwurf von Klassen ------------------------------------------------------------------------ 714 8.1.7 Ein wenig Programmierlogik: Klasseninvarianten und Korrektheit ------------------------------------------------------------------------ 720 8.1.8 UML-Diagramme fuer Klassen und Objekte ------------------------------------------------------------------------ 722 8.2 Klassen als Datentypen ------------------------------------------------------------------------ 723 8.2.1 DerStandardkonstruktor ------------------------------------------------------------------------ 725 8.2.2 Objekte als Klassenelemente und Elementinitialisierer ------------------------------------------------------------------------ 731 8.2.3 friend-Funktionen und -Klassen ------------------------------------------------------------------------ 735 8.2.4 UEberladene Operatoren als Elementfunktionen ------------------------------------------------------------------------ 743 8.2.5DerCopy-Konstruktor ------------------------------------------------------------------------ 751 8.2.6 Der Zuweisungsoperator = fuer Klassen ------------------------------------------------------------------------ 760 8.2.7 Benutzerdefinierte Konversionen ------------------------------------------------------------------------ 764 8.2.8 Explizite Konstruktoren©., ------------------------------------------------------------------------ 766 8.2.9 Statische Klassenelemente ------------------------------------------------------------------------ 768 8.2.10 Konstante Klassenelemente und Objekte ------------------------------------------------------------------------ 770 8.2.11 Weitere Deklarationsmoeglichkeiten in Klassen © ------------------------------------------------------------------------ 771 8.2.12 Klassen und Header-Dateien ------------------------------------------------------------------------ 773 8.2.13 UEberladene Operatoren fuer new und delete © ------------------------------------------------------------------------ 776 8.3 Vererbung ------------------------------------------------------------------------ 776 8.3.1 Die Elemente von abgeleiteten Klassen ------------------------------------------------------------------------ 779 8.3.2 Zugriffsrechte auf die Elemente von Basisklassen ------------------------------------------------------------------------ 781 8.3.3 Die Bedeutung von Elementnamen in einer Klassenhierarchie ------------------------------------------------------------------------ 783 8.3.4 ;(<<'ng-Deklarationen in abgeleiteten Klassen © ------------------------------------------------------------------------ 784 8.3.5 Konstruktoren, Destruktoren und implizit erzeugte Funktionen ------------------------------------------------------------------------ 790 8.3.6 Vererbung bei Formularen im C++Builder ------------------------------------------------------------------------ 791 8.3.7 OO Design: public Vererbung und "ist ein"-Beziehungen ------------------------------------------------------------------------ 797 8.3.8 OO Design: Komposition und "hat ein"-Beziehungen ------------------------------------------------------------------------ 799 8.3.9 Konversionen zwischen public abgeleiteten Klassen ------------------------------------------------------------------------ 802 &.3.10 protected und private abgeleitete Klassen © ------------------------------------------------------------------------ 806 8.3.11 Mehrfachvererbung und virtuelle Basisklassen ------------------------------------------------------------------------ 812 8.4 Virtuelle Funktionen, spaete Bindung und Polymorphie ------------------------------------------------------------------------ 813 8.4.1 Der statische und der dynamische Datentyp ------------------------------------------------------------------------ 814 8.4.2 Virtuelle Funktionen ------------------------------------------------------------------------ 825 8.4.3 Die interne Realisierung von virtuellen Funktionen: vptr und vrW ------------------------------------------------------------------------ 831 8.4.4 OO-Design: Der Einsatzbereich von virtuellen Funktionen ------------------------------------------------------------------------ 832 8.4.5 Komposition \m& private Mehrfachvererbung © ------------------------------------------------------------------------ 833 8.4.6 Virtuelle Konstruktoren und Destruktoren ------------------------------------------------------------------------ 836 8.4.7 Virtuelle Funktionen in Konstruktoren und Destruktoren © ------------------------------------------------------------------------ 837 8.4.8 Virtuelle Funktionen und Erweiterbarkeit ------------------------------------------------------------------------ 840 8.4.9 Rein virtuelle Funktionen und abstrakte Klassen ------------------------------------------------------------------------ 843 8.4.10 OO-Design: Virtuelle Funktionen und abstrakte Basisklassen ------------------------------------------------------------------------ 848 8.4.11 Protokollklassen und Programmgerueste ------------------------------------------------------------------------ 850 8.4.12 Muster (Patterns) ------------------------------------------------------------------------ 855 8.4.13 UML-Diagramme fuer Vererbung und Komposition ------------------------------------------------------------------------ 857 8.4.14 Zeiger auf Klassenelemente © ------------------------------------------------------------------------ 862 8.5 Laufzeit-Typinformationen ------------------------------------------------------------------------ 862 8.5.1 Typinformationen mit dem Operator typeid ® ------------------------------------------------------------------------ 866 8.5.2 Typkonversionen mit dynamic_cast © ------------------------------------------------------------------------ 870 8.5.3 Anwendungen von Laufzeit-Typinformationen © ------------------------------------------------------------------------ 873 8.5.4 statte_cast mit Klassen © ------------------------------------------------------------------------ 875 8.5.5 Laufzeit-Typinformationen fuer die Klassen der VCL © ------------------------------------------------------------------------ 879 9 Die Bibliothek der visuellen Komponenten (VCL) ------------------------------------------------------------------------ 880 9.1 Besonderheiten der VCL ------------------------------------------------------------------------ 884 9.2 Visuelle Programmierung und Properties (Eigenschaften) ------------------------------------------------------------------------ 884 9.2.1 Lesen und Schreiben von Eigenschaften ------------------------------------------------------------------------ 887 9.2.2 Array-Properties ------------------------------------------------------------------------ 889 9.2.3 Indexangaben ------------------------------------------------------------------------ 890 9.2.4 Speicherangaben ------------------------------------------------------------------------ 891 9.2.5 UEberschriebene Eigenschaften ------------------------------------------------------------------------ 891 9.3 Die Klassenhierarchie der VCL ------------------------------------------------------------------------ 899 9.4 Selbst definierte Komponenten und ihre Ereignisse ------------------------------------------------------------------------ 904 9.5MDI-Programme ------------------------------------------------------------------------ 907 9.6 Klassenreferenztypen und virtuelle Konstruktoren ------------------------------------------------------------------------ 912 9.7 Botschaften (Messages) ------------------------------------------------------------------------ 912 9.7.1 Die Message Queue und die Window-Prozedur ------------------------------------------------------------------------ 914 9.7.2 Botschaften fuer eine Anwendung ------------------------------------------------------------------------ 915 9.7.3 Die Behandlung von Botschaften in der VCL ------------------------------------------------------------------------ 921 9.7.4 Selbst definierte Message-Handler fuer Windows-Steuerelemente ------------------------------------------------------------------------ 923 9.7.5 Botschaften versenden ------------------------------------------------------------------------ 927 9.8 Die Erweiterung der Komponentenpalette ------------------------------------------------------------------------ 935 10 Templates und die STL ------------------------------------------------------------------------ 936 10.1 Generische Funktionen: Funktions-Templates ------------------------------------------------------------------------ 937 10.1.1 Die Deklaration von Funktions-Templates mit Typ-Parametern ------------------------------------------------------------------------ 939 10.1.2 Spezialisierungen von Funktions-Templates ------------------------------------------------------------------------ 944 10.1.3 Funktions-Templates mit Nicht-Typ-Parametern © ------------------------------------------------------------------------ 946 10.1.4 Explizit instanziierte Funktions-Templates © ------------------------------------------------------------------------ 946 10.1.5 Explizit spezialisierte und ueberladene Templates ------------------------------------------------------------------------ 950 10.1.6 Rekursive Funktions-Templates ------------------------------------------------------------------------ 953 10.2 Generische Klassen: Klassen-Templates ------------------------------------------------------------------------ 953 10.2.1 Die Deklaration von Klassen-Templates mit Typ-Parametern ------------------------------------------------------------------------ 954 10.2.2 Spezialisierungen von Klassen-Templates ------------------------------------------------------------------------ 962 10.2.3 Templates mit Nicht-Typ-Parametern © ------------------------------------------------------------------------ 963 10.2.4 Explizit instanziierte Klassen-Templates © ------------------------------------------------------------------------ 964 10.2.5 Partielle und vollstaendige Spezialisierungen © ------------------------------------------------------------------------ 970 10.2.6 Elemente undfriend-Funktionen von Klassen-Templates © ------------------------------------------------------------------------ 974 10.2.7 Ableitungen von Templates © ------------------------------------------------------------------------ 975 10.2.8 Exportierte Templates ------------------------------------------------------------------------ 976 10.2.9 UML-Diagramme fuer parametrisierte Klassen © ------------------------------------------------------------------------ 980 10.3 Funktionsobjekte in der STL ------------------------------------------------------------------------ 980 10.3.1 Der Aufrufoperator Q ------------------------------------------------------------------------ 982 10.3.2 Praedikate und arithmetische Funktionsobjekte ------------------------------------------------------------------------ 986 10.3.3 Binder, Funktionsadapter und Negatoren ------------------------------------------------------------------------ 992 10.4 Iteratoren und die STL-Algorithmen ------------------------------------------------------------------------ 993 10.4.1 Die verschiedenen Arten von Iteratoren ------------------------------------------------------------------------ 995 10.4.2 Umkehriteratoren ------------------------------------------------------------------------ 996 10.4.3 Einfuegefunktionen und Einfuegeiteratoren ------------------------------------------------------------------------ 998 10.4.4Stream-Iteratoren ------------------------------------------------------------------------ 999 10.4.5 Container-Konstruktoren mit Iteratoren ------------------------------------------------------------------------ 1000 10.4.6 STL-Algorithmen fuer alle Elemente eines Containers ------------------------------------------------------------------------ 1002 10.5 Die Algorithmen der STL ------------------------------------------------------------------------ 1003 10.5.1 Lineares Suchen ------------------------------------------------------------------------ 1005 10.5.2 Zaehlen ------------------------------------------------------------------------ 1005 10.5.3 Der Vergleich von Bereichen ------------------------------------------------------------------------ 1007 10.5.4 Suche nach Teilfolgen ------------------------------------------------------------------------ 1008 10.5.5 Minimum und Maximum ------------------------------------------------------------------------ 1010 10.5.6 Elemente vertauschen ------------------------------------------------------------------------ 1011 10.5.7 Kopieren von Bereichen ------------------------------------------------------------------------ 1012 10.5.8 Elemente transformieren und ersetzen ------------------------------------------------------------------------ 1014 10.5.9 Elementen in einem Bereich Werte zuweisen ------------------------------------------------------------------------ 1014 10.5.10 Elemente entfernen ------------------------------------------------------------------------ 1016 10.5.11 Die Reihenfolge von Elementen vertauschen ------------------------------------------------------------------------ 1017 10.5.12 Permutationen ------------------------------------------------------------------------ 1018 10.5.13 Partitionen ------------------------------------------------------------------------ 1019 10.5.14 Bereiche sortieren ------------------------------------------------------------------------ 1021 10.5.15 Binaeres Suchen in sortierten Bereichen ------------------------------------------------------------------------ 1022 10.5.16 Mischen von sortierten Bereichen ------------------------------------------------------------------------ 1023 10.5.17 Mengenoperationen auf sortierten Bereichen ------------------------------------------------------------------------ 1024 10.5. 18 Heap-Operationen ------------------------------------------------------------------------ 1025 10.5.19 Verallgemeinerte numerische Operationen ------------------------------------------------------------------------ 1027 11 Verschiedenes ------------------------------------------------------------------------ 1028 11.13D-GrafikmitOpenGL ------------------------------------------------------------------------ 1028 11.1.1 Initialisierungen ------------------------------------------------------------------------ 1031 11.1.2 Grafische Grundelemente: Primitive ------------------------------------------------------------------------ 1036 11.1.3 Modelltransformationen ------------------------------------------------------------------------ 1039 11.1.4 Vordefinierte Koerper ------------------------------------------------------------------------ 1041 11.1.5 Lokale Transformationen ------------------------------------------------------------------------ 1044 11.1.6 Beleuchtungseffekte ------------------------------------------------------------------------ 1046 11.1,7 Texturen ------------------------------------------------------------------------ 1051 11.2 Win32-Funktionen zur Dateibearbeitung ------------------------------------------------------------------------ 1051 11.2.1 Elementare Funktionen ------------------------------------------------------------------------ 1055 11.2.2 Der gleichzeitige Zugriff von mehreren Anwendern auf e. Datei ------------------------------------------------------------------------ 1056 11.2.3 Record-Locking ------------------------------------------------------------------------ 1051 11.2.4 VCL-Funktionen zur Dateibearbeitung und TFileStream ------------------------------------------------------------------------ 1059 11.3 Datenuebertragung ueber die serielle Schnittstelle ------------------------------------------------------------------------ 1060 11.3.1 Grundbegriffe ------------------------------------------------------------------------ 1061 11.3.2 Standards fuer die serielle Schnittstelle: RS-232C bzw. V.24 ------------------------------------------------------------------------ 1063 11.3.3 Win3 2-Funktionen zur seriellen Kommunikation ------------------------------------------------------------------------ 1067 11.4 Datenbank-Komponenten der VCL ------------------------------------------------------------------------ 1067 11.4.1 Tabellen und die Komponente TTable ------------------------------------------------------------------------ 1072 11.4.2 Die Anzeige von Tabellen mit der Komponente DBGrid ------------------------------------------------------------------------ 1075 11.4.3 Indizierte Tabellen ------------------------------------------------------------------------ 1078 11.4.4 Datenbanken mit mehreren Tabellen ------------------------------------------------------------------------ 1080 11.4.5 SQL-Abfragen ------------------------------------------------------------------------ 1082 11.4.6 Transaktionen und Cached Updates ------------------------------------------------------------------------ 1084 11.4.7 Die BDE am Beispiel von ODBC und MS Access Datenbanken ------------------------------------------------------------------------ 1086 11.4.8 Visuell gestaltete Datenbank-Ausdrucke mit QuickReport ------------------------------------------------------------------------ ******* EOF ************************************************************