Verfügbarkeit: C von A bis Z | Technische Universität München

C von A bis Z: das umfassende Handbuch

Gespeichert in:

Bibliographische Detailangaben
Beteiligte Personen:	Wolf, Jürgen 1974- (VerfasserIn), Krooß, René (VerfasserIn)
Format:	Buch
Sprache:	Deutsch
Veröffentlicht:	Bonn Rheinwerk Verlag 2020
Ausgabe:	4., aktualisierte und überarbeitete Auflage
Schriftenreihe:	Rheinwerk Computing
Schlagwörter:	C > Programmiersprache ANSI C C++ ANSI C++ C-Programmierung Software-Entwicklung entwickeln Hand-Buch Bücher Wissen lernen Tutorials Kurse Workshops Ausbildung Studium Seminare C programmieren lernen Algorithmen Entwickler Programmierer Engineer
Links:	http://deposit.dnb.de/cgi-bin/dokserv?id=9b7c412c241445b9ae09b3eed0cda1e4&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032158424&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
Beschreibung:	Auf dem Cover: Aktuell zu C18
Umfang:	1228 Seiten Illustrationen, Diagramme 24 cm x 16.8 cm
ISBN:	9783836239738 3836239736

Internformat

MARC


LEADER	00000nam a22000008c 4500
001	BV046748654
003	DE-604
005	20210802
007	t\|
008	200604s2020 gw a\|\|\| \|\|\|\| 00\|\|\| ger d
015			\|a 20,N05 \|2 dnb
016	7		\|a 1203448775 \|2 DE-101
020			\|a 9783836239738 \|c Festeinband : EUR 44.90 (DE), EUR 46.20 (AT), CHF 57.90 (freier Preis) \|9 978-3-8362-3973-8
020			\|a 3836239736 \|9 3-8362-3973-6
024	3		\|a 9783836239738
028	5	2	\|a Bestellnummer: 459/03973
035			\|a (OCoLC)1164633002
035			\|a (DE-599)DNB1203448775
040			\|a DE-604 \|b ger \|e rda
041	0		\|a ger
044			\|a gw \|c XA-DE-NW
049			\|a DE-860 \|a DE-29T \|a DE-Aug4 \|a DE-863 \|a DE-859 \|a DE-634 \|a DE-573 \|a DE-1051 \|a DE-19 \|a DE-703 \|a DE-83 \|a DE-523 \|a DE-473 \|a DE-898 \|a DE-1046 \|a DE-1043 \|a DE-20 \|a DE-573n \|a DE-B768 \|a DE-862
082	0		\|a 005.133 \|2 23/ger
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a 004 \|2 sdnb
100	1		\|a Wolf, Jürgen \|d 1974- \|e Verfasser \|0 (DE-588)132691256 \|4 aut
245	1	0	\|a C von A bis Z \|b das umfassende Handbuch \|c Jürgen Wolf, René Krooß
250			\|a 4., aktualisierte und überarbeitete Auflage
264		1	\|a Bonn \|b Rheinwerk Verlag \|c 2020
300			\|a 1228 Seiten \|b Illustrationen, Diagramme \|c 24 cm x 16.8 cm
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
490	0		\|a Rheinwerk Computing
500			\|a Auf dem Cover: Aktuell zu C18
650	0	7	\|a C \|g Programmiersprache \|0 (DE-588)4113195-2 \|2 gnd \|9 rswk-swf
650	0	7	\|a ANSI C \|0 (DE-588)4233557-7 \|2 gnd \|9 rswk-swf
650	0	7	\|a C++ \|0 (DE-588)4193909-8 \|2 gnd \|9 rswk-swf
650	0	7	\|a ANSI C++ \|0 (DE-588)4499937-9 \|2 gnd \|9 rswk-swf
653			\|a C-Programmierung
653			\|a Software-Entwicklung entwickeln
653			\|a Hand-Buch Bücher Wissen lernen Tutorials Kurse Workshops Ausbildung Studium Seminare
653			\|a C programmieren lernen
653			\|a Algorithmen
653			\|a Entwickler Programmierer Engineer
689	0	0	\|a C \|g Programmiersprache \|0 (DE-588)4113195-2 \|D s
689	0	1	\|a ANSI C \|0 (DE-588)4233557-7 \|D s
689	0		\|5 DE-604
689	1	0	\|a C++ \|0 (DE-588)4193909-8 \|D s
689	1		\|8 1\p \|5 DE-604
689	2	0	\|a ANSI C++ \|0 (DE-588)4499937-9 \|D s
689	2		\|8 2\p \|5 DE-604
700	1		\|a Krooß, René \|e Verfasser \|0 (DE-588)1211561577 \|4 aut
710	2		\|a Rheinwerk Verlag \|0 (DE-588)1081738405 \|4 pbl
780	0	0	\|i Vorangegangen ist \|z 9783836214117
856	4	2	\|m X:MVB \|q text/html \|u http://deposit.dnb.de/cgi-bin/dokserv?id=9b7c412c241445b9ae09b3eed0cda1e4&prov=M&dok_var=1&dok_ext=htm \|3 Inhaltstext
856	4	2	\|m DNB Datenaustausch \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032158424&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
883	1		\|8 1\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
883	1		\|8 2\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
943	1		\|a oai:aleph.bib-bvb.de:BVB01-032158424

Datensatz im Suchindex

_version_	1819336119963090944
adam_text	AUF EINEN BLICK 1 EINSTIEG IN C ........................................................................................ 31 2 EINE GUENSTIGE PROGRAMMIERPLATTFORM-DER RASPBERRY PI ................... 53 3 DAS ERSTE PROGRAMM ........................................................................... 73 4 GRUNDLAGEN ......................................................................................... 81 5 BASISDATENTYPEN .................................................................................. 95 6 FORMATIERTE EIN-/AUSGABE MIT SCANFQ UND PRINTFQ ..................... 147 7 OPERATOREN .......................................................................................... 161 8 TYPUMWANDLUNG ................................................................................. 181 9 KONTROLLSTRUKTUREN .............................................................................. 189 10 FUNKTIONEN ............................................................................ 235 11 PRAEPROZESSOR-DIREKTIVEN ..................................................................... 283 12 ARRAYS .................................................................................................. 309 13 ZEIGER (POINTER) .................................................................................... 369 14 KOMMANDOZEILENARGUMENTE ............................................................. 429 15 DYNAMISCHE SPEICHERVERWALTUNG ....................................................... 441 16 STRUKTUREN ........................................................................................... 479 17 EIN-/AUSGABE-FUNKTIONEN ................................................................... 539 18 ATTRIBUTE VON DATEIEN UND DAS ARBEITEN MIT VERZEICHNISSEN (NICHT ANSI C) ...................................................................................... 673 19 ARBEITEN MIT VARIABEL LANGEN ARGUMENTLISTEN- STDARG.H ............... 707 20 ZEITROUTINEN ........................................................................................ 723 21 WEITERE HEADERDATEIEN UND IHRE FUNKTIONEN (ANSI C) ....................... 739 22 DYNAMISCHE DATENSTRUKTUREN ............................................................ 797 23 ALGORITHMEN ....................................................................................... 881 24 MYSQL UND C ...................................................................................... 989 25 NETZWERKPROGRAMMIERUNG UND CROSS-PLATTFORM-ENTWICKLUNG ........... 1069 26 PARALLELES RECHNEN ................................................................................ 1135 27 SICHERES PROGRAMMIEREN ...................................................................... 1153 28 WIE GEHT * S JETZT WEITER? ........................................................................ 1181 INHALT MATERIALIEN ZUM BUCH ................................................................................................... 23 VORWORT .......................................................................................................................... 25 VORWORT DES GUTACHTERS ................................................................................................ 29 1 EINSTIEG IN C 31 1.1 UEBERSICHT ZU C ................................................................................................... 31 1.2 DER ANSI-C-STANDARD ....................................................................................... 33 1.2.1 WELCHER C-STANDARD WIRD IN DIESEM BUCH VERWENDET? ....................... 35 1.2.2 DER VORTEIL DES ANSI-C-STANDARDS ...................................................... 36 1.3 DER POSIX-STANDARD ......................................................................................... 36 1.4 VOR- UND NACHTEILE DER PROGRAMMIERSPRACHE C ............................................ 37 1.5 C IN DIESEM BUCH ............................................................................................... 39 1.6 WAS BENOETIGEN SIE FUER C? ................................................................................ 39 1.6.1 TEXTEDITOR ............................................................................................ 39 1.6.2 COMPILER ............................................................................................... 40 1.6.3 ALL-IN-ONE- DIE ENTWICKLUNGSUMGEBUNG ........................................... 40 1.7 WELCHER COMPILER UND WELCHES BETRIEBSSYSTEM? ........................................ 41 1.8 UNTERSCHIEDE ZWISCHEN WINDOWS UND LINUX ................................................ 42 1.9 EINE PROGRAMMIERUMGEBUNG EINRICHTEN - CODE::BLOCKS FUER WINDOWS .... 42 1.9.1 DIE IDE INSTALLIEREN .............................................................................. 43 1.9.2 DEN COMPILER INSTALLIEREN ................................................................... 46 1.9.3 EIN EINFACHES C-PROJEKT MIT CODE::BLOCKS ANLEGEN UND KOMPILIEREN .......................................................................................... 49 1.10 EINE PROGRAMMIERUMGEBUNG EINRICHTEN - NANO/GCC FUER LINUX ............... 51 2 EINE GUENSTIGE PROGRAMMIERPLATTFORM - DER RASPBERRY PI 53 2.1 WAS GENAU IST DER RASPBERRY PI? .................................................................... 53 2.1.1 DIE HARDWARE DES RASPBERRY PI .......................................................... 54 2.1.2 WELCHE BETRIEBSSYSTEME GIBT ES FUER DEN RASPBERRY PI? ..................... 56 5 INHALT 2.2 INSTALLATION EINES LINUX-BETRIEBSSYSTEMS AM BEISPIEL VON RASPBIAN ......... 57 2.2.1 WAS GENAU IST BUSTER? ......................................................................... 57 2.2.2 RASPBIAN AUS DEM INTERNET HERUNTERLADEN ........................................ 59 2.2.3 RASPBIAN INSTALLIEREN ........................................................................... 60 2.2.4 RASPBIAN MIT DER GRUNDKONFIGURATION STARTEN .................................. 63 2.2.5 WIE OFT BENOETIGEN SIE UPDATES UND WIE GEHEN SIE VOR? .................... 64 2.3 DIE KONFIGURATION DES RASPBERRY PI IM DETAIL .............................................. 66 2.4 DAS TOOL RASPI-CONFIG ........................................................................................ 66 2.4.1 DAS TOOL RASPI-CONFIG IM DETAIL ........................................................... 67 3 DAS ERSTE PROGRAMM 73 3.1 WAS LEISTET DER EDITOR? ..................................................................................... 74 3.2 WAS LEISTET DER COMPILER? ............................................................................... 74 3.3 WAS SIND INCLUDE-DATEIEN UND WOZU BENOETIGT MAN SIE? ............................. 75 3.4 DAS ERSTE PROGRAMM - DIE AUSGABE EINES TEXTES IN DER KONSOLE .............. 75 3.5 DAS HALLO-WELT-PROGRAMM IM DETAIL ............................................................. 76 3.6 WIE KOMPILIERT MAN EIN PROGRAMM UND FUEHRT ES ANSCHLIESSEND AUS? ........ 79 4 GRUNDLAGEN SI 4.1 SYMBOLE ............................................................................................................. 81 4.1.1 BEZEICHNER ............................................................................................ 81 4.1.2 SCHLUESSELWOERTER ................................................................................... 82 4.1.3 LITERALE .................................................................................................. 82 4.1.4 EINFACHE BEGRENZER .............................................................................. 84 4.1.5 KOMMENTARE ........................................................................................ 85 4.2 ZEICHENSAETZE ...................................................................................................... 88 4.2.1 BASIS-ZEICHENSATZ ................................................................................. 88 4.2.2 AUSFUEHRUNGSZEICHENSATZ (STEUERZEICHEN) .......................................... 89 4.2.3 TRIGRAPH-ZEICHEN ................................................................................. 92 4.3 STRINGS ................................................................................................................ 93 4.4 DAS EINFUEHRUNGSBEISPIEL MIT STRINGS ............................................................. 94 6 INHALT 5 BASISDATENTYPEN 95 5.1 WAS IST EIN BYTE UND WIE WERDEN ZAHLEN IN C GESPEICHERT? ....................... 95 5.2 WAS IST EINE VARIABLE UND WAS IST EIN VARIABIENTYP? .................................. 96 5.3 WAS IST EIN OPERAND? ....................................................................................... 97 5.4 WAS IST EIN PARAMETER? .................................................................................... 97 5.5 WIE SPEICHERT EIN PROZESSOR VARIABLEN, PARAMETER UND OPERANDEN? ....... 97 5.6 WAS SIND SPEICHERADRESSEN UND WARUM SIND SIE WICHTIG FUER C? ................ 97 5.7 DEKLARATION UND DEFINITION VON VARIABLEN ................................................... 98 5.8 ARRAY-DATENTYPEN (DATENFELDER) .................................................................... 99 5.9 STANDARD-DATENTYPEN ..................................................................................... 100 5.9.1 DER DATENTYP INT (INTEGER), STANDARDGROESSE 2 BYTES ........................ 100 5.9.2 VERWENDUNG DES DATENTYPS INT ...................................................... 102 5.9.3 DER DATENTYP LONG, STANDARDGROESSE 4 BYTE ...................................... 105 5.9.4 DER DATENTYP LONG LONG, STANDARDGROESSE 8 BYTE .............................. 106 5.9.5 DER DATENTYP SHORT, GROESSE 2 BYTE .................................................... 106 5.10 GANZZAHLIGE TYPEN MIT VORGEGEBENER BREITE - STDINT.H ........................ 107 5.10.1 INTTYPES.H (C99) ............................................................................... 109 5.11 DIE GLEITPUNKTTYPEN FLOAT UND DOUBLE, GROESSE 4 ODER 8 BYTE ............. 110 5.11.1 GLEITPUNKTTYPEN IM DETAIL .................................................................. 112 5.11.2 FLOAT IM DETAIL .................................................................................. 113 5.11.3 DOUBLE IM DETAIL .............................................................................. 113 5.11.4 LONG DOUBLE .......................................................................................... 114 5.11.5 EINIGES ZU N-STELLIGER GENAUIGKEIT ...................................................... 114 5.11.6 NUMERISCHE GLEITPUNKTPROBLEME ...................................................... 116 5.12 KOMPLEXE GLEITPUNKTTYPEN - COMPLEX.H ................................................. 118 5.13 DER DATENTYP CHAR, STANDARDGROESSE 1 BYTE ............................................... 120 5.14 NATIONALE CONTRA INTERNATIONALE ZEICHENSAETZE ............................................ 126 5.14.1 DER BREITZEICHEN-TYP WCHAR_T, GROESSE 2 BYTE ................................... 128 5.14.2 MULTIBYTE-ZEICHEN, GROESSE 2,4 ODER 8 BYTE ......................................... 129 5.15 BOOLESCHE WERTE - STDBOOL.H ..................................................................... 129 5.16 DER UNTERSCHIED ZWISCHEN VORZEICHENLOSEN UND VORZEICHEN BEHAFTETEN ZAHLEN ................................................................................ 131 5.17 LIMITS FUER GANZZAHL- UND GLEITPUNKTDATENTYPEN ........................................ 133 5.18 DER TYP VOID .................................................................................................. 136 5.19 NUMERISCHE KONSTANTEN ................................................................................. 137 5.19.1 GANZZAHLKONSTANTEN ........................................................................... 137 7 INHALT 5.19.2 GLEITPUNKTKONSTANTEN ......................................................................... 138 5.19.3 ZEICHENKONSTANTEN .............................................................................. 138 5.19.4 STRINGLITERALE (STRINGKONSTANTEN) ............................................... 138 5.20 UMWANDLUNGSVORGABEN FUER FORMATIERTE EIN-/AUSGABE ............................. 139 6 FORMATIERTE EIN-/AUSGABE MIT SCANF() UND PRINTFQ 147 6.1 FORMATIERTE EINGABE MIT SCANF() ................................................................. 147 6.1.1 DER ADRESSOPERATOR & ...................................................................... 149 6.1.2 PROBLEME UND DEREN BEHANDLUNG MIT SCANFQ ................................. 151 6.1.3 UEBERPRUEFEN AUF DAS RICHTIGE FORMAT ................................................... 154 6.1.4 ZUSAMMENFASSUNG ZU SCANFQ ......................................................... 156 6.2 FORMATIERTE AUSGABE MIT PRINTF() .............................................................. 157 7 OPERATOREN 161 7.1 WAS SIND OPERATOREN UND WOZU BENOETIGT MAN SIE IN C? ............................. 161 7.2 ARITHMETISCHE OPERATOREN .............................................................................. 162 7.2.1 DIVIDIEREN VON GANZZAHLEN .................................................................. 164 7.3 ERWEITERTE DARSTELLUNG ARITHMETISCHER OPERATOREN .................................... 165 7.4 INKREMENT- UND DEKREMENT-OPERATOREN ...................................................... 167 7.5 BIT-OPERATOREN .................................................................................................. 168 7.5.1 BITWEISES UND ...................................................................................... 169 7.5.2 BITWEISES ODER ..................................................................................... 171 7.5.3 BITWEISES XOR ....................................................................................... 172 7.5.4 BITWEISES KOMPLEMENT ........................................................................ 173 7.5.5 LINKSVERSCHIEBUNG ............................................................................... 173 7.5.6 RECHTSVERSCHIEBUNG ............................................................................ 175 7.5.7 REZEPT FUER FORTGESCHRITTENE ................................................................. 175 7.6 MAKROS FUER LOGISCHE OPERATOREN UND BIT-OPERATOREN - ISO646.H ......... 177 7.7 DER SIZEOF-OPERATOR ..................................................................................... 178 7.7.1 C VERSUS C++ .......................................................................................... 179 8 INHALT 8 TYPUMWANDLUNG ISI 8.1 AUTOMATISCHE IMPLIZITE DATENTYPUMWANDLUNG DURCH DEN C-COMPILER .... 181 8.1.1 IMPLIZITES CHAR NACH INT ............................................................... 182 8.1.2 IMPLIZITES FLOAT NACH DOUBLE ........................................................ 182 8.1.3 IMPLIZITE UMWANDLUNG IN EINEN KOMPLEXEN GLEITPUNKTTYP ............. 182 8.1.4 UEBLICHE ARITHMETISCHE DATENTYPUMWANDLUNG .................................. 183 8.2 WOZU BENOETIGT MAN DAS BENUTZERDEFINIERTE EXPLIZITE TYPECASTING? ....... 186 8.3 EXPLIZITE DATENTYPUMWANDLUNG MIT TYPECASTING AN BEISPIELEN .............. 186 9 KONTROLLSTRUKTUREN 189 9.1 VERZWEIGUNGEN MIT DER IF-BEDINGUNG ...................................................... 190 9.1.1 ANWEISUNGSBLOECKE ............................................................................... 190 9.2 DIE VERZWEIGUNG MIT EISE IF ....................................................................... 194 9.3 DIE VERZWEIGUNG MIT EISE .......................................................................... 196 9.4 DER !-OPERATOR (LOGISCHER NOT-OPERATOR) ..................................................... 200 9.5 LOGISCHES UND (&&) - LOGISCHES ODER (\|\|) .................................................... 202 9.6 DER BEDINGUNGSOPERATOR ?: ........................................................................ 205 9.7 FALLUNTERSCHEIDUNG: DIE SWITCH-VERZWEIGUNG ......................................... 207 9.7.1 DEFAULT ................................................................................................. 210 9.8 DIE WHILE-SCHLEIFE ........................................................................................ 212 9.8.1 ENDLOSSCHLEIFEN MIT WHILE ............................................................... 214 9.8.2 FEHLERVERMEIDUNG BEI WHILE-SCHLEIFEN ........................................... 215 9.9 DIE DO WHILE-SCHLEIFE ................................................................................... 216 9.10 DIE FOR-SCHLEIFE ............................................................................................. 221 9.10.1 EINSATZMOEGLICHKEITEN DER FOR-SCHLEIFE ........................................... 224 9.11 KONTROLLIERTER AUSSTIEG AUS SCHLEIFEN MIT BREAK ...................................... 229 9.11.1 CONTINUE ............................................................................................... 229 9.11.2 BREAK .................................................................................................... 230 9.12 DIREKTE SPRUENGE MIT GOTO - UND WARUM MAN SIE NICHT VERWENDEN SOLLTE .................................................................................... 231 9.13 EINIGE ANMERKUNGEN ZUM NOTATIONSSTIL ...................................................... 232 9.13.1 K&R-STIL ............................................................................................... 233 9.13.2 WHITESMITH-STIL ................................................................................... 233 9 INHALT 9.13.3 ALLMAN-STIL ............................................................................................ 233 9.13.4 GNU EMACS-STIL .................................................................................. 233 9.13.5 DER STIL DES AUTORS (K&R-IIKE) ..................................................... 233 9.14 EINIGE ANMERKUNGEN ZU EINEM GUTEN PROGRAMMIERSTIL ............................. 234 10 FUNKTIONEN 235 10.1 WAS SIND FUNKTIONEN? ...................................................................................... 235 10.2 WOZU DIENEN FUNKTIONEN? .............................................................................. 236 10.3 DEFINITION VON FUNKTIONEN .............................................................................. 236 10.4 FUNKTIONSAUFRUF ................................................................................................ 237 10.5 FUNKTIONSDEKLARATION ....................................................................................... 238 10.6 LOKALE VARIABLEN ............................................................................................... 241 10.7 GLOBALE VARIABLEN ............................................................................................ 243 10.8 STATISCHE VARIABLEN .......................................................................................... 245 10.9 SCHLUESSELWOERTER FUER VARIABLEN - SPEICHERKLASSEN ........................................ 246 10.9.1 AUTO ....................................................................................................... 246 10.9.2 EXTERN ................................................................................................... 247 10.9.3 REGISTER .................................................................................................. 247 10.9.4 STATIC ..................................................................................................... 247 10.10 TYP-QUALIFIZIERER ............................................................................................... 247 10.10.1 VOLATILE .................................................................................................. 247 10.10.2 CONST ..................................................................................................... 248 10.11 GELTUNGSBEREICH VON VARIABLEN ...................................................................... 248 10.12 SPEICHERKLASSEN-SPEZIFIZIERER FUER FUNKTIONEN ............................................. 250 10.12.1 EXTERN ................................................................................................... 250 10.12.2 STATIC ..................................................................................................... 250 10.12.3 VOLATILE .................................................................................................. 250 10.13 DATENAUSTAUSCH ZWISCHEN FUNKTIONEN ......................................................... 250 10.14 WERTUEBERGABE AN FUNKTIONEN (CALL-BY-VALUE) ............................................. 252 10.15 DER RUECKGABEWERT VON FUNKTIONEN ............................................................... 256 10.16 DIE HAUPTFUNKTION MAIN() ........................................................................... 258 10.17 WAS BEDEUTET DER RUECKGABEWERT BEIM BEENDEN EINES PROGRAMMS? ....... 260 10.17.1 PROGRAMMENDE AUSWERTEN ................................................................ 261 10.18 FUNKTIONEN DER LAUFZEITBIBLIOTHEK ................................................................ 264 10.19 GETRENNTES KOMPILIEREN VON QUELLDATEIEN .................................................. 264 10 INHALT 10.20 REKURSIVE FUNKTIONEN (REKURSION) ................................................................ 267 10.20.1 EXKURS: STACK ........................................................................................ 267 10.20.2 REKURSIONEN UND DER STACK ................................................................. 268 10.20.3 FAKULTAET ............................................................................................... 273 10.20.4 FIBONACCI-ZAHLEN ................................................................................. 274 10.20.5 GROESSTER GEMEINSAMER TEILER (GGT) ..................................................... 275 10.21 INLINE-FUNKTIONEN ........................................................................................ 280 11 PRAEPROZESSOR-DIREKTIVEN 283 11.1 MIT TTINCLUDE DATEIEN EINBINDEN ................................................................ 284 11.2 WICHTIGE VORDEFINIERTE HEADERDATEIEN FUER C ................................................ 285 11.3 MAKROS UND KONSTANTEN - #DEFINE ........................................................... 287 11.3.1 SYMBOLISCHE KONSTANTEN MIT #DEFINE ............................................ 287 11.3.2 MAKROS MIT #DEFINE ......................................................................... 292 11.4 BEDINGTE KOMPILIERUNG MIT #IFDEF ............................................................ 296 11.5 VORDEFINIERTE PRAEPROZESSOR-DIREKTIVEN (ANSI C) .......................................... 301 11.6 EINEN MAKROPARAMETER DURCH EINEN STRING ERSETZEN .................................. 304 11.7 #UNDEF - MAKRONAMEN WIEDER AUFHEBEN ................................................ 305 11.8 FEHLERMELDUNGEN AUSGEBEN MIT #ERROR .................................................... 306 11.9 #PRAGMA (GILT NUR FUER WINDOWS) ................................................................ 307 12 ARRAYS 309 12.1 ARRAYS DEKLARIEREN ............................................................................................ 309 12.2 INITIALISIERUNG UND ZUGRIFF AUF ARRAYS ........................................................... 311 12.2.1 GUELTIGKEITSBEREICH VON ARRAYS ............................................................. 316 12.3 ARRAYS VERGLEICHEN ........................................................................................... 318 12.4 ANZAHL DER ELEMENTE EINES ARRAYS ERMITTELN ................................................ 320 12.5 UEBERGABE VON ARRAYS AN FUNKTIONEN ............................................................ 321 12.6 ARRAYS AUS FUNKTIONEN ZURUECKGEBEN ............................................................. 324 12.7 PROGRAMMBEISPIEL ZU ARRAYS .......................................................................... 325 12.8 ARRAY-WERTE UEBER DIE TASTATUR EINLESEN ....................................................... 328 12.9 MEHRDIMENSIONALE ARRAYS ............................................................................... 329 12.9.1 MEHRDIMENSIONALE ARRAYS INITIALISIEREN ............................................. 330 11 INHALT 12.9.2 UEBERGABE VON ZWEI- BZW. MEHRDIMENSIONALEN ARRAYS AN FUNKTIONEN 343 12.10 ARRAYS IN EINE TABELLENKALKULATION EINLESEN (CSV-DATEIEN) ....................... 345 12.11 STRINGS/ZEICHENKETTEN (CHAR-ARRAY) .......................................................... 346 12.11.1 VOM STRING ZUR BINAERZAHL ..................................................................... 350 12.12 EINLESEN VON STRINGS ......................................................................................... 353 12.13 DIE STANDARD-BIBLIOTHEK STRING.H ............................................................... 356 12.13.1 STRCAT()-STRINGS ANEINANDERHAENGEN ............................................... 356 12.13.2 STRCHR()-EIN ZEICHEN IM STRING SUCHEN ........................................... 357 12.13.3 STRCMPO-STRINGSVERGLEICHEN ......................................................... 358 12.13.4 STRCPYO - EINEN STRING KOPIEREN ....................................................... 359 12.13.5 STRCSPN()-EINEN TEILSTRING ERMITTELN .............................................. 360 12.13.6 STRLENQ - LAENGE EINES STRINGS ERMITTELN ........................................... 361 12.13.7 STRNCATQ-STRING MIT N ZEICHEN ANEINANDERHAENGEN ....................... 362 12.13.8 STRNCMPO - N ZEICHEN VON ZWEI STRINGS MITEINANDER VERGLEICHEN ............................................................................................ 363 12.13.9 STRNCPYO - STRING MIT N ZEICHEN KOPIEREN ....................................... 363 12.13.10 STRPBRK() - NACH DEM AUFTRETEN BESTIMMTER ZEICHEN SUCHEN ........ 364 12.13.11 STRRCHR() - DAS LETZTE AUFTRETEN EINES BESTIMMTEN ZEICHENS IM STRING SUCHEN ................................................................................... 365 12.13.12 STRSPNQ - DAS ERSTE AUFTRETEN EINES ZEICHENS, DAS NICHT VORKOMMT ............................................................................................. 365 12.13.13 STRSTRQ - EINEN STRING NACH DEM AUFTRETEN EINES TEILSTRINGS DURCHSUCHEN ......................................................................................... 366 12.13.14 STRTOK()-EINEN STRING ANHAND BESTIMMTER ZEICHEN ZERLEGEN ........ 367 13 ZEIGER (POINTER) 369 13.1 DER UNTERSCHIED ZWISCHEN EINER NORMALEN VARIABLEN UND EINEM ZEIGER ............................................................................................. 369 13.2 ZEIGER DEKLARIEREN ............................................................................................ 370 13.3 ZEIGER INITIALISIEREN .......................................................................................... 371 13.3.1 SPEICHERGROESSE VON ZEIGERN ................................................................. 383 13.4 ZEIGERARITHMETIK .............................................................................................. 385 13.5 ZEIGER, DIE AUF ANDERE ZEIGER VERWEISEN ....................................................... 386 13.5.1 SUBTRAKTION ZWEIER ZEIGER ................................................................... 387 13.6 TYPENSICHERUNG BEI DER DEREFERENZIERUNG ................................................... 389 13.7 ZEIGER ALS FUNKTIONSPARAMETER (CALL-BY-REFERENCE) .................................... 389 13.7.1 ZEIGER ALS RUECKGABEWERT ...................................................................... 393 12 INHALT 13.8 ARRAY UND ZEIGER .............................................................................................. 396 13.9 ZEIGERAUFSTRINGS ............................................................................................. 403 13.9.1 ZEIGER AUF KONSTANTE OBJEKTE (READ-ONLY-ZEIGER) .............................. 404 13.10 ZEIGER AUF ZEIGER UND STRINGTABELLEN ............................................................ 405 13.10.1 STRINGTABELLEN ...................................................................................... 407 13.11 ZEIGER AUF FUNKTIONEN ..................................................................................... 414 13.12 VOID-ZEIGER ........................................................................................................ 420 13.13 AEQUIVALENZ ZWISCHEN ZEIGERN UND ARRAYS ..................................................... 423 13.14 DER RESTRICT-ZEIGER ........................................................................................ 426 14 KOMMANDOZEILENARGUMENTE 429 14.1 ARGUMENTE AN DIE HAUPTFUNKTION UEBERGEBEN ............................................. 430 14.2 ARGUMENTE AUS DER KOMMANDOZEILE AUSWERTEN ......................................... 435 15 DYNAMISCHE SPEICHERVERWALTUNG 44I 15.1 DAS SPEICHERKONZEPT ....................................................................................... 442 15.1.1 CODE-SPEICHER ..................................................................................... 442 15.1.2 DATEN-SPEICHER .................................................................................... 443 15.1.3 STACK-SPEICHER ..................................................................................... 443 15.1.4 HEAP-SPEICHER ..................................................................................... 443 15.2 SPEICHERALLOKATION MIT MALLOC() ................................................................ 444 15.3 DAS NULL-MYSTERIUM ....................................................................................... 447 15.3.1 NULL FUER FORTGESCHRITTENE ................................................................... 447 15.3.2 WAS JETZT - NULL, 0 ODER 0 ...? ........................................................... 449 15.3.3 ZUSAMMENGEFASST .............................................................................. 450 15.4 SPEICHERRESERVIERUNG UND IHRE PROBLEME ..................................................... 450 15.5 FREE() - SPEICHER WIEDER FREIGEBEN ............................................................ 452 15.5.1 EINIGE ERGAENZENDE DINGE ZUR FREISPEICHERVERWALTUNG ...................... 455 15.5.2 PROZESSINTERNE FREISPEICHERVERWALTUNG ............................................. 457 15.6 DYNAMISCHE ARRAYS .......................................................................................... 460 15.7 SPEICHER DYNAMISCH RESERVIEREN MIT REALLOCQ UND CALLOC() ................. 464 15.8 SPEICHER VOM STACK ANFORDERN MIT ALLOCA() (NICHT ANSI C) ..................... 468 15.9 ERGAENZENDE ANMERKUNGEN ZU FREEQ .......................................................... 468 13 INHALT 15.10 ZWEIDIMENSIONALE DYNAMISCHE ARRAYS .......................................................... 469 15.11 WAS MUSS MAN TUN, WENN DIE SPEICHERALLOKATION FEHLSCHLAEGT? ................ 472 15.11.1 SPEICHERANFORDERUNG REDUZIEREN ........................................................ 473 15.11.2 SPEICHERANFORDERUNGEN AUFTEILEN ....................................................... 474 15.11.3 EINEN PUFFER KONSTANTER GROESSE VERWENDEN ....................................... 476 15.11.4 VOR DER ALLOKATION AUF EINE FESTPLATTE ZWISCHENSPEICHERN .............. 476 15.11.5 NUR SO VIEL SPEICHER ANFORDERN WIE NOETIG ............................................ 476 16 STRUKTUREN 479 16.1 BENUTZERDEFINIERTE TYPENDEFINITIONEN MIT TYPEDEF ............................... 479 16.2 WAS IST EIN STRUKTURIERTER DATENTYP UND WOZU BENOETIGT MAN IHN IN C? ... 480 16.3 STRUKTUREN MIT TYPEDEF STRUCT DEKLARIEREN ............................................... 480 16.4 INITIALISIERUNG UND ZUGRIFF AUF STRUKTUREN .................................................... 482 16.5 STRUKTUREN ALS WERTUEBERGABE AN EINE FUNKTION BENUTZEN ........................ 491 16.6 STRUKTUREN ALS RUECKGABEWERT EINER FUNKTION BENUTZEN ............................. 493 16.7 STRUKTUREN MITEINANDER VERGLEICHEN ............................................................. 496 16.8 ARRAYS VON STRUKTUREN ERSTELLEN ..................................................................... 497 16.9 STRUKTUREN IN STRUKTUREN (NESTED STRUCTURES) .............................................. 504 16.10 WEITERE SPEZIELLE DATENTYPEN ........................................................................ 514 16.10.1 UNIONS .................................................................................................. 516 16.10.2 DER AUFZAEHLUNGSTYP ENUM .............................................................. 521 16.10.3 WEITERE TYPDEFINITIONEN MIT TYPEDEF ............................................. 524 16.11 ATTRIBUTE VON STRUKTUREN VERAENDERN ............................................................. 525 16.12 BITFELDER ............................................................................................................. 529 16.13 DAS OFFSETOF-MAKRO ...................................................................................... 536 17 EIN-/AUSGABE-FUNKTIONEN 539 17.1 WAS IST EINE DATEI AUS SICHT DER PROGRAMMIERSPRACHE C? .......................... 539 17.2 FORMATIERTE UND UNFORMATIERTE EIN-/AUSGABE ............................................ 540 17.3 HOEHERE EIN-/AUSGABE-FUNKTIONEN MIT STDIO.H ........................................ 540 17.3.1 EINE DATEI MIT FOPEN OEFFNEN ............................................................ 542 17.3.2 ZEICHENWEISE LESEN UND SCHREIBEN - GETCHAR() UND PUTCHARQ .... 548 17.3.3 ZEICHENWEISE LESEN UND SCHREIBEN - PUTC()/FPUTC() UND GETC()/FGETC() ................................................................................. 553 14 INHALT 17.3.4 EINE GEOEFFNETE DATEI MIT FCLOSE() WIEDER SCHLIESSEN (WICHTIG!) ...... 559 17.3.5 FORMATIERTE EIN-/AUSGABEN MIT FPRINTFQ UND FSCANFQ ............... 563 17.4 STREAMS (EIN-/AUSGABE-DATENSTROEME) .......................................................... 568 17.4.1 WAS UNTERSCHEIDET EINEN STREAM VON EINER DATEI? ............................ 568 17.4.2 STANDARD-STEAMS IN C .......................................................................... 568 17.4.3 FEHLERBEHANDLUNG VON STREAMS - FEOFQ, FERRORQ UND CLEARERRQ .................................................................................... 571 17.4.4 GELESENE ZEICHEN IN DIE EINGABE ZURUECKSCHIEBEN - UNGETCQ ........ 573 17.4.5 DEN TASTATURPUFFER LEEREN - FFLUSH () ............................................... 575 17.4.6 EINEN STREAM POSITIONIEREN - FSEEKQ, REWINDQ UND FTELL() ..... 576 17.4.7 EINEN STREAM POSITIONIEREN - FSETPOSQ, FGETPOSQ ...................... 581 17.4.8 ZEILENWEISE EIN-/AUSGABE IN STREAMS ................................................ 583 17.5 SPEZIELLE EIN-/AUSGABE-FUNKTIONEN FUER STREAMS ......................................... 597 17.5.1 BLOCKWEISE LESEN UND SCHREIBEN - FREAD() UND FWRITE() .............. 597 17.5.2 EINE DATEI ERNEUT OEFFNEN - FREOPENQ .............................................. 608 17.5.3 EINE DATEI LOESCHEN ODER UMBENENNEN - REMOVE() UND RENAMEQ ............................................................... 609 17.5.4 PUFFERUNG EINSTELLEN - SETBUFQ UND SETVBUFQ ............................ 612 17.5.5 TEMPORAERE DATEIEN ERZEUGEN - TMPFILEQ UND TMPNAMQ .......... 619 17.5.6 FEHLER BEI DER EIN-/AUSGABE ABFANGEN UND BEHANDELN ..................... 624 17.5.7 FORMATIERT IN EINEN STRING SCHREIBEN UND FORMATIERT AUS EINEM STRING LESEN - SSCANFQ UND SPRINTFQ ............................................ 628 17.5.8 EIN FORTGESCHRITTENES THEMA ............................................................... 634 17.6 LOW-LEVEL-DATEI-I/O-FUNKTIONEN (NICHT ANSI C) .......................................... 643 17.6.1 DATEIEN OEFFNEN MIT OPENQ ............................................................... 643 17.6.2 DATEIEN SCHLIESSEN MIT CLOSE() .......................................................... 651 17.6.3 DATEI ERZEUGEN - CREATQ .................................................................. 652 17.6.4 SCHREIBEN UND LESEN - WRITE() UND READQ .................................... 652 17.6.5 DEN FILE-DESKRIPTOR MIT ISEEKQ POSITIONIEREN ................................. 663 17.6.6 EINEN FILE-DESKRIPTOR VON EINEM STREAM MIT FILENO() ABLEITEN ...... 664 17.6.7 STREAM VON FILE-DESKRIPTOR MIT FDOPEN() ABLEITEN ......................... 665 17.6.8 GERAETEDATEIEN UNTER LINUX - ZUGRIFF AUF MAUS UND FRAMEBUFFER ..... 667 18 ATTRIBUTE VON DATEIEN UND DAS ARBEITEN MIT VERZEICHNISSEN (NICHT ANSI C) 673 18.1 DIE ATTRIBUTE EINER DATEI MIT STAT() ERMITTELN ......................................... 673 18.1.1 STATQ - ST_MODE .......................................................................... 674 18.1.2 STATQ - ST_SIZE .............................................................................. 680 18.1.3 STATQ - ST_ATIME, ST_MTIME UND ST_CTIME ........................... 682 15 INHALT 18.1.4 STATQ - ST GID UND ST UID ........................................................ 686 18.1.5 STATQ - ST_NLINK, STJNO ............................................................ 687 18.1.6 STATQ - ST_DEV, ST_RDEV ............................................................ 688 18.2 PRUEFEN DES ZUGRIFFSRECHTS MIT ACCESSQ....................................................... 691 18.3 VERZEICHNISFUNKTIONEN .................................................................................... 693 18.3.1 VERZEICHNIS ERSTELLEN, LOESCHEN UND WECHSELN MIT MKDIRQ, RMDIR UND CHDIR ............................................................................ 693 18.3.2 IN DAS ARBEITSVERZEICHNIS WECHSELN MIT GETCWDQ .......................... 699 18.3.3 VERZEICHNISSE OEFFNEN, LESEN UND SCHLIESSEN - OPENDIRQ, READDIRQ UND CLOSEDIRQ ................................................................. 701 19 ARBEITEN MIT VARIABEL LANGEN ARGUMENTLISTEN - STDARG.H 707 19.1 WAS IST EINE ELLIPSE UND WIE WERDEN MIT IHR PARAMETER UEBERGEBEN? ........ 707 19.2 WIE KANN MAN MIT STDARG.H DIE PARAMETERLISTE ABFRAGEN? ................... 708 19.3 MAKROS IN STDARG.H - VAJIST, VA_ARG, VA_START UND VA_END ................................................................................................... 708 19.4 DIE ARGUMENTLISTE AM ANFANG ODER ENDE KENNZEICHNEN ............................ 709 19.5 VPRINTF (), VSPRINTF(), VFSPRINTF() UND VSNSPRINTF() ......................... 714 19.6 VARIADIC MAKROS - ___VA ARGS__ ................................................................. 719 20 ZEITROUTINEN 723 20.1 DIE HEADERDATEI TIME.H ............................................................................... 723 20.1.1 KONSTANTEN IN DER HEADERDATEI TIME.H ........................................... 725 20.1.2 DATUMS-UND ZEITFUNKTIONEN IN TIME.H .......................................... 725 20.2 LAUFZEITMESSUNG (PROFILING) ........................................................................... 735 20.3 BESONDERHEITEN BEIM RASPBERRY PI ................................................................ 737 21 WEITERE HEADERDATEIEN UND IHRE FUNKTIONEN (ANSI C) 739 21.1 TESTMOEGLICHKEITEN UND FEHLERSUCHE - ASSERT.H ....................................... 739 21.2 ZEICHENKLASSIFIZIERUNG UND UMWANDLUNG - CTYPE.H ............................. 741 16 INHALT 21.3 MATHEMATISCHE FUNKTIONEN - MATH.H , TGMATH.H UND COMPLEX.H 746 21.3.1 FUNKTIONEN FUER REELLE UND KOMPLEXE GLEITPUNKTTYPEN ...................... 747 21.3.2 FUNKTIONEN NUR FUER REELLE GLEITPUNKTTYPEN ........................................ 749 21.3.3 FUNKTIONEN NUR FUER KOMPLEXE GLEITPUNKTTYPEN ................................. 751 21.3.4 TYPENGENERISCHE MAKROS- TGMATH.H ............................................ 752 21.3.5 GLEITPUNKTWERTE KLASSIFIZIEREN ........................................................... 754 21.3.6 MAKRO ZUM VERGLEICHEN VON REELLEN ZAHLEN ...................................... 755 21.3.7 ZUGRIFF AUF DIE GLEITPUNKTUMGEBUNG- FENV.H ............................... 756 21.4 EINIGE NUETZLICHE FUNKTIONEN IN STDLIB.H .................................................... 759 21.4.1 PROGRAMMBEENDIGUNG - EXITQ, _EXIT(), ATEXIT() UND ABORTQ 759 21.4.2 STRINGS IN NUMERISCHE WERTE KONVERTIEREN ........................................ 763 21.4.3 BESSERE ALTERNATIVE-STRINGS IN NUMERISCHE WERTE KONVERTIEREN .... 765 21.4.4 ZUFALLSZAHLEN ....................................................................................... 770 21.4.5 ABSOLUTWERTE, DER QUOTIENT UND DER REST VON DIVISIONEN ................. 773 21.4.6 SUCHEN UND SORTIEREN - QSORT() UND BSEARCHQ ............................ 774 21.4.7 SYSTEMQ ........................................................................................... 777 21.5 LAENDERSPEZIFISCHE EIGENHEITEN - LOCALE.H ................................................ 779 21.6 NICHTLOKALE SPRUENGE - SETJMP.H ................................................................ 783 21.7 EINIGE NUETZLICHE FUNKTIONEN IN SIGNAL.H .................................................... 787 21.8 DIE MEM...-FUNKTIONEN ZUR SPEICHERMANIPULATION - STRING.H .......... 792 21.8.1 MEMCHRO -SUCHE NACH EINZELNEN ZEICHEN .................................... 793 21.8.2 MEMCMPO - BESTIMMTE ANZAHL VON BYTES VERGLEICHEN ................ 793 21.8.3 MEMCPYO - BESTIMMTE ANZAHL VON BYTES KOPIEREN ...................... 794 21.8.4 MEMMOVEO - BESTIMMTE ANZAHL VON BYTES KOPIEREN ................... 795 21.8.5 MEMSETQ - SPEICHERBEREICH MIT BESTIMMTEN ZEICHEN AUFFUELLEN ... 796 22 DYNAMISCHE DATENSTRUKTUREN 797 22.1 LINEARE LISTEN (EINFACH VERKETTETE LISTEN) ..................................................... 797 22.1.1 ERSTES ELEMENT DER LISTE LOESCHEN ......................................................... 805 22.1.2 EIN BELIEBIGES ELEMENT IN DER LISTE LOESCHEN ....................................... 807 22.1.3 ELEMENTE DER LISTE AUSGEBEN .............................................................. 810 22.1.4 EINE VOLLSTAENDIGE LISTE AUF EINMAL LOESCHEN ........................................ 815 22.1.5 ELEMENT IN DIE LISTE EINFUEGEN .............................................................. 818 22.2 DOPPELT VERKETTETE LISTEN .............................................................................. 831 22.3 STACKS NACH DEM LIFO-(LAST-IN-FIRST-OUT-)PRINZIP ......................................... 849 22.4 QUEUES NACH DEM FIFO-PRINZIP ...................................................................... 869 22.5 DYNAMISCHES ARRAY MIT FLEXIBLEN ELEMENTEN ............................................... 878 17 INHALT 23 ALGORITHMEN SSI 23.1 WAS SIND ALGORITHMEN? ................................................................................... 881 23.2 BEISPIELE FUER ALGORITHMEN ............................................................................... 883 23.2.1 SORTIERALGORITHMEN .............................................................................. 883 23.2.2 SUCHALGORITHMEN UND BAEUME ............................................................. 911 23.2.3 STRINGMATCHING .................................................................................... 940 23.2.4 PATTERN MATCHING DURCH REGULAERE AUSDRUECKE ..................................... 952 23.2.5 BACKTRACKING ........................................................................................ 959 23.2.6 DER WEG DURCH DEN IRRGARTEN .............................................................. 959 23.2.7 KRYPTOGRAFISCHE HASHING-ALGORITHMEN .............................................. 974 23.2.8 WOZU BENOETIGT MAN HASHING IN DER KRYPTOGRAFIE? .............................. 974 23.2.9 WICHTIGE KRYPTOGRAFISCHE HASHING-VERFAHREN ................................... 974 24 MYSQL UND C 989 24.1 AUFBAU EINES DATENBANKSYSTEMS .................................................................. 989 24.1.1 WARUM WURDEN DATENBANKSYSTEME (DBS) ENTWICKELT? .................... 990 24.1.2 DAS DATENBANK-MANAGEMENT-SYSTEM (DBMS) .................................. 991 24.1.3 RELATIONALE DATENBANKEN .................................................................... 993 24.1.4 MIT C EIGENE CLIENTS FUER SQL ENTWICKELN MITHILFE DER ODBC-API ...... 994 24.2 MYSQL INSTALLIEREN ............................................................................................ 995 24.2.1 LINUX ..................................................................................................... 995 24.2.2 WINDOWS .............................................................................................. 996 24.2.3 DEN CLIENT MYSQL STARTEN ................................................................. 997 24.3 CRASHKURS SQL ................................................................................................... 999 24.3.1 WAS IST SQL? ......................................................................................... 999 24.3.2 DIE DATENTYPEN VON (MY)SQL .............................................................. 1000 24.3.3 EINE DATENBANK ERZEUGEN ................................................................... 1002 24.3.4 EINE DATENBANK LOESCHEN ...................................................................... 1003 24.3.5 DATENBANK WECHSELN ........................................................................... 1004 24.3.6 EINE TABELLE ERSTELLEN ........................................................................... 1004 24.3.7 DIE TABELLE ANZEIGEN ........................................................................... 1005 24.3.8 TABELLENDEFINITION UEBERPRUEFEN ............................................................ 1005 24.3.9 TABELLEN LOESCHEN .................................................................................. 1006 24.3.10 EIN BACKUP ERSTELLEN ............................................................................ 1006 24.3.11 DIE STRUKTUR EINER TABELLE AENDERN ....................................................... 1006 24.3.12 DATENSAETZE EINFUEGEN ........................................................................... 1007 24.3.13 DATENSAETZE AUSWAEHLEN ....................................................................... 1007 24.3.14 EIN FORTGESCHRITTENES SZENARIO ........................................................... 1009 18 INHALT 243.15 DATENSAETZE LOESCHEN ............................................................................. 1010 243.16 DATENSATZ AENDERN ............................................................................... 1011 243.17 ZUGRIFFSRECHTE IN MYSQL ..................................................................... 1011 243.18 UEBERSICHT UEBER EINIGE SQL-KOMMANDOS ............................................. 1012 24.4 DIE MYSQL-C-API .............................................................................................. 1014 24.4.1 GRUNDLAGEN ZUR PROGRAMMIERUNG EINES MYSQL-CLIENTS .................... 1014 24.4.2 CLIENT-PROGRAMM MIT DEM GCC UNTER LINUX UND DEM CYGWIN- GCC-COMPILER UNTER WINDOWS ........................................................... 1015 24.43 MYSQL CLIENT-PROGRAMME MIT DEM VC++ COMPILER UND DEM BORLAND FREEWARE COMPILER ................................................................ 1016 24.4.4 TROUBLESHOOTING .................................................................................. 1018 24.4.5 DAS ERSTE CLIENT-PROGRAMM - VERBINDUNG MIT DEM MYSQL-SERVER HERSTELLEN ............................................................................................. 1018 24.4.6 MYSQL-KOMMANDOZEILEN-OPTIONEN .................................................. 1023 24.4.7 ANFRAGE AN DEN SERVER ......................................................................... 1026 24.5 MYSQL UND C MIT CGI ....................................................................................... 1045 24.5.1 HTML-EINGABEFORMULAR ...................................................................... 1045 24.5.2 DIE CGI-ANWENDUNG ADD_DB.CGI ..................................................... 1047 24.53 DIE CGI-ANWENDUNG SEARCH_DB.CGI ................................................. 1054 24.6 FUNKTIONSUEBERSICHT .......................................................................................... 1063 24.7 DATENTYPENUEBERSICHT DER C-API ..................................................................... 1066 24.8 WEITERFUEHRENDE LITERATUR ZU DATENBANKEN ................................................. 1067 25 NETZWERKPROGRAMMIERUNG UND CROSS-PLATTFORM-ENTWICKLUNG 1069 25.1 BEGRIFFE ZUR NETZWERKTECHNIK ........................................................................ 1070 25.1.1 ETHERNET-FRAMES .................................................................................. 1070 25.1.2 IP-ADRESSEN .......................................................................................... 1071 25.1.3 PORTNUMMERN ...................................................................................... 1073 25.1.4 HOST- UND DOMAINNAMEN ................................................................... 1074 25.1.5 NAMESERVER ......................................................................................... 1074 25.1.6 DAS IP-PROTOKOLL ................................................................................... 1075 25.1.7 TCP UND UDP ........................................................................................ 1075 25.2 WAS SIND SOCKETS UND WIE LEGT MAN SIE IN C AN? .......................................... 1076 25.3 HEADERDATEIEN FUER DIE NETZWERKPROGRAMMIERUNG ..................................... 1077 25.3.1 LINUX/UNIX .......................................................................................... 1077 25.3.2 WINDOWS .............................................................................................. 1078 19 INHALT 25.4 DAS CLIENT-SERVER-PRINZIP ................................................................................. 1080 25.5 ERSTELLEN EINER CLIENT-ANWENDUNG ................................................................. 1082 25.5.1 SOCKETQ - ERZEUGEN EINES KOMMUNIKATIONSENDPUNKTES ............... 1082 25.5.2 CONNECTQ - EIN CLIENT STELLT EINE VERBINDUNG ZUM SERVER HER ....... 1084 25.5.3 SENDEN UND EMPFANGEN VON DATEN .................................................... 1089 25.5.4 CLOSEQ UND CLOSESOCKETQ .............................................................. 1092 25.6 ERSTELLEN EINER SERVER-ANWENDUNG ................................................................ 1092 25.6.1 BINDQ - FESTLEGEN EINER ADRESSE AUS DEM NAMENSRAUM .............. 1092 25.6.2 LISTENQ - WARTESCHLANGE FUER EINGEHENDE VERBINDUNGEN EINRICHTEN ............................................................................................. 1094 25.6.3 ACCEPTQ UND DIE SERVER-HAUPTSCHLEIFE ............................................ 1095 25.7 EINEINFACHERTCP-ECHO-SERVER ....................................................................... 1098 25.7.1 DER CLIENT ............................................................................................. 1098 25.7.2 DER SERVER ............................................................................................ 1101 25.8 CROSS-PLATTFORM-DEVELOPMENT ....................................................................... 1105 25.8.1 ABSTRACTION LAYER ................................................................................. 1105 25.8.2 HEADERDATEI FUER LINUX/UNIX ............................................................... 1106 25.8.3 LINUX/UNIX-QUELLCODEDATEI ................................................................ 1107 25.8.4 HEADERDATEI FUER MS-WINDOWS ............................................................. 1111 25.8.5 WINDOWS-QUELLCODEDATEI ................................................................... 1111 25.8.6 ALL TOGETHER-DIE MAIN()-FUNKTIONEN ............................................. 1115 25.8.7 EIN UDP-BEISPIEL .................................................................................. 1118 25.8.8 MEHRERE CLIENTS GLEICHZEITIG BEHANDELN ............................................ 1121 25.9 WEITERE ANMERKUNGEN ZUR NETZWERKPROGRAMMIERUNG UND LITERATUREMPFEHLUNGEN ........................................................................... 1128 25.9.1 DAS DATENFORMAT ................................................................................. 1128 25.9.2 DER PUFFER ............................................................................................. 1129 25.9.3 PORTABILITAET ........................................................................................... 1130 25.9.4 VON IPV4 NACH IPV6 ............................................................................... 1130 25.9.5 RFC-DOKUMENTE (REQUEST FOR COMMENTS) ......................................... 1132 25.9.6 SICHERHEIT ............................................................................................. 1132 25.9.7 LITERATUREMPFEHLUNGEN ....................................................................... 1133 26 PARALLELES RECHNEN 1135 26.1 WAS IST MULTITASKING UND WIE WIRD ES REALISIERT? ......................................... 1135 26.2 BRAUCHT MAN SPEZIELLE PROZESSOREN FUER MULTITASKING? ................................ 1136 26.2.1 SINGLE-PROZESSORSYSTEME ..................................................................... 1137 20 INHALT 26.2.2 HYPERTHREADING ................................................................................... 1138 26.3 BRAUCHT MAN SPEZIELLE MULTITASKING-BETRIEBSSYSTEME? ............................. 1139 26.4 PROGRAMMIERTECHNIKEN DER PARALLELISIERUNG ................................................ 1139 26.4.1 AUTOMATISCHE PARALLELISIERUNG ........................................................... 1139 26.4.2 HALBAUTOMATISCHE PARALLELISIERUNG .................................................... 1139 26.4.3 ECHTE PARALLELISIERUNG .......................................................................... 1140 26.5 VOM PROZESS ZUM THREAD ............................................................................... 1140 26.6 MIT POSIX-THREADS PROGRAMMIEREN .............................................................. 1144 26.6.1 EIN SERIELLES BEISPIEL ............................................................................ 1144 26.6.2 DAS GRUNDGERUEST FUER EIN PROGRAMM MIT MEHREREN THREADS ............. 1146 26.6.3 ZUSAMMENFASSUNG .............................................................................. 1152 27 SICHERES PROGRAMMIEREN 1153 27.1 BUFFER OVERFLOW (SPEICHERUEBERLAUF) .............................................................. 1154 27.1.1 WAS VERURSACHT BUFFER OVERFLOWS? ..................................................... 1154 27.1.2 WARUM SIND BUFFER OVERFLOWS KRITISCH FUER DIE SICHERHEIT? ................ 1155 27.1.3 WIE MAN BUFFER OVERFLOWS VERMEIDET ................................................ 1164 27.1.4 GEGENMASSNAHMEN ZUM BUFFER OVERFLOW, WENN DAS PROGRAMM FERTIG IST ............................................................................. 1168 27.2 STACK OVERFLOW (STAPELUEBERLAUF) .................................................................... 1172 27.2.1 WAS VERURSACHT STACK OVERFLOWS? ...................................................... 1173 27.2.2 WARUM IST EIN STAPELUEBERLAUF KRITISCH FUER DIE SICHERHEIT? ................. 1173 27.2.3 WIE MAN STACK OVERFLOWS VERHINDERT ................................................ 1173 27.3 MEMORY LEAKS (SPEICHERLECKS) ....................................................................... 1174 27.3.1 BIBLIOTHEKEN UND TOOLS ZU MEMORY LEAKS .......................................... 1178 27.3.2 TIPPS ZU SICHERHEITSPROBLEMEN .......................................................... 1180 27.4 WEITERFUEHRENDE LITERATUR ZU SICHEREM PROGRAMMIEREN ............................. 1180 28 WIE GEHT * S JETZT WEITER? USI 28.1 GUI-PROGRAMMIERUNG - GRAFISCHE OBERFLAECHEN ........................................... 1182 28.1.1 LOW-LEVEL-GRAFIKPROGRAMMIERUNG ..................................................... 1182 28.1.2 HIGH-LEVEL-GRAFIKPROGRAMMIERUNG .................................................... 1183 28.1.3 RAD-TOOLS ............................................................................................ 1184 28.1.4 MULTIMEDIA-GRAFIKPROGRAMMIERUNG .................................................. 1184 21 INHALT 28.2 GRAFIKPROGRAMMIERUNG UNTER WINDOWS ....................................................... 1185 28.2.1 DAS GERAETEKONTEXT-HANDLE (HDC) ....................................................... 1189 28.2.2 UEBER DAS HDC IN EIN FENSTER ZEICHNEN (VISUAL STUDIO 2013 UND HOEHER) .......................................................... 1190 28.2.3 UEBER EIN HDC IN DIE KONSOLE ZEICHNEN (BORLAND C++ 5.5) .................. 1193 28.2.4 DIE METHODE BITBLT .............................................................................. 1195 28.2.5 GRAFIKEN IM FENSTER SCHNELL AUFFRISCHEN ............................................. 1196 28.3 GRAFIKPROGRAMMIERUNG UNTER LINUX (BEISPIEL RASPBERRY PI) ...................... 1197 28.3.1 DIE FRAMEBUFFER-GERAETEDATEI ............................................................. 1198 28.3.2 IN DEN FRAMEBUFFER ZEICHNEN .............................................................. 1198 28.3.3 DEN BILDSCHIRMINHALT SCHNELL AUFFRISCHEN .......................................... 1199 28.3.4 EIN PAAR GRAFIKPRIMITIVEN .................................................................... 1202 28.3.5 WEITERFUEHRENDE LITERATUR ZUM THEMA GRAFIKPROGRAMMIERUNG ........ 1205 ANHANG 1207 A OPERATOREN ........................................................................................................ 1207 A.L RANGFOLGE DER OPERATOREN ................................................................... 1207 A.2 ASCII-CODE-TABELLE ............................................................................... 1209 A.3 RESERVIERTE SCHLUESSELWOERTER IN C .......................................................... 1210 A.4 STANDARD-HEADERDATEIEN DER ANSI-C-BIBLIOTHEK ................................. 1210 INDEX ............................................................................................................................... 1213 22
any_adam_object	1
author	Wolf, Jürgen 1974- Krooß, René
author_GND	(DE-588)132691256 (DE-588)1211561577
author_facet	Wolf, Jürgen 1974- Krooß, René
author_role	aut aut
author_sort	Wolf, Jürgen 1974-
author_variant	j w jw r k rk
building	Verbundindex
bvnumber	BV046748654
classification_rvk	ST 250
ctrlnum	(OCoLC)1164633002 (DE-599)DNB1203448775
dewey-full	005.133
dewey-hundreds	000 - Computer science, information, general works
dewey-ones	005 - Computer programming, programs, data, security
dewey-raw	005.133
dewey-search	005.133
dewey-sort	15.133
dewey-tens	000 - Computer science, information, general works
discipline	Informatik
edition	4., aktualisierte und überarbeitete Auflage
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>03012nam a22006858c 4500</leader><controlfield tag="001">BV046748654</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20210802 </controlfield><controlfield tag="007">t\|</controlfield><controlfield tag="008">200604s2020 gw a\|\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">20,N05</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1203448775</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783836239738</subfield><subfield code="c">Festeinband : EUR 44.90 (DE), EUR 46.20 (AT), CHF 57.90 (freier Preis)</subfield><subfield code="9">978-3-8362-3973-8</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3836239736</subfield><subfield code="9">3-8362-3973-6</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9783836239738</subfield></datafield><datafield tag="028" ind1="5" ind2="2"><subfield code="a">Bestellnummer: 459/03973</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1164633002</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB1203448775</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">ger</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">XA-DE-NW</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-860</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-863</subfield><subfield code="a">DE-859</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-573</subfield><subfield code="a">DE-1051</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-703</subfield><subfield code="a">DE-83</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-473</subfield><subfield code="a">DE-898</subfield><subfield code="a">DE-1046</subfield><subfield code="a">DE-1043</subfield><subfield code="a">DE-20</subfield><subfield code="a">DE-573n</subfield><subfield code="a">DE-B768</subfield><subfield code="a">DE-862</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">23/ger</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Wolf, Jürgen</subfield><subfield code="d">1974-</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)132691256</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">C von A bis Z</subfield><subfield code="b">das umfassende Handbuch</subfield><subfield code="c">Jürgen Wolf, René Krooß</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">4., aktualisierte und überarbeitete Auflage</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Bonn</subfield><subfield code="b">Rheinwerk Verlag</subfield><subfield code="c">2020</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1228 Seiten</subfield><subfield code="b">Illustrationen, Diagramme</subfield><subfield code="c">24 cm x 16.8 cm</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a">Rheinwerk Computing</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Auf dem Cover: Aktuell zu C18</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">C</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4113195-2</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">ANSI C</subfield><subfield code="0">(DE-588)4233557-7</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">C++</subfield><subfield code="0">(DE-588)4193909-8</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">ANSI C++</subfield><subfield code="0">(DE-588)4499937-9</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">C-Programmierung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Software-Entwicklung entwickeln</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Hand-Buch Bücher Wissen lernen Tutorials Kurse Workshops Ausbildung Studium Seminare</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">C programmieren lernen</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Algorithmen</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Entwickler Programmierer Engineer</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">C</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4113195-2</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2="1"><subfield code="a">ANSI C</subfield><subfield code="0">(DE-588)4233557-7</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="1" ind2="0"><subfield code="a">C++</subfield><subfield code="0">(DE-588)4193909-8</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="2" ind2="0"><subfield code="a">ANSI C++</subfield><subfield code="0">(DE-588)4499937-9</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="2" ind2=" "><subfield code="8">2\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Krooß, René</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)1211561577</subfield><subfield code="4">aut</subfield></datafield><datafield tag="710" ind1="2" ind2=" "><subfield code="a">Rheinwerk Verlag</subfield><subfield code="0">(DE-588)1081738405</subfield><subfield code="4">pbl</subfield></datafield><datafield tag="780" ind1="0" ind2="0"><subfield code="i">Vorangegangen ist</subfield><subfield code="z">9783836214117</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">X:MVB</subfield><subfield code="q">text/html</subfield><subfield code="u">http://deposit.dnb.de/cgi-bin/dokserv?id=9b7c412c241445b9ae09b3eed0cda1e4&prov=M&dok_var=1&dok_ext=htm</subfield><subfield code="3">Inhaltstext</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">DNB Datenaustausch</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032158424&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">2\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-032158424</subfield></datafield></record></collection>
id	DE-604.BV046748654
illustrated	Illustrated
indexdate	2024-12-20T18:59:50Z
institution	BVB
institution_GND	(DE-588)1081738405
isbn	9783836239738 3836239736
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-032158424
oclc_num	1164633002
open_access_boolean
owner	DE-860 DE-29T DE-Aug4 DE-863 DE-BY-FWS DE-859 DE-634 DE-573 DE-1051 DE-19 DE-BY-UBM DE-703 DE-83 DE-523 DE-473 DE-BY-UBG DE-898 DE-BY-UBR DE-1046 DE-1043 DE-20 DE-573n DE-B768 DE-862 DE-BY-FWS
owner_facet	DE-860 DE-29T DE-Aug4 DE-863 DE-BY-FWS DE-859 DE-634 DE-573 DE-1051 DE-19 DE-BY-UBM DE-703 DE-83 DE-523 DE-473 DE-BY-UBG DE-898 DE-BY-UBR DE-1046 DE-1043 DE-20 DE-573n DE-B768 DE-862 DE-BY-FWS
physical	1228 Seiten Illustrationen, Diagramme 24 cm x 16.8 cm
publishDate	2020
publishDateSearch	2020
publishDateSort	2020
publisher	Rheinwerk Verlag
record_format	marc
series2	Rheinwerk Computing
spellingShingle	Wolf, Jürgen 1974- Krooß, René C von A bis Z das umfassende Handbuch C Programmiersprache (DE-588)4113195-2 gnd ANSI C (DE-588)4233557-7 gnd C++ (DE-588)4193909-8 gnd ANSI C++ (DE-588)4499937-9 gnd
subject_GND	(DE-588)4113195-2 (DE-588)4233557-7 (DE-588)4193909-8 (DE-588)4499937-9
title	C von A bis Z das umfassende Handbuch
title_auth	C von A bis Z das umfassende Handbuch
title_exact_search	C von A bis Z das umfassende Handbuch
title_full	C von A bis Z das umfassende Handbuch Jürgen Wolf, René Krooß
title_fullStr	C von A bis Z das umfassende Handbuch Jürgen Wolf, René Krooß
title_full_unstemmed	C von A bis Z das umfassende Handbuch Jürgen Wolf, René Krooß
title_short	C von A bis Z
title_sort	c von a bis z das umfassende handbuch
title_sub	das umfassende Handbuch
topic	C Programmiersprache (DE-588)4113195-2 gnd ANSI C (DE-588)4233557-7 gnd C++ (DE-588)4193909-8 gnd ANSI C++ (DE-588)4499937-9 gnd
topic_facet	C Programmiersprache ANSI C C++ ANSI C++
url	http://deposit.dnb.de/cgi-bin/dokserv?id=9b7c412c241445b9ae09b3eed0cda1e4&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032158424&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT wolfjurgen cvonabiszdasumfassendehandbuch AT krooßrene cvonabiszdasumfassendehandbuch AT rheinwerkverlag cvonabiszdasumfassendehandbuch

Verfügbarkeit

‌

Per Fernleihe bestellen Inhaltsverzeichnis