Einführung in die Programmiersprache C

Dieses Seminar bietet dir in zwei Tagen einen strukturierten und praxisnahen Einstieg in die prozedurale Programmiersprache C. Du lernst die Syntax, den Umgang mit grundlegenden Datenstrukturen sowie die hardwarenahe Programmierung durch Zeiger (Pointer) und manuelle Speicherverwaltung. Am Ende hast du ein solides Fundament für die Entwicklung von performanter Systemsoftware, Treibern oder eingebetteten Systemen (Embedded Systems).

Für wen ist dieses Seminar

Angehende Softwareentwickler, Systemprogrammierer, Ingenieure und Umsteiger aus höheren Programmiersprachen.

Das Angebot richtet sich an Unternehmen, Behörden und Selbstständige.

Was du mitbringen solltest

Allgemeines technisches Verständnis. IT-Grundkenntnisse sind erforderlich, erste Programmiererfahrungen sind hilfreich, aber nicht zwingend.

Detaillierte Inhalte

Grundlagen und Entwicklungsumgebung

Historie und Einsatzgebiete von C (Systemprogrammierung, Embedded C)
Der Build-Prozess im Detail: Präprozessor, Compiler, Assembler und Linker (z. B. GCC, Clang)
Aufbau eines C-Programms: Die main()-Funktion und grundlegende Syntax
Standard-Ein-/Ausgabe: Arbeiten mit printf() und scanf()
C-Standards im Überblick: C11, C17 und Ausblick auf C23

Variablen, Datentypen und Operatoren

Primitive Datentypen (int, char, float, double) und ihre Speichergrößen
Typ-Modifizierer: signed, unsigned, short, long
Konstanten definieren (const und #define)
Operatoren: Arithmetische, relationale, logische und bitweise Operatoren
Implizite und explizite Typumwandlung (Type Casting)

Kontrollstrukturen und Ablaufsteuerung

Bedingte Anweisungen: if, else if, else
Mehrfachverzweigungen: Das switch-Statement
Schleifenkonstrukte: while, do-while und for
Schleifensteuerung mit break und continue

Funktionen und Programmstrukturierung

Definition, Deklaration und Funktionsprototypen
Parameterübergabe: Call-by-Value
Rückgabewerte und der Datentyp void
Gültigkeitsbereiche von Variablen (Scope): Lokal vs. Global
Speicherklassen-Spezifizierer: auto, register, static, extern
Kommandozeilenargumente entgegennehmen (argc, argv)

Arrays und Zeichenketten (Strings)

Deklaration und Initialisierung eindimensionaler Arrays
Mehrdimensionale Arrays und Matrizen
Spezifika von C-Strings: Nullterminierte Zeichenketten (\0)
Wichtige Funktionen der Standardbibliothek <string.h> (strlen, strcpy, strcmp, strcat)

Zeiger (Pointer)

Konzept des Arbeitsspeichers und Speicheradressen
Zeiger-Deklaration (*) und Adressoperator (&)
Dereferenzierung von Zeigern
Pointer-Arithmetik und der Zusammenhang zwischen Arrays und Pointern
Parameterübergabe an Funktionen: Call-by-Reference (Zeiger als Argumente)
Zeiger auf Funktionen und deren Einsatz, z. B. für Callback-Mechanismen

Dynamische Speicherverwaltung (Memory Management)

Speichermodell: Stack vs. Heap
Speicherallokation zur Laufzeit: malloc(), calloc() und realloc()
Speicherfreigabe mit free()
Best Practices und Fehlervermeidung: Memory Leaks, Dangling Pointers und Buffer Overflows

Strukturierte Datentypen

Gruppierung heterogener Daten mit Strukturen (struct)
Typdefinitionen mit typedef zur Code-Vereinfachung
Unions: Speichereffiziente Datennutzung (union)
Aufzählungen (enum) für Konstanten-Gruppen
Zeiger auf Strukturen und der Pfeil-Operator (->)

Der C-Präprozessor und Makros

Einbinden von Header-Dateien (#include)
Definition von Makros mit und ohne Parameter (#define)
Bedingte Kompilierung (#ifdef, #ifndef, #endif) zur Portabilität
Include-Guards zur Vermeidung von Mehrfacheinbindungen

Datei-Ein- und Ausgabe (File I/O)

Dateizeiger (FILE *)
Dateien öffnen und schließen (fopen, fclose)
Textdateien verarbeiten: fprintf(), fscanf(), fgets(), fputs()
Binärdateien verarbeiten: fread() und fwrite()
Fehlerbehandlung und Dateiende-Prüfung (feof, ferror)

Projektstruktur, Build-Systeme und Debugging

Mehrdateien-Projekte organisieren: Trennung von Header- und Source-Dateien
Projekte bauen mit make und CMake
Debugging mit gdb: Breakpoints setzen, Variablen inspizieren, Stack-Traces lesen
Speicherfehler aufspüren mit AddressSanitizer und Valgrind

Dauer: 2 Tage

Was du danach kannst

Eigenständig C-Programme mit Zeigern, dynamischer Speicherverwaltung und eigenen Datentypen entwickeln
Mehrdateien-Projekte strukturieren und mit make/CMake bauen
Speicherfehler mit gdb, AddressSanitizer und Valgrind aufspüren und beheben
Kommandozeilenargumente auswerten und Funktionszeiger für Callbacks einsetzen
Textdateien und Binärdateien lesen und schreiben
Moderne C-Standards (C11/C17/C23) einordnen

Dein Dozent

Frank Glück schult seit mehr als 30 Jahren und programmiert seit fast 40 Jahren. Seit 1999 ist er auch als Dozent für die GFU tätig. Er vermittelt hardwarenahe Programmierung und Speicherverwaltung fundiert und verständlich.

Häufige Fragen (FAQ)

Für wen eignet sich dieser Einführungskurs in C?

Der Kurs richtet sich an Entwickler, Ingenieure, systemnahe Programmierer und Einsteiger, die das Fundament moderner Softwareentwicklung verstehen möchten. C ist die Basissprache für Betriebssysteme, Treiber, Embedded Systems und Hochleistungs-Backends.

Warum ist das Verständnis von Zeigern (Pointern) in C so entscheidend?

Zeiger ermöglichen den direkten Zugriff auf Arbeitsspeicheradressen, effiziente Parameterübergaben ohne Kopier-Overhead und dynamische Speicherallokation (malloc/free). Ein solides Zeigerverständnis ist unverzichtbar, um Speicherlecks und Segmentierungsfehler zu vermeiden.

Werden moderne C-Standards im Seminar behandelt?

Ja, vermittelt werden moderne C-Standards (C11, C17 und Ausblicke auf C23) mit Best Practices für plattformübergreifende Portabilität, sichere Stringverarbeitung und saubere Code-Strukturierung mit Header-Guards.