Ullenboom C programmieren

Das umfassende Handbuch
1. Auflage 2026
ISBN: 978-3-367-11644-7
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Deutsch, 1238 Seiten

Modernes C-Wissen von Anfang an

An der Programmiersprache C kommt man auch heute nicht vorbei: Sie ist die Lingua Franca der Systemprogrammierung . In diesem Handbuch lernen Sie C von Anfang an, egal, welchen Wissensstand Sie schon mitbringen. Anhand von Best Practices und vielen Übungen begleitet Sie der erfahrene Autor Christian Ullenboom durch Variablen, Datentypen und Funktionen bis hin zu Continuous Integration und Leistungsanalyse. Sowohl Einsteiger in C als auch professionelle Anwender kommen hier auf ihre Kosten. Der ideale Weg zu fundierten und umfassenden Kenntnissen in C!

• Moderne C-Programmierung für die professionelle Praxis
• Inkl. Sprachgrundlagen, Speicherverwaltung, Leistungsanalyse, Continuous Integration u. v. m.
• Ideal für Studium und Beruf, mit Best Practices, Aufgaben und Lösungen

Aus dem Inhalt:

• Variablen, Datentypen und Typsicherheit
• Operatoren und Ausdrücke
• Kontrollstrukturen
• Funktionen
• Arrays
• Zeiger
• Speicherverwaltung
• Zeichen, Zeichenketten und Textverarbeitung
• Nebenläufigkeit und Parallelität
• Profiler und Optimierung
• Testen und Qualitätssicherheit

Autoren/Hrsg.

Ullenboom, Christian

Inhaltsverzeichnis

  Materialien zum Buch ... 31

  Vorwort ... 33

  1.  Die Philosophie von C ... 41

       1.1 ... Was ist C, und was ist es nicht? ... 41

       1.2 ... Der C-Standard ... 44

       1.3 ... Die Bedeutung von C heute ... 52

       1.4 ... Rückblick und Ausblick ... 55

  2.  Werkzeugkette und das erste C-Programm ... 57

       2.1 ... Minimales Beispiel main.c ... 57

       2.2 ... Compiler im Alltag: GCC und Clang ... 60

       2.3 ... C-Programm auf der Kommandozeile kompilieren und ausführen ... 68

       2.4 ... Präprozessor, Compiler und Linker ... 73

       2.5 ... Editoren, IDEs ... 74

       2.6 ... Debugger und Laufzeitanalyse ... 80

       2.7 ... Dokumentation zu C-Funktionen finden ... 82

       2.8 ... Aufgabe ... 82

       2.9 ... Rückblick und Ausblick ... 83

  3.  Syntax und Struktur von C-Programmen ... 85

       3.1 ... Vom Quelltext zum Programm ... 85

       3.2 ... Lexikalische Grundlagen ... 86

       3.3 ... Lesbarkeit und Stil ... 90

       3.4 ... Grammatik und Programmbausteine ... 91

       3.5 ... Rückblick und Ausblick ... 93

  4.  Variablen, Datentypen und Typsicherheit ... 95

       4.1 ... Konstanten und String-Literale: feste Angaben im Quelltext ... 95

       4.2 ... Werte mit der Funktion zur formatierten Ausgabe printf() ausgeben ... 97

       4.3 ... Grundtypen ... 99

       4.4 ... Variablen ... 100

       4.5 ... Konstante Werte ... 112

       4.6 ... Ganzzahlen (int, short, long, long long) ... 117

       4.7 ... Gleitkommatypen (float, double, long double) ... 120

       4.8 ... Zeichentyp (char) ... 123

       4.9 ... Wahrheitswerte (bool) ... 128

       4.10 ... Der Nicht-Wertetyp (void) ... 129

       4.11 ... Vorzeichenbehaftete und vorzeichenlose Ganzzahlen ... 130

       4.12 ... Zahlendarstellungen und Schreibweisen ... 140

       4.13 ... Typkategorien und Grundbegriffe ... 145

       4.14 ... Rückblick und Ausblick ... 145

  5.  Operatoren und Ausdrücke ... 147

       5.1 ... Primäre Ausdrücke ... 148

       5.2 ... Zuweisungsoperatoren ... 149

       5.3 ... Arithmetische Operatoren (+, -, *, /, %) ... 152

       5.4 ... Kurzschreibweisen für Zuweisungen und Änderungen ... 157

       5.5 ... Vergleichsoperatoren ... 160

       5.6 ... Logische Operatoren (!, &&, ||) ... 165

       5.7 ... Typumwandlungen (Conversions) und ihre Regeln ... 174

       5.8 ... Kommaoperator, Vorrang, Assoziativität und Auswertungsreihenfolge ... 181

       5.9 ... Mathematisches aus den Standard-Bibliotheken ... 186

       5.10 ... Rückblick und Ausblick ... 188

  6.  Kontrollstrukturen ... 189

       6.1 ... Bedingte Anweisungen (Fallunterscheidungen: if, else) ... 189

       6.2 ... Bedingungsoperator (?:) ... 201

       6.3 ... switch-Anweisung ... 205

       6.4 ... while-Schleife ... 216

       6.5 ... do-while-Schleife ... 222

       6.6 ... for-Schleife ... 225

       6.7 ... Schleifen mit break und continue steuern ... 231

       6.8 ... Best Practices, Tipps und Fehlerquellen bei Schleifen ... 239

       6.9 ... Programmsprünge (goto) ... 246

       6.10 ... Rückblick und Ausblick ... 253

  7.  Funktionen ... 255

       7.1 ... Warum Funktionen? ... 255

       7.2 ... Funktionsgrundlagen: Definition, Deklaration und Aufruf ... 257

       7.3 ... Parameterübergabe ... 263

       7.4 ... Funktionen mit return verlassen ... 267

       7.5 ... Funktionen mit Rückgabewerten ... 267

       7.6 ... Überladen von Funktionen in C? ... 270

       7.7 ... Rekursive Funktionen ... 272

       7.8 ... Variadische Funktionen (variable Argumentlisten) ... 276

       7.9 ... Inline-Funktionen ... 280

       7.10 ... Attribute ... 282

       7.11 ... Fehlerbehandlung in Funktionen ... 287

       7.12 ... Rückblick und Ausblick ... 298

  8.  Scope, Linkage, Storage Duration und Modularisierung ... 299

       8.1 ... Scope, Linkage und Storage Duration von Variablen und Funktionen ... 300

       8.2 ... Storage Classes im Überblick ... 312

       8.3 ... Header-Dateien und Modularisierung ... 321

       8.4 ... Strukturierung größerer C-Anwendungen ... 344

       8.5 ... Rückblick und Ausblick ... 347

  9.  Der C-Präprozessor ... 349

       9.1 ... Historische Entwicklung und Motivation ... 349

       9.2 ... Makros definieren: #define ... 356

       9.3 ... Bedingte Kompilierung ... 388

       9.4 ... Vordefinierte Makros ... 394

       9.5 ... Compilerabhängige Erweiterungen ... 399

       9.6 ... Rückblick und Ausblick ... 405

10.  Benutzerdefinierte und erweiterte Datentypen ... 407

       10.1 ... Typ-Alias definieren (typedef) ... 407

       10.2 ... Ganzzahltypen aus

       10.3 ... Typen aus

       10.4 ... Optionale Gleitkomma-Datentypen ... 425

       10.5 ... Größen, Grenzen und Eigenschaften der Typen ... 434

       10.6 ... Rückblick und Ausblick ... 438

11.  Komplexe Datentypen ... 439

       11.1 ... Aufzählungen (enum) ... 439

       11.2 ... Strukturen (struct) ... 457

       11.3 ... Unions (union) ... 484

       11.4 ... Rückblick und Ausblick ... 511

12.  Arrays ... 513

       12.1 ... Einführung und Motivation für Arrays ... 513

       12.2 ... Deklaration von Arrays ... 513

       12.3 ... Zugriff auf Array-Elemente ... 519

       12.4 ... Initialisierung von Arrays ... 523

       12.5 ... Arrays bei der Parameterübergabe und Rückgabe von Funktionen ... 540

       12.6 ... Aufgaben ... 550

       12.7 ... Mehrdimensionale Arrays ... 554

       12.8 ... Einbinden externer Inhalte ... 576

       12.9 ... Rückblick und Ausblick ... 578

13.  Zeiger ... 579

       13.1 ... Datenzeiger und Adressen ... 579

       13.2 ... Der Null-Pointer nullptr ... 599

       13.3 ... Zeiger und const: Unveränderlichkeit deklarieren ... 602

       13.4 ... Zeiger in Funktionen ... 607

       13.5 ... Void-Zeiger: typenloses Zeigerwerkzeug ... 620

       13.6 ... Zeigerbeziehungen und -operationen ... 626

       13.7 ... Array-Decay und Zeigerarithmetik ... 634

       13.8 ... Zugriff auf Strukturen über Zeiger ... 652

       13.9 ... Arrays von Zeigern ... 661

       13.10 ... Mehrstufige Indirektion mit Zeigern auf Zeigern ... 671

       13.11 ... Kommandozeilenargumente als Array von Zeigern ... 685

       13.12 ... Funktionszeiger ... 688

       13.13 ... Rückblick und Ausblick ... 718

14.  Speicherverwaltung und Fehlersicherheit ... 721

       14.1 ... Einführung in die dynamische Speicherverwaltung ... 721

       14.2 ... Grundlegende Allokationsfunktionen und Anwendungen ... 723

       14.3 ... Arbeiten mit Speicherbereichen ... 757

       14.4 ... Flexible Array-Mitglieder (FAM) ... 771

       14.5 ... Speicherlebenszyklen und Ownership-Modelle ... 773

       14.6 ... Typische Speicherfehler und ihre Vermeidung ... 781

       14.7 ... Fragmentierung und Out-of-Memory-Handling ... 804

       14.8 ... Alignment und Padding ... 804

       14.9 ... Debugging und Analyse von Speicherfehlern ... 807

       14.10 ... Allokatoren ... 816

       14.11 ... Rückblick und Ausblick ... 828

15.  Metaprogrammierung ... 831

       15.1 ... Das Problem: generischer Code ohne zusätzlichen Laufzeitaufwand ... 831

       15.2 ... Präprozessor-Metaprogrammierung ... 833

       15.3 ... Compilerbasierte Metaprogrammierung ... 837

       15.4 ... Zusammenfassung und Ausblick ... 862

16.  Zeichen, Zeichenketten und Textverarbeitung ... 865

       16.1 ... Historische Grundlagen der Textrepräsentation ... 865

       16.2 ... Von einzelnen Zeichen zu Zeichenketten ... 867

       16.3 ... Moderne Textrepräsentation ... 874

       16.4 ... Moderne Texttypen und Literale ... 877

       16.5 ... Moderne String-Repräsentationen ... 884

       16.6 ... Memory-Management-Techniken ... 889

       16.7 ... Dynamische Strings ... 893

       16.8 ... Locale: Einfluss auf Zeichen- und String-Funktionen ... 898

       16.9 ... Formatierte Ausgabe in Strings ... 902

       16.10 ... Parsing und Konvertierung ... 916

       16.11 ... Klassische Charakterklassifikation (is*() und weitere) ... 926

       16.12 ... Unicode in C23 ... 927

       16.13 ... Standard-Stringfunktionen für nullterminierte Zeichenketten ... 931

       16.14 ... Vergleiche und Hashing ... 944

       16.15 ... Testing, Fuzzing und Verifikation von C-String-Code ... 951

       16.16 ... Aufgabe ... 951

       16.17 ... Rückblick und Ausblick ... 956

17.  Ein-/Ausgabe (I/O) ... 957

       17.1 ... Grundlagen von Streams ... 957

       17.2 ... Dateien öffnen und schließen ... 958

       17.3 ... Textdateien schreiben und lesen ... 960

       17.4 ... Standardstreams ... 962

       17.5 ... Rohdaten verarbeiten ... 964

       17.6 ... Position im Stream steuern (fseek(), ftell() usw.) ... 972

       17.7 ... Fehler erkennen und behandeln (ferror(), feof(), clearerr()) ... 975

       17.8 ... Puffer und Streameigenschaften steuern ... 976

       17.9 ... Dateien löschen und umbenennen ... 979

       17.10 ... Temporäre Dateien ... 980

       17.11 ... Plattform- und POSIX-Erweiterungen ... 982

       17.12 ... POSIX-Erweiterungen rund um Datei- und Verzeichnis-I/O ... 983

       17.13 ... Zusammenfassung und Ausblick ... 987

18.  Bitoperationen ... 989

       18.1 ... Bit- und Schiebeoperatoren ... 990

       18.2 ... Bitmasken, Flags und typische Muster ... 996

       18.3 ... Standardisierte Bitfunktionen (

       18.4 ... Ganzzahlen mit fester Bitbreite (_BitInt) ... 1008

       18.5 ... Bitfelder ... 1012

       18.6 ... Rückblick und Ausblick ... 1019

19.  Numerik und Mathematik ... 1021

       19.1 ... Sichere Arithmetik (

       19.2 ... Besondere Gleitkommazahlen ... 1025

       19.3 ... Konvertierungen zwischen Ganz- und Gleitkommazahlen ... 1032

       19.4 ... Mathematische Funktionen (

       19.5 ... Floating-Point-Umgebung und Rundungsmodi (

       19.6 ... Generische Mathematik (

       19.7 ... Zufallsfunktionen in C ... 1047

       19.8 ... Komplexe Zahlen ... 1049

       19.9 ... Rückblick und Ausblick ... 1051

20.  Weitere Teile der C-Standardbibliothek ... 1053

       20.1 ... Standard Utilities Header (

       20.2 ... Signale (

       20.3 ... Nichtlokale Sprünge (

       20.4 ... Zeit und Datum (

       20.5 ... Rückblick und Ausblick ... 1082

21.  Nebenläufigkeit und Parallelität ... 1083

       21.1 ... Einführung in Nebenläufigkeit ... 1083

       21.2 ... Thread-Lebenszyklus: Erstellen, Ausführen, Beenden ... 1090

       21.3 ... Das C-Memory-Modell und atomare Operationen ... 1106

       21.4 ... Fortgeschrittene Konzepte kurz vorgestellt ... 1111

       21.5 ... Alternativen zu

       21.6 ... Rückblick und Ausblick ... 1116

22.  Standardbibliothek, Implementierungen und Erweiterungen ... 1119

       22.1 ... Implementierungen der Standardbibliothek ... 1119

       22.2 ... POSIX ... 1121

       22.3 ... Plattformunabhängige Bibliotheken ... 1127

       22.4 ... Plattformabstrahierende Bibliotheken ... 1128

       22.5 ... Plattformspezifische APIs jenseits von C und POSIX ... 1130

       22.6 ... Compiler- und Implementierungserweiterungen ... 1132

       22.7 ... Zusammenfassung und Ausblick ... 1133

23.  Build und Auslieferung ... 1135

       23.1 ... Make ... 1136

       23.2 ... Projektstruktur in C ... 1144

       23.3 ... CMake ... 1147

       23.4 ... Cross-Compiler ... 1149

       23.5 ... Packaging und Distribution ... 1151

       23.6 ... Continuous Integration ... 1152

       23.7 ... Zusammenfassung und Ausblick ... 1154

24.  Testen und Qualitätssicherung ... 1155

       24.1 ... Compiler-Warnungen ... 1155

       24.2 ... Statische Analyse ... 1156

       24.3 ... Code-Formatter ... 1158

       24.4 ... Tests ... 1159

       24.5 ... Code-Coverage ... 1161

       24.6 ... Fuzzing ... 1162

       24.7 ... Review-Prozesse ... 1163

       24.8 ... Dokumentation ... 1164

       24.9 ... Zusammenfassung und Ausblick ... 1166

25.  Profiler und Optimierung ... 1167

       25.1 ... Compiler-Optimierungen ... 1167

       25.2 ... Grundlagen und Kennzahlen der Leistungsanalyse ... 1172

       25.3 ... Werkzeuge ... 1176

       25.4 ... Benchmarking und Reproduzierbarkeit ... 1180

       25.5 ... Optimierungstechniken im Code ... 1184

       25.6 ... Methodik: systematisches Vorgehen bei Leistungsproblemen ... 1191

       25.7 ... Rückblick und Ausblick ... 1193

26.  Nachwort: der »C-Weg« -- Philosophie und Kernprinzipien ... 1195

  Anhang ... 1199

  A.  Standard-Header ... 1201

  B.  Die 8 kostbaren Übersetzungsphasen ... 1205

  C.  Operatorpräzedenz ... 1211

  D.  Konvertierungsspezifikationen sowie PRI- und SCN-Makros ... 1213

  Index ... 1229

Leseproben

Vorwort

Warum dieses Buch?

Die Programmiersprache C ist über 50 Jahre alt, so alt wie ich. In der Geschichte der Informatik ist das eine enorme Zeitspanne. Und dennoch: Auch heute kommt man an C kaum vorbei. Seine Spuren sind in vielen modernen Programmiersprachen erkennbar. Man denke nur an C++, Java oder JavaScript. Die geschweiften Klammern erinnern sofort an die »Mutter C«.

C ist nicht die einzige Sprache, die die Programmierlandschaft geprägt hat. Aber keine andere ist in so vielen Bereichen verankert geblieben, in Betriebssystemen, Compilern, Embedded-Systemen und High-Performance-Bibliotheken. Wer sich ernsthaft mit Computern auseinandersetzt, stößt unweigerlich auf C.

»Gibt es nicht schon genug Bücher über C?« Klar! Aber die meisten basieren auf veralteten Standards und behandeln neue Features nur am Rande, oft mit Vorbehalten zur Kompatibilität. Dieses Buch geht anders vor: Es basiert auf dem aktuellen C-Standard C23 und zeigt C, wie es heute programmiert wird.

Warum C heute lernen?

Die Frage liegt nahe: Warum sollte man 2026 überhaupt noch eine Sprache ohne automatische Speicherbereinigung (Garbage Collection), ohne Klassen und ohne moderne Abstraktionen lernen?

• Weil C überall schlummert – von Betriebssystemen über Datenbanken bis zu den Laufzeitumgebungen von Python, Ruby und JavaScript. Es ist die Lingua franca der Systemprogrammierung, die Brücke zwischen Hochsprachen und Hardware.

• Weil C die Grundlage ist. Wer C versteht, versteht, was hinter den Abstraktionen moderner Sprachen geschieht, wie Speicher verwaltet wird, warum Rust das Ownership-Konzept betont oder wie Python native Erweiterungen einbindet.

• Weil modernes C nicht das der 1980er-Jahre ist. Features wie bool, _Generic oder standardisierte Threads machen es ausdrucksstärker, und heutige Compiler erkennen viele Fehler schon vor der Ausführung.

Was genau C ausmacht, wo es überall steckt und warum es technisch nach wie vor überzeugt, zeigt das nächste Kapitel ausführlich.

Vapes mit C programmieren

Bogdan Ionescu (aka BogdanTheGeek) sammelt Vapes. Beim Zerlegen neuerer Modelle fiel ihm auf, dass darin ein vollwertiger Mikrocontroller steckt, ein Chip, hinter dem sich ein ARM-Cortex-M0+-Kern mit 24 MHz, 24 KB Flash und 3 KB RAM versteckt. Aus Neugier wollte er einen funktionierenden Webserver direkt auf der Vape programmieren.

Auf dem Mikrocontroller läuft dafür der uIP TCP/IP-Stack, eine sehr schlanke Netzwerklösung, die IP und TCP auf nur wenige Kilobyte Speicher unterbringt. Darauf hat Bogdan einen einfachen HTTP-Server aufgebaut, der Webseiten ausliefern kann. Unter https://bogdanthegeek.github.io/blog/projects/vapeserver/ beschreibt er das Projekt. Alles ist in C programmiert.

Da der Chip keine eigene Netzwerkschnittstelle besitzt, übernimmt ein Linux-Rechner die Verbindung nach außen. Er spricht mit der Vape über die Debug-Leitung (SWD). So können HTTP-Anfragen über diesen Umweg an den Mikrocontroller gelangen, der sie verarbeitet und beantwortet. Das Ergebnis ist ein funktionsfähiger, wenn auch stark begrenzter Webserver auf einer Einweg-E-Zigarette. Die Webseite selbst liegt im Speicher der E-Zigarette und belegt dort den größten Teil des verfügbaren Platzes.

Philosophie und Besonderheiten des Buches

Die Programmiersprache C ist bewusst einfach gehalten und besteht im Kern aus wenigen Konzepten. Trotzdem lassen sich damit große und komplexe Programme umsetzen. Das Buch zeigt an konkreten Beispielen, wie aus diesem kleinen Sprachkern größere Strukturen, typische Muster und stabile Programme entstehen.

Das Buch zeigt auch, dass der Standard nicht alles genau festlegt. Viele Einzelheiten hängen von der jeweiligen Umsetzung ab, weshalb C auf verschiedenen Plattformen unterschiedlich funktioniert. Es erklärt, wo die Spezifikation bewusst offen bleibt und welche unterschiedlichen Ergebnisse dadurch bei bestimmten Sprachkonstrukten entstehen können.

Ein weiterer Schwerpunkt liegt auf modernen Werkzeugen. Das Buch geht gezielt auf Compiler, Warnungen und statische Analyse ein und erläutert, was diese Meldungen bedeuten und warum sie entstehen. Compiler-Warnungen sind ein wirksames Mittel, um für typische Fehler sensibilisiert zu werden und den eigenen Code systematisch zu verbessern. Viele C-Bücher lassen diesen Aspekt weitgehend außen vor; hier ist er fester Bestandteil.

Zielgruppe

Dieses Buch richtet sich an Menschen, die C trotz – oder gerade wegen – moderner Hochsprachen nutzen oder lernen möchten.

• Studierende der Informatik und verwandter Fächer, die einen aktuellen Einstieg in die Systemprogrammierung suchen. Viele Studienpläne enden bei C99; dieses Buch zeigt C in seiner heutigen Form mit modernen Funktionen für mehr Ausdruckskraft und Sicherheit.

• Praktiker in der Softwareentwicklung, die C für spezifische Projekte einsetzen:

  • Personen in der Systemprogrammierung für Betriebssysteme, Treiber, Firmware oder Performance-Komponenten (z.B. Linux, Windows, Datenbanken), die tiefes C-Wissen benötigen.

  • Fachleute aus performancekritischen Bereichen, die C für Hotspots oder Bibliotheken einsetzen und die zugrunde liegende Ebene verstehen müssen, etwa bei nativen Erweiterungen in Python, Java oder JavaScript.

  • Personen aus der Sicherheitsanalyse und dem Reverse Engineering, die Kenntnisse in C benötigen, um Schwachstellen in kritischer Software zu analysieren.

• Umsteiger aus höheren Sprachen, die neugierig die Schichten unter ihren Abstraktionen erkunden wollen. C erklärt Designentscheidungen in Sprachen wie Go, Rust oder Python und bildet das Fundament moderner Software-Infrastruktur.

• Einsteiger in die Programmierung, die mit einer maschinennahen Sprache beginnen und von Grund auf verstehen möchten, wie Software und Hardware zusammenspielen. C eignet sich als erste Sprache, weil es wenige Abstraktionen verbirgt und ein klares Bild davon vermittelt, was der Computer tatsächlich tut.

Voraussetzungen

C erschließt sich nicht völlig ohne Vorwissen. Ein grundlegendes Verständnis der Funktionsweise von Computern ist daher von Vorteil. Dazu gehört die Vorstellung, dass Daten im Speicher liegen, der Prozessor Befehle ausführt und Bytes die Basis aller Informationen bilden. Hilfreich ist auch ein Gefühl dafür, dass Datentypen unterschiedlich viel Speicher belegen und verschieden interpretiert werden. Begriffe wie Bedingungen, Schleifen und Funktionen sollten zumindest dem Namen nach bekannt sein, ohne dass die Kenntnis einer konkreten Programmiersprache vorausgesetzt wird. Die grobe Vorstellung davon, wie ein Compiler Quellcode in ein ausführbares Programm übersetzt, bildet eine solide Grundlage.

Wichtig ist außerdem eine gewisse Frustrationstoleranz. C verzeiht kaum: Viele Fehler, die andere Sprachen zur Laufzeit abfangen, führen hier direkt zu undefiniertem oder schwer nachvollziehbarem Verhalten. Das gehört zum Lernprozess. C geht davon aus, dass man weiß, was man tut, und macht genau das, was man geschrieben hat – im Guten wie im Schlechten.

Wer bereits Sprachen wie Python oder JavaScript kennt, wird umdenken müssen: C bietet keine komplexen Standarddatenstrukturen, keine automatische Speicherverwaltung und keine schützende Laufzeitumgebung. Wer ohne Vorerfahrung in einer anderen Sprache einsteigt, lernt diese Konzepte direkt auf der grundlegenden Ebene kennen, ohne den Umweg über Abstraktionen, die erst wieder abgelegt werden müssen.

Praktisch benötigt man lediglich ein Betriebssystem wie Windows, macOS oder Linux. C-Compiler sind unter Unix-Systemen oft vorinstalliert, aber auf jeden Fall frei verfügbar. Das Buch zeigt Schritt für Schritt, wie eine funktionierende Entwicklungsumgebung eingerichtet wird und welche Werkzeuge dafür sinnvoll sind.

Für den Einstieg reichen einfache Mittel:

• Online-Werkzeuge im Browser zum Ausprobieren ohne Installation

• lokale freie Compiler und Entwicklungsumgebungen

Es ist keine kostenpflichtige Software nötig. Ein Rechner, ein Compiler und Zeit genügen.

Aufbau und Lesetipps

...

Über Autor(innen)

Ullenboom, Christian
Christian Ullenboom, Dipl.-Informatiker, ist seit Jahrzehnten in der Welt der C-Programmierung zu Hause, ein erfahrener Fachbuchautor und seit 1997 Trainer und Berater für objektorientierte Analyse und Design. Seit Jahren teilt er sein Wissen mit unzähligen Besuchern seiner Website, wo er Fragen beantwortet, Inhalte bereitstellt und diskutiert. Christian Ullenboom bietet auch Rheinwerk Seminare zu Java und Spring an.