C

C ist eine prozedurale Sprache für die Systemprogrammierung. Ein Übersetzer erzeugt optimierten Maschinencode für eine bestimmte Hardware-Architektur.

Versionen

Beispiel

hello.c
#include <stdio.h>

int
main (int argc, char * argv[])
{
	if (argc == 1) {
		printf ("Hello, World!\n");
	} else for (int i = 1; i < argc; i++) {
		printf ("Hello, %s!\n", argv[i]);
	}
	return 0;
}

Übersetzen und ausführen mit:

gcc -std=c11 -o hello hello.c && ./hello
Hello, World!

Syntax

Der Quellcode für ein C-Programm oder Modul (Übersetzungseinheit) besteht aus:

1. Direktiven für den Präprozessor,
2. Deklarationen von globalen Variablen und Funktionen
3. Definition dieser Funktionen

Makros definieren

Der Präprozessor (cpp) expandiart Makros nach folgenden Regeln, bevor der Übersetzer (cc) den Code sieht:

Primitive Datentypen

Die Deklaration einer Variable legt Speicherklasse, Zugriff, Vorzeichen, Größe, Typ, Name und den initialen Wert fest.

Variablen deklarieren

Primitive, Aufzählungen, Alternativen, Strukturen und Funktionen bevölkern jeweils einen eigenen Namensraum. Daher kann man gleiche Namen für verschiedene Klassen verwenden. Sprich: Eine Struktur kann genauso heißen wie eine Aufzählung.

Type Name = Value;

Mit der Deklaration sollte auch gleich die Zuweisung eines Wertes erfolgen.

enum Name { Name = Value, … };

Eine Aufzählung deklariert eine Gruppe zusammengehörender Konstanten.

union Name { Type Name, … };

Eine Alternative interpoliert verschiedene Datentypen über dem gleichen Speicherbereich.

struct Name { Type Name, … } = { .Name = Value, … };

Eine Struktur fasst eine Liste von Variablen zusammen.

Aufzählung

Alternative mit überlappenden Mitgliedern

Datenstruktur

Type Name[Size] = { Value, … };

Eine Reihung speichert eine Liste von gleichartigen Objekten mit fester Länge.

Type Name[Size][Size]… = { {… Value, …}, …};

Mehrdimensionale Reihungen decken die Anwendungsfälle Matrix und Tensor ab.

Einen zusammengehörenden Bereich im Speicher bezeichnet man als Objekt. Der Übersetzer führt Buch über den Typ dieser Objekte, etwa ob es sich um eine Ganzzahl, eine Datenstruktur oder um eine Funktion handelt.

Funktionen definieren

Eine Funktion ist ein Objekt, dessen Adresse man als Zeiger speichern, als Element in Strukturen verwenden oder als Parameter und Rückgabewert anderen Funktionen übergeben kann.

Type Name (Argument, …) { Statement; … }

Eine Funktion besteht aus Rückgabewert, Funktionsname, Argumentliste und einem Block mit Anweisungen

Schlüsselwörter für Funktionen

inline

Rumpf expandieren. Lieber auf Optimierung verlassen.

static

Funktion ist nur in der Übersetzungeinheit sichtbar, das Symbol wird nicht exportiert.

_Noreturn

Funktion kehrt niemals zurück. Aktiviere Optimierung. Nur sinnvoll für void-Funktionen.

Operationen ausführen

Die Präzedenz der Operatoren ist auf intuitive Verwendung ausgelegt, so dass man häufig auf Klammern verzichten kann. Geklammerte Ausdrücke genießen immer Vorrang, gefolgt von Index-Angaben in Reihungen, Zeiger-Dereferenzierung und Feldzugriffe. In arithmetischen Ausdrücken werden zuerst unäre Operatoren, dann Multiplikation, Addition und schließlich Bitoperationen ausgewertet. Danach folgen logische Ausdrücke mit Vergleich, Bitverknpüfung, Wahrheitslogik und Entscheidungslogik mit dem ternären Operator. Am geringsten binden Zuweisungen.

Ablauf steuern

if (Condition) { … } else { … }

Verzweigung

switch (Name) { case Value: … break; default: … break; }

Mehrfachverzweigung

for (Expression; Condition; Expression) …

Schleife für Iteration mit Initialisierung, Abbruchbedingung und Inkrement

while (Condition) …

Schleife mit Abbruchbedingung

do … while (Condition);

Schleife mit Abbruchbedingung am Ende

continue;

Aktuellen Schleifendurchlauf beenden

break;

Schleife verlassen

goto Label;

Unbedingter Sprung

return Expression;

Rücksprung aus Funktion

asm { Instruction … }

Anweisungen in Maschinencode einbetten

Zeiger dereferenzieren

Ein Zeiger ist eine Variable, welche die Speicheradresse eines Objekts enthält.

Type * Name = NULL;

Zeiger nach nirgendwo

Type (* Name) (Argument, …);

Zeiger auf eine Funktion

Type (* Name[Size]) (Argument, …);

Reihung von Funktionszeigern

Stilvoll programmieren

Quelltext dient in erster Linie der Kommunikation mit anderen Entwicklern. Er sollte daher leicht zu verstehen und leicht zu erweitern sein. Es ist die Aufgabe des Übersetzers, daraus für den Rechner optimierte Anweisungen zu erzeugen.

Typographische Konventionen

Programme sollte wie Bücher aufgebaut sein:

• Bibliotheken widmen sich einem bestimmten Themengebiet.
• Module bilden die Kapitel, jedes in einer eigenen Datei.
• Funktionen bilden die Abschnitte, keiner länger als eine Bildschirmseite.
• Blöcke werden durch Tabulatoren eingerückt, für Klammern gilt der 1TBS.
• Anweisungen bilden Absätze, funktionale Einheiten werden durch eine Leerzeile getrennt.
• Leerzeichen stehen nach Kommas und Strichpunkten, vor und nach binären Operatoren sowie vor öffnenden und nach schließenden Klammern.
• Namensbestandteile werden mit Unterstrichen getrennt und klein geschrieben.
• Namen von Bibliotheken, Modulen, Funktionen und Variablen sind kurz und prägnant.

Struktur von Übersetzungseinheiten

Module fassen Datenstrukturen und alle darauf arbeitenden Funktionen zusammen.

• Header werden in der Reihenfolge Projekt – Bibliothek – System eingebunden.
• Auzfählungen definieren zusammengehörende Konstanten.
• Global sichtbare Objekte bekommen sprechenden Namen und ein Modul-Präfix.
• Lokale Variabeln und Parameter sind kurze Wörter ohne Prä- und Suffixe.
• Funktionen genießen Vorzug gegenüber Makros.
• Fehler werden zuerst behandelt (innerhalb eines if-Blocks).
• Wahrheitslogik vermeidet Negation.
• Komplexe Funktionen werden aufgespalten.

Die Unix-Philosophie

• Modularität bedeutet, saubere Nahtstellen verbinden einfache Teile.
• Klarheit sticht Klugheit.
• Komposition von kooperierenden Programmen
• Trennung von Richtlinien und Mechanismen; von Schnittstelle und Maschinerie.
• Einfachheit anstreben, Komplexität nur bei Bedarf hinzufügen.
• Sparsamkeit vermeidet große Programme (oder man erbrint den Gegenbeweis).
• Transparenz durch Beobachtbarkeit; sie vereinfacht die Prüfung und Fehlersuche.
• Robustheit und Stabilität sind die Kinder von Transparenz und Einfachheit.
• Repräsentation von Erkenntnissen steckt in den Daten, Programme bleiben dumm.
• Erwartungskonformität durch Schnittstellen, die den unüberraschendsten Weg wählen.
• Schweigen wenn ein Programm nichts überraschendes zu sagen hat.
• Reparatur oder, wenn etwas schiefgeht, alsbaldigst und geräuschvoll versagen.
• Ökonomie weil Programmierer teuer sind, aber Maschinen billig arbeiten.
• Generierung vermeidet Handarbeit, Programme schreiben Programme.
• Optimierung von Flaschenhälse kommt später, erst funktionierende Prototypen bauen.
• Diversität und Misstrauen gegenüber dem einen wahren Weg bewahren.
• Erweiterbarkeit für die Zukunft planen, sie kommt schneller als man denkt.

Literatur

1. Kernighan, Ritchie: The C Programming Language, Second Edition, Prentice Hall, 1988
2. Kernighan, Pike: The Practice of Programming, Addison-Wesley, 1999
3. Boswell, Foucher: The Art of Readable Code, O'Reilly, 2012
4. Rob Pike: Notes on Programming in C
5. Linus Torvalds: Linux kernel coding style
6. Eric S. Raymond, Basics of the Unix Philosophy, The Art of Unix Programming, 2003
7. Gustavo Duarte: Anatomy of a Program in Memory
8. Pete Jinks: C Syntax in BNF