Vom Kennen der C-Syntax zum echten C-Programmierer

C ist eine wirklich leicht zu erlernende Programmiersprache. Variablen, Funktionen, Kontrollflussanweisungen, Strukturen, Zeiger – und das war’s im Grunde schon. Vor allem aber gibt C dir die Kontrolle: Wenn du deinen Code in C schreibst, bist du der Gott.

Doch große Macht bringt große Verantwortung mit sich. Du kannst alles perfekt und effizient zum Laufen bringen, aber du kannst auch alles durcheinanderbringen, indem du beispielsweise Stack-Überläufe, baumelnde Zeiger, Use-after-free-Fehler, Dereferenzierungen von Nullzeigern, doppelte Speicherfreigaben, Speicherlecks, Speicherzugriffe außerhalb der gültigen Grenzen und Ähnliches in dein Programm einführst.

Darüber hinaus ist C eine mächtige Sprache, die dir Kontrolle gibt. Das bedeutet jedoch auch, dass C deutlich weniger Abstraktion bietet als C++, Python und andere Sprachen und dass du selbst dafür verantwortlich bist, einen großen Teil der benötigten Logik zu implementieren. Deshalb liegt zwischen dem Kennen der C-Syntax und dem Werden eines echten C-Programmierers ein gewaltiger Unterschied.

Ich habe 2024/2025 C gelernt, aber ohne mein Wissen durch das Schreiben echter, produktionsreifer Programme praktisch anzuwenden, bin ich zum Lernen von C++ übergegangen. Anschließend habe ich angefangen, Anwendungen mit C++ und Qt zu entwickeln, was ich als angenehm empfunden habe. In den letzten Tagen bin ich jedoch bei dem Versuch, eine Begleitanwendung für CanoKey mit libcanokey zu entwickeln, auf einige Hindernisse gestoßen. Ursprünglich sollte dieses Projekt dazu dienen, meine Kenntnisse in der Programmierung mit C++ + Qt + Kirigami praktisch anzuwenden. Dabei habe ich jedoch festgestellt, dass ich noch sehr viel lernen muss, um vom „C-Kennen“ zum „Wissen, wie man nützliche Programme in C entwickelt“ zu gelangen.

Dieser Artikel stellt einige einfache Beispiele vor. Ich hoffe, dass er anderen Menschen hilft, die gerade erst die C-Syntax gelernt haben, aber noch nicht wissen, wie man nützliche Programme in C schreibt.

Objektorientierte Programmierung in C

C unterstützt von Haus aus keine objektorientierte Programmierung. Einer der wichtigsten integrierten zusammengesetzten Typen zur Gruppierung von Werten heißt Struktur. Er fasst mehrere Member aus den eingebauten C-Typen oder anderen Strukturtypen zu einem einzigen Typ zusammen, wobei zwischen den Membern gegebenenfalls Auffüllbytes eingefügt werden können. Viele Projekte und Bibliotheken aus der Freie-Software-Gemeinschaft, die in C geschrieben sind, verwenden jedoch ein manuell implementiertes, pseudo-objektorientiertes Design. Sie erweitern nicht die C-Syntax, sondern verwenden einfach Strukturen, um ihre Ziele zu erreichen.

Die grundlegende Idee

Definiere eine Struktur:

typedef struct Counter
{
    int a;
} Counter;

Und definiere einige Funktionen:

Counter *counter_create()
{
    Counter *ans = malloc(sizeof *ans);
    if (! ans) return NULL;
    ans->a = 0;
    return ans;
}

void counter_increase(Counter *self)
{
    self->a++;
}

int counter_get_value(Counter *self)
{
    return self->a;
}

Herzlichen Glückwunsch! Du hast eine Klasse und ihre Methoden in C implementiert.

Eine C++-Klasse, die dasselbe tut, würde so aussehen:

class Counter
{
public:
    Counter()
    : a(0) {}

    void increase()
    {
        this->a++;
    }

    int get_value() const
    {
        return this->a;
    }

private:
    int a;
}

Die Grundidee besteht darin, Strukturen als Objekte und Funktionen als Methoden zu verwenden.

Kapselung

Normalerweise behandeln wir die von uns definierten Strukturen als Objekte und bearbeiten sie mithilfe einer Reihe von Funktionen. Es ist jedoch weiterhin möglich, die Member dieser Strukturen direkt zu verändern, was zu unerwartetem Verhalten führen kann.

C bietet keinen Mechanismus, um die direkte Veränderung einer Struktur zu verhindern und gleichzeitig ihre Veränderung durch eine vorgegebene Gruppe von Funktionen zu ermöglichen. Es gibt jedoch einen Trick, mit dem wir dieses Ziel erreichen können.

Lege die Deklarationen unserer Struktur und Funktionen in eine Header-Datei namens counter.h:

#ifndef COUNTER_H
#define COUNTER_H

typedef struct Counter Counter;
Counter *counter_create();
void counter_increase(Counter *self);
int counter_get_value(Counter *self);

#endif

Und lege die Implementierungen in counter.c ab:

#include "counter.h"

struct Counter
{
    int a;
};

Counter *counter_create()
{
    Counter *ans = malloc(sizeof *ans);
    if (! ans) return NULL;
    ans->a = 0;
    return ans;
}

void counter_increase(Counter *self)
{
    self->a++;
}

int counter_get_value(Counter *self)
{
    return self->a;
}

In jeder Quelldatei, die Counter verwenden muss, genügt folgende Anweisung:

#include "counter.h"

Deine Quelldatei weiss nun, dass es eine Struktur namens Counter gibt und dass einige Funktionen mit dieser Struktur arbeiten können. Sie weiss jedoch weder, welche Member die Struktur enthält, noch, was die Funktionen tun. Daher kann sie die Struktur nicht direkt verändern, es sei denn, sie wandelt den Zeiger gewaltsam in einen bekannten Typ um.

Vererbung

Definiere eine weitere Struktur:

typedef struct CounterPlusPlus
{
    Counter pref;
    int step;
} CounterPlusPlus;

Und definiere eine Methode:

void counter_plus_plus_increase(CounterPlusPlus *self)
{
    self->pref.a += self->step;
}

Wir könnten selbstverständlich eine Funktion wie int counter_plus_plus_get_value(CounterPlusPlus *self) definieren, um den Wert unseres erweiterten Zählers abzurufen. Aber das ist nicht nötig!

In einer Struktur sind die Member in der Reihenfolge ihrer Deklaration angeordnet, wobei zwischen ihnen möglicherweise Auffüllbytes eingefügt werden. Ein CounterPlusPlus besteht aus einem Counter, auf den ein int folgt. Daher ist die Adresse einer CounterPlusPlus-Instanz identisch mit der Adresse ihres ersten Members pref!

Somit können wir CounterPlusPlus * in Counter * umwandeln, den Zeiger an int counter_get_value(Counter *self) übergeben und die Funktion ihn als Counter behandeln lassen. Das funktioniert genau wie erwartet!

Dies ist ein gängiger Ansatz zur Implementierung von Vererbung in C. GObject verwendet diesen Ansatz sehr intensiv, und viele seiner Datentypen erben auf diese Weise von GObject.

Ressourcenverwaltung und Besitzverhältnisse

C gibt uns die Freiheit, Speicher zu reservieren und freizugeben. Wenn wir diese Freiheit jedoch nicht sinnvoll nutzen, ist es sehr wahrscheinlich, dass wir auf Probleme wie Speicherlecks, doppelte Speicherfreigaben, Use-after-free-Fehler und Ähnliches stossen.

Besitzverhältnisse sind eine Konvention, an die sich C-Programmierer halten, damit sie reservierten Speicher korrekt verwalten können. Weitere Informationen dazu findest du in meinem vorherigen Artikel.

Direkte Kommunikation mit Hardware

Vielleicht weisst du bereits, dass bei der Systemprogrammierung intensiv auf C zurückgegriffen wird und dass C direkt mit Hardware kommunizieren kann. Viele Anfänger und fortgeschrittene C-Lernende denken möglicherweise, dass dies auf speziellen C-Syntaxelementen beruht, die durch die Hardwareschnittstelle eingeführt werden. In den meisten Fällen ist das jedoch nicht der Fall.

Die meisten Hersteller stellen eine Hardware-Abstraktionsschicht (HAL) für ihre Hardware bereit, um Entwicklern die Entwicklung von Firmware und Treibern zu erleichtern. Die HAL bietet Funktionen zur Steuerung der Hardware. In den meisten Fällen ist die HAL selbst jedoch ebenfalls in C geschrieben. Welche C-Konstrukte verwendet eine HAL also, um die Hardware zu steuern?

Tatsächlich stellen einige Hardwareplattformen spezielle Maschinenbefehle für bestimmte Operationen bereit. Auf diese kann zugegriffen werden, indem Assemblersprache mit C kombiniert wird. In den meisten Fällen ist die Kommunikation mit Hardware aus C jedoch nicht komplizierter als eine Anweisung wie diese:

*((volatile uint32_t *)0x40000000UL) = 1;

Ja. Du hast richtig gelesen, und ich mache keine Witze. Eine Adresse, eine Typumwandlung und eine gewöhnliche Ganzzahlzuweisung. Das ist alles.

Die meisten Hardwarekomponenten verfügen über Steuerregister, mit denen sich ihr Betrieb steuern lässt. Indem du Werte in diese Register schreibst, kannst du sie unterschiedliche Aufgaben ausführen lassen. Techniken wie MMIO bilden diese Register auf einen oder mehrere Adressräume ab, sodass du auf sie ähnlich wie auf gewöhnlichen Speicher zugreifen kannst. Durch das Lesen und Schreiben von Peripherieregistern können wir Hardware konfigurieren, ihren Betriebszustand steuern und unterstützte Operationen auslösen. Die interne Logik des Peripheriegeräts interpretiert diese Registerzugriffe und führt die entsprechenden Aktionen aus. Es gibt weitere Techniken, beispielsweise PMIO, das auf Architekturen, die es unterstützen, einen separaten E/A-Adressraum verwendet.

Nichts Magisches oder Undurchsichtiges.

Weitere Empfehlungen

Die oben aufgeführten Punkte sind nur die Spitze des Eisbergs.

Derzeit verwende ich den Study-Modus eines Anbieters von LLM-Diensten, um mich eingehender mit diesen Themen zu beschäftigen. Er hat einen Lernfahrplan erstellt, und hier ist eine Liste einiger wichtiger Punkte. Ich hoffe, dass sie hilfreich sind.

  1. Speicherverwaltung und Besitzverhältnisse
    • Speicherreservierung auf dem Stack gegenüber Speicherreservierung auf dem Heap.
    • Objektlebensdauer und Speicherdauer.
    • Besitz, Ausleihen und Übertragung von Besitz.
    • Flache Kopien gegenüber tiefen Kopien.
    • Referenzzählung.
    • Ressourcenbeschaffung und -freigabe.
    • Teilweise Initialisierung und Bereinigung bei Fehlern.
    • Vermeidung von Speicherlecks, doppelter Speicherfreigabe und Use-after-free.
    • Flexible Array-Member.
    • Ausrichtung und Auffüllbytes.
    • Überlauf der Allokationsgrösse.
  2. API-Entwurf und Kapselung
    • Opake Strukturen.
    • Öffentliche und private Header-Dateien.
    • Konstruktoren und Destruktoren.
    • Initialisierer und Finalisierer.
    • Getter und Setter.
    • APIs zur Referenzzählung.
    • Kopieren und Klonen.
    • Funktionsverträge.
    • Vorbedingungen und Nachbedingungen.
    • Fehlerberichterstattung.
    • API-Dokumentation.
    • Namensraumkonventionen.
    • Callback-APIs.
  3. Der vollständige Kompilierungsprozess
    • Präprozessierung.
    • Kompilierung.
    • Assemblierung.
    • Linken.
    • Übersetzungseinheiten.
    • Objektdateien.
    • Symboltabellen.
    • Nicht definierte Symbole.
    • Sichtbarkeit von Symbolen.
    • Statische Bibliotheken.
    • Gemeinsame Bibliotheken.
    • Positionsunabhängiger Code.
    • Laden von Bibliotheken zur Laufzeit.
    • Dynamisches Linken.
    • ABI-Kompatibilität.
  4. Fortgeschrittene Zeigertechniken
    • Zeigerarithmetik.
    • Arrays und Zeiger: ihre Gemeinsamkeiten und Unterschiede.
    • Zeiger auf Zeiger (T **).
    • Zeiger auf Arrays.
    • Funktionszeiger.
    • Zeiger auf Strukturen.
    • Korrekte Verwendung von const.
    • restrict.
    • void * und generische Programmierung.
    • Nullzeiger und ungültige Zeiger.
    • Zeigerlebensdauer und Aliasing-Regeln.
  5. Strukturen und datenzentriertes Design
    • Strukturkomposition.
    • Opake Strukturen.
    • Öffentliche und private Strukturen.
    • Markierte Unions.
    • Aufzählungstypen.
    • Bitfelder und ihre Einschränkungen hinsichtlich der Portabilität.
    • Auffüllbytes und Ausrichtung von Strukturen.
    • Flexible Array-Member.
    • Intrusive und nicht-intrusive Datenstrukturen.
    • Initialisierung von Strukturen.
    • Zusammengesetzte Literale.
  6. C-Zeichenketten und Binärdaten
    • Nullterminierte Zeichenketten.
    • Zeichenarrays.
    • Puffergrössen und Kapazitäten.
    • strlen(), strcmp(), memcpy() und memmove().
    • Sichere Erstellung von Zeichenketten.
    • Dynamische Zeichenkettenpuffer.
    • UTF-8.
    • Zeichenkodierung gegenüber Byte-Darstellung.
    • Ganzzahlformatierung und Formatbezeichner von printf().
    • Sicherheitslücken durch Formatzeichenketten.
    • Verarbeitung von Binärdaten.
  7. Ganzzahltypen und undefiniertes Verhalten
    • Ganzzahl-Promotionen.
    • Vorzeichenbehaftete und vorzeichenlose Arithmetik.
    • Ganzzahlüberlauf.
    • Ganzzahlkonvertierungen.
    • Ganzzahltypen mit fester Breite (uint32_t, int64_t usw.).
    • size_t, ptrdiff_t und uintptr_t.
    • Endianness.
    • Ausrichtung.
    • Undefiniertes Verhalten.
    • Nicht spezifiziertes Verhalten.
    • Implementierungsdefiniertes Verhalten.
    • Striktes Aliasing.
  8. Fehlerbehandlung
    • Fehlerbehandlung auf Grundlage von Rückgabewerten.
    • Fehlercodes.
    • Ausgabeparameter für Fehler.
    • Das Bereinigungsmuster mit goto.
  9. Datenstrukturen und Algorithmen in C
    • Dynamische Arrays.
    • Verkettete Listen.
    • Doppelt verkettete Listen.
    • Hashtabellen.
    • Bäume.
    • Binäre Suchbäume.
    • Ausgeglichene Bäume.
    • Warteschlangen.
    • Stapel.
    • Heaps.
    • Ringpuffer.
    • Zeichenketten-Ersteller.
    • Iteratoren.
  10. Funktionszeiger, Callbacks und Polymorphismus
    • Registrierung von Callbacks.
    • Funktionszeiger.
    • Funktionszeiger innerhalb von Strukturen.
    • Muster mit virtuellen Funktionstabellen.
    • Implementierung von Schnittstellen.
    • Ereignisbehandlungsroutinen.
    • Zeiger auf Benutzerdaten.
    • Plugin-Schnittstellen.
    • Dynamische Methodenbindung.
  11. Die Schnittstelle zum Betriebssystem
    • Standard-C-Bibliothek gegenüber Betriebssystem-APIs.
    • POSIX.
    • Dateideskriptoren.
    • Dateiströme (FILE *).
    • Dateioperationen.
    • Verzeichnisse und Pfade.
    • Prozesse.
    • Umgebungsvariablen.
    • Pipes.
    • Signale.
    • Sockets.
    • Speicherabbildung (mmap()).
    • Systemaufrufe.
  12. Nebenläufigkeit und Multithreading
    • Prozesse gegenüber Threads.
    • POSIX-Threads.
    • Mutexes.
    • Bedingungsvariablen.
    • Semaphore.
    • Atomare Operationen.
    • Datenrennen.
    • Deadlocks.
    • Thread-Sicherheit.
    • Thread-lokaler Speicher.
    • Speicherordnung.
    • Ereignisschleifen.
    • Asynchrone Programmierung.
  13. Ereignisgesteuerte Programmierung
    • Ereignisschleifen.
    • Ereigniswarteschlangen.
    • Ereignisverteilung.
    • Callbacks.
    • Zeitgeber.
    • Eingabeereignisse.
    • Fensterereignisse.
    • Asynchrone Operationen.
    • Anwendungslebenszyklus.
  14. Build-Systeme
    • GNU Make
    • Autoconf und Automake
    • Meson
    • CMake
  15. Bibliotheksinstallation und Abhängigkeitsverwaltung
    • Include-Verzeichnisse.
    • Bibliotheksverzeichnisse.
    • pkg-config.
    • .pc-Dateien.
    • PKG_CONFIG_PATH.
    • Statisches gegenüber dynamischem Linken.
    • Laufzeitpfade von Bibliotheken.
    • Installationspräfixe.
    • Installation von Header-Dateien.
    • Versionierung von Bibliotheken.
    • Ermittlung von Abhängigkeiten.
    • Transitive Abhängigkeiten.
  16. Debugging
    • GDB.
    • Haltepunkte.
    • Stack-Traces.
    • Stack-Frames.
    • Variableninspektion.
    • Speicherabbilder.
    • Überwachungspunkte.
    • Debug-Symbole.
    • Debugging optimierter Programme.
    • Debugging von Speicherzugriffsfehlern.
  17. Erkennung von Speicherfehlern und undefiniertem Verhalten
    • AddressSanitizer zur Erkennung von Zugriffen außerhalb gültiger Grenzen, Use-after-free und anderen Speicherfehlern.
    • UndefinedBehaviorSanitizer zur Erkennung verschiedener Formen undefinierten Verhaltens.
    • Valgrind Memcheck zur Erkennung ungültiger Speicherzugriffe, nicht initialisierter Werte und Speicherlecks.
    • MemorySanitizer zur Erkennung der Verwendung nicht initialisierten Speichers.
    • Statische Analyse zur Erkennung potenzieller Fehler, ohne das Programm auszuführen.
  18. Softwaretests
    • Einheitentests.
    • Integrationstests.
    • Regressionstests.
    • Test-Fixtures.
    • Test-Assertions.
    • Grenzwerttests.
    • Tests von Fehlerpfaden.
    • Tests auf Speicherlecks.
    • Fuzz-Tests.
    • Kontinuierliche Integration.
  19. Leistungsanalyse
    • Algorithmische Komplexität.
    • Cache-Lokalität.
    • Mehraufwand durch Speicherallokation.
    • Profiling.
    • CPU-Profiling.
    • Speicherprofiling.
    • Benchmarking.
    • Datenorientierte Optimierung.
  20. Programmierkonventionen und Lesbarkeit
    • Namenskonventionen.
    • Einrückung.
    • Organisation von Funktionen.
    • Organisation von Header-Dateien.
    • Kommentare.
    • Dokumentationskommentare.
    • Benennung öffentlicher und privater Symbole.
    • Dateiorganisation.
    • Vermeidung unnötiger Makros.
    • Vermeidung unnötiger globaler Variablen.
    • Funktionen verständlich halten.
    • Konsistenz bewahren.
  21. Dokumentation
    • Öffentliche Funktionen.
    • Funktionsparameter.
    • Rückgabewerte.
    • Fehlerbedingungen.
    • Übertragung von Besitz.
    • Lebenszyklus von Objekten.
    • Garantien zur Thread-Sicherheit.
    • API-Stabilität.
    • Anwendungsbeispiele.
  22. API- und ABI-Stabilität
    • Was ist eine API?
    • Was ist eine ABI?
    • Was gilt als inkompatible Änderung?
    • Warum die Offenlegung von Struktur-Membern problematisch sein kann.
    • Sichtbarkeit von Symbolen.
    • Versionierung gemeinsamer Bibliotheken.
    • Missbilligung und Ausmusterung.
    • Rückwärtskompatibilität.
    • Parallele Installation verschiedener Bibliotheksversionen.
  23. Internationalisierung und Lokalisierung
    • UTF-8.
    • Zeichenkodierungen.
    • Gebietsschemata.
    • gettext.
    • Übersetzungskataloge.
    • Pluralformen.
    • Datums- und Zahlenformatierung.
    • Übersetzung von Fehlermeldungen.
    • Vermeidung fest codierter, für Benutzer sichtbarer Zeichenketten.
  24. Git und gemeinschaftliche Entwicklung
    • Repositorien.
    • Commits.
    • Branches.
    • Zusammenführen.
    • Rebasen.
    • Prüfung von Unterschieden.
    • Konfliktlösung.
    • Erstellung von Patches.
    • Code-Reviews.
    • Melden von Problemen.
    • Release-Branches.

Oder eine vereinfachte Version:

  1. Stufe 1 — Idiomatisches C
    • Speicherbesitz und Lebensdauern.
    • Fortgeschrittene Zeiger und Strukturen.
    • Verarbeitung von Zeichenketten und Puffern.
    • Fehlerbehandlung.
    • Datenstrukturen.
    • Funktionszeiger und Callbacks.
  2. Stufe 2 — Bibliotheksentwicklung
    • Opake Typen und API-Entwurf.
    • Organisation von Header- und Quelldateien.
    • Statische und gemeinsame Bibliotheken.
    • Kompilierung und Linken.
    • pkg-config.
    • ABI- und API-Stabilität.
  3. Stufe 3 — Professionelle C-Entwicklung
    • POSIX und Systemprogrammierung.
    • Build-Systeme.
    • Debugging und Profiling.
    • Einheiten- und Integrationstests.
    • Laufzeitprüfprogramme und statische Analyse.
    • Dokumentation und Programmierkonventionen.
  4. Stufe 4 — Entwicklung im Ökosystem
    • GLib und GObject.
    • GNU-Entwicklungspraktiken.
    • SDL-Entwicklungspraktiken.
    • Git und gemeinschaftliche Entwicklung.
    • API-Kompatibilität.
    • Beiträge in Form von Patches zu etablierten Projekten.
Erstellt mit Hugo
Theme Stack gestaltet von Jimmy