Funktionen und Programmstruktur in C

Eine Funktion fasst eine Aufgabe so zusammen, dass ein anderer Teil des Programms sie aufrufen kann. Gib ihr einen Namen, der diese Aufgabe beschreibt, und lege ihre Eingaben und ihr Ergebnis fest, bevor du ihren Rumpf schreibst. In einem gewöhnlichen C-Programm mit einer Host-Umgebung beginnt die Ausführung in main.

Eine Definition erstellen

int square(int n)
{
    return n * n;
}

Die Definition hat einen Rückgabetyp (int), einen Namen (square), eine Parameterliste (int n) und einen Rumpf in geschweiften Klammern. Der Parameter ist die lokale Variable, die eine Eingabe erhält. Ein Argument ist der Wert, den ein Aufruf übergibt: In square(6) ist dieser Wert 6. Der Aufruf ergibt 36. Definiere jede Funktion auf Dateiebene außerhalb anderer Funktionen; Standard-C erlaubt keine verschachtelten Funktionsdefinitionen.

Jeder Parameter braucht einen eigenen Typ. Schreibe int max(int a, int b) und trenne die Deklarationen durch ein Komma. Gib bei einem Aufruf Werte ohne ihre Typen an: max(8, 3).

Einen Wert an den Aufrufer zurückgeben

int max(int a, int b)
{
    if (a > b)
        return a;
    return b;
}

Ein return beendet den aktuellen Aufruf sofort. Bei max(8, 3) wird das erste return ausgeführt, sodass das zweite nie erreicht wird. Ein zurückgegebener Ausdruck wird in den Rückgabetyp der Funktion umgewandelt. Wähle diesen Typ so, dass die benötigte Art von Ergebnis erhalten bleibt.

Verwende für ein Ergebnis mit Nachkommateil durchgehend Gleitkommaarithmetik:

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

Der Aufruf c_to_f(37.0) gibt 98.6 zurück. Eine Ganzzahlversion mit c * 9 / 5 + 32 gibt 98 zurück, weil die Division den Nachkommateil abschneidet. Stellst du den Ausdruck zu 9 / 5 * c + 32 um, wird zuerst 9 / 5 zu 1 ausgewertet, was für 37 den Wert 69 ergibt. Ein Gleitkomma-Rückgabetyp allein kann eine bereits im Rumpf ausgeführte Ganzzahlberechnung nicht rückgängig machen.

Das Ergebnis verwenden

Ein Aufruf, der einen Wert zurückgibt, ist ein Ausdruck. Mit der obigen Definition ergibt square(3) + square(4) den Wert 25. In square(square(2)) gibt der innere Aufruf 4 zurück. Dieser Wert wird zum Argument des äußeren Aufrufs, der 16 ergibt. Eine Anweisung wie square(5); ist zulässig, verwirft aber den zurückgegebenen Wert.

Ausgeben und Zurückgeben erfüllen unterschiedliche Aufgaben. printf zeigt Text an; return liefert ein Ergebnis, das der Aufrufer speichern oder in einem anderen Ausdruck verwenden kann. Erreicht eine gewöhnliche Funktion mit einem anderen Rückgabetyp als void ihre schließende Klammer, ohne zurückzukehren, und verwendet der Aufrufer ihr Ergebnis, ist das Verhalten undefiniert. Kompiliere mit -Wall -Wextra, um fehlende Rückgaben leichter zu finden.

Funktionen, die keinen Wert liefern

Eine void-Funktion erledigt eine Aufgabe, ohne einen Wert zurückzugeben. Sie kann mit return; vorzeitig beendet werden. Zum Beispiel kann void print_line(int width) eine Zeile mit Bindestrichen ausgeben, aber int x = print_line(5); ist ungültig, weil der Aufruf keinen Wert liefert. Soll die Funktion keine Eingaben entgegennehmen, schreibe void in die Parameterliste, wie in int read_sensor(void).

int main(void) gibt einen Status an die Host-Umgebung zurück. Verwende return 0; für Erfolg; <stdlib.h> stellt außerdem EXIT_SUCCESS und EXIT_FAILURE bereit. Das Erreichen des Endes von main gibt automatisch null zurück. Diese Ausnahme gilt nicht für andere Funktionen, die einen Wert zurückgeben.

Ein Funktionsaufruf benötigt eine Deklaration, die der Compiler bereits gesehen hat. Steht die Definition später, setze einen Prototyp vor den ersten Aufruf. Der Prototyp teilt dem Compiler mit, wie er den Aufruf prüfen soll, ohne den Funktionsrumpf bereitzustellen.

Die Zusage vom Rumpf trennen

#include <stdio.h>

double c_to_f(double c);

int main(void)
{
    printf("%.1f\n", c_to_f(25.0));
    return 0;
}

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

Der Prototyp endet mit einem Semikolon. Die Definition hat einen Rumpf und kein Semikolon zwischen ihrer Parameterliste und der öffnenden geschweiften Klammer. Eine nützliche Anordnung ist: Headerdateien, Prototypen, main, dann weitere Definitionen. Die Ausgabe lautet hier 77.0.

Parameternamen sind in Prototypen optional: double c_to_f(double); deklariert dieselbe Funktion. Namen wie c können eine Eingabe dokumentieren, müssen aber nicht mit den Namen in der Definition übereinstimmen. Alle Deklarationen müssen beim Rückgabetyp und den Parametertypen übereinstimmen. Eine verwendete Funktion benötigt eine Definition; wiederholte kompatible Prototypen erzeugen keine weiteren Funktionen.

Was der Compiler prüft

Mit einem Prototyp prüft der Compiler die Anzahl der Argumente und wandelt jeden übergebenen Wert in den deklarierten Parametertyp um. Bei double c_to_f(double c); haben sowohl c_to_f() als auch c_to_f(20.0, 5.0) die falsche Anzahl und erfordern eine Diagnose.

Ein Unterschied zwischen numerischen Typen kann dagegen eine zulässige Umwandlung sein:

int half(int n)
{
    return n / 2;
}

Bei half(7.9) erhält der Parameter durch die Umwandlung zunächst den Wert 7. Die Ganzzahldivision ergibt dann 3. Bei half(-7.9) ergibt die Umwandlung -7 und die Division -3. In beiden Fällen werden Nachkommateile in Richtung null abgeschnitten. Der Aufruf erhält den ursprünglichen double-Wert nicht allein deshalb, weil das Argument mit einem Dezimalpunkt geschrieben wurde. Ergänze -Wconversion, wenn du Warnungen zu solchen Umwandlungen erhalten möchtest.

Ausdrücklich angeben, wenn es keine Parameter gibt

In C17 verhindert eine leere Parameterliste in einer Deklaration eine vollständige Argumentprüfung; sie erlaubt keine beliebigen Argumente für die spätere Funktion. Verwende durchgehend (void). GCC 15 hat seinen standardmäßigen C-Dialekt auf gnu23 geändert, sodass -std=c17 den beabsichtigten Standard ausdrücklich festlegt, wenn du diesen Beispielen folgst.

Ein Deklarationsproblem beheben

Der Aufruf einer nicht deklarierten Funktion verstößt gegen modernes C. Binde die Standardheaderdatei ein, die sie deklariert, etwa <stdio.h> für printf, oder ergänze einen eigenen passenden Prototyp. Aktuelle Versionen von GCC und Clang lehnen implizite Deklarationen normalerweise ab.

Ein Prototyp wie double area(double r); kann nicht zu einer Definition passen, die float zurückgibt und float entgegennimmt. Binde die Headerdatei eines Moduls in die Datei ein, die seine Funktionen definiert, damit der Compiler sie vergleichen kann. Versuche nicht, eine Typabweichung durch eine explizite Typumwandlung beim Aufruf zu beheben: Korrigiere Deklaration und Definition so, dass sie dieselbe Funktion beschreiben.

C übergibt jedes Argument als Wert: Jeder Parameter beginnt mit einer Kopie des Werts seines Arguments. Eine Zuweisung an einen gewöhnlichen Ganzzahlparameter ändert diese Kopie, auch wenn der Parameter denselben Namen wie eine Variable des Aufrufers hat.

Die Kopie verfolgen

Mit eingebundenem <stdio.h> und dieser Definition vor ihrem Aufruf:

void double_it(int n)
{
    n *= 2;
    printf("inside: %d\n", n);
}

Der Aufrufer führt aus:

int score = 21;
double_it(score);
printf("after: %d\n", score);

Die Ausgabe lautet inside: 42, danach after: 21. Der Parameter ändert sich von 21 auf 42; keine Anweisung weist dem score des Aufrufers einen Wert zu.

Ein zurückgegebenes Ergebnis behalten

int doubled(int n)
{
    return n * 2;
}

Die Funktion berechnet einen Wert; die Zuweisung des Aufrufers aktualisiert dessen Variable. Die Rückgabe des Werts einer lokalen Variablen ist sicher: int total = a + b; return total; kopiert den Wert heraus, bevor die automatische lokale Variable aufhört zu existieren. Berechnungen, die nur Parameter und zurückgegebene Ergebnisse verwenden, lassen sich testen, ohne versteckten gemeinsam genutzten Zustand einzurichten.

Verstehen, warum ein Tausch nur mit Werten scheitert

void swap(int a, int b)
{
    int t = a;
    a = b;
    b = t;
}

Nach int p = 3, q = 7; swap(p, q); gelten beim Aufrufer weiterhin p == 3 und q == 7. Der Rumpf hat seine Kopien vertauscht. Um Objekte des Aufrufers über Parameter zu ändern, sind ihre Adressen nötig, die als Zeigerwerte übergeben werden.

Argumente in eine Reihenfolge bringen, wenn sie wichtig ist

Argumente können Ausdrücke wie a + 1 oder square(b) sein. Ihre Auswertung ist abgeschlossen, bevor der Rumpf der aufgerufenen Funktion beginnt, aber ihre Auswertungsreihenfolge ist nicht festgelegt. Zwei Aufrufe einer zustandsändernden Funktion next_ticket() in einer Ausgabe können die Ticketnummern in beliebiger Reihenfolge liefern. Verwende getrennte Anweisungen:

int first = next_ticket();
int second = next_ticket();
printf("%d %d\n", first, second);

Vermeide f(i, i++): Das nicht sequenzierte Lesen und Ändern von i führt zu undefiniertem Verhalten.

Ein Aufruf hält seinen Aufrufer an, bis ein Ergebnis bereitsteht. Verfolgst du die aktiven Aufrufe, verstehst du, wie ein Programm an die richtige Stelle zurückkehrt und warum Rekursion eine Abbruchregel braucht.

Einen Datensatz pro aktivem Aufruf führen

Die meisten Implementierungen verwenden einen Aufrufstapel. Jeder aktive Aufruf hat einen Stackframe, der seine Parameterwerte, automatischen lokalen Variablen und die Fortsetzungsstelle im Aufrufer festhält. Der Standard legt das Verhalten fest, ohne diese bestimmte Speicheranordnung vorzuschreiben.

Wenn main die Funktion print_table aufruft und print_table die Funktion c_to_f aufruft, kehrt die Umrechnungsfunktion zuerst zurück. Die Ausführung wird in print_table fortgesetzt, das später zu main zurückkehrt. Gewöhnliche automatische lokale Variablen gehören zu einem Aufruf. Bei einer statischen lokalen Variablen ist es anders: Alle Aufrufe teilen sich ihren einen gespeicherten Wert.

Eine rekursive Berechnung abwärts verfolgen

Eine rekursive Funktion ruft sich selbst für ein kleineres Problem auf. Ein Basisfall kehrt direkt zurück; ein Rekursionsfall nähert sich ihm an.

int factorial(int n)
{
    if (n <= 1)
        return 1;
    return n * factorial(n - 1);
}

Bei factorial(4) kann der erste Aufruf seine Multiplikation erst abschließen, wenn factorial(3) zurückkehrt. Dieser Aufruf wartet auf factorial(2), das auf factorial(1) wartet.

Am tiefsten Punkt sind vier Fakultätsaufrufe aktiv. Jeder hat sein eigenes n; das Erreichen von n == 1 ändert die Werte der früheren Aufrufe nicht.

Die Rückgaben aufwärts verfolgen

Der Aufruf im Basisfall gibt 1 zurück. Der Aufruf mit n == 2 berechnet nun 2 * 1 und gibt 2 zurück. Der nächste gibt 3 * 2, also 6, zurück; der erste gibt 4 * 6, also 24, zurück. Trage die Rückgabewerte beim Aufstieg in ein Ablaufprotokoll ein, nachdem das Ergebnis der aufgerufenen Funktion bekannt ist.

Die Abbruchbedingung muss für die unterstützten Eingaben erreichbar sein. Lautete die Prüfung n == 1, würde der Start bei null zu weiteren Aufrufen mit -1, -2 und kleineren Werten führen, statt eins zu erreichen. Fortgesetzte Rekursion erschöpft Ressourcen und kann zum Absturz führen. Die umfassendere Prüfung n <= 1 stoppt diese Eingaben, obwohl die mathematische Fakultät für nichtnegative Ganzzahlen verwendet wird.

Sowohl die Tiefe als auch den Ergebnistyp prüfen

Ein korrekter Abbruch garantiert nicht, dass das Ergebnis in den Typ passt. Auf einer Plattform mit einem 32-Bit-int ist der größte Wert 2147483647. factorial(12) ergibt 479001600, was hineinpasst; factorial(13) bräuchte 6227020800, was nicht hineinpasst. Ein Überlauf bei vorzeichenbehafteten Ganzzahlen führt zu undefiniertem Verhalten.

Eine Schleife kann die Fakultät berechnen und dabei ein laufendes Produkt in einem Funktionsaufruf führen. Rekursion ist nützlich, wenn das nächste Problem dieselbe Struktur in kleinerem Maßstab hat. Bei positiven Ganzzahlen ist die Summe der Ziffern ein weiteres Beispiel: sum_digits(472) benötigt 2 + sum_digits(47), dann 2 + 7 + sum_digits(4), was 13 ergibt. Ein Ablaufprotokoll sollte sowohl die kleiner werdende Eingabe als auch die spätere Verknüpfung der zurückgegebenen Werte zeigen.

Der Gültigkeitsbereich ist der Teil des Quelltexts, in dem ein Name verwendet werden kann. Lies die geschweiften Klammern und Deklarationen, um zu ermitteln, welche Variable ein Ausdruck bezeichnet; die Reihenfolge der Aufrufe ändert diese Regeln nicht.

Die Begrenzung des Gültigkeitsbereichs finden

Eine innerhalb eines Blocks deklarierte Variable hat Blockgültigkeitsbereich. Er beginnt unmittelbar nach ihrem Deklarator und endet an der schließenden Klammer dieses Blocks. Parameter sind innerhalb ihrer Funktionsrümpfe sichtbar. Eine Deklaration in einem for-Kopf wie for (int i = 0; i < 10; i++) macht i während dieser Schleife verfügbar, aber nicht danach.

Ein außerhalb aller Funktionen deklarierter Name hat Dateigültigkeitsbereich, der von seiner Deklaration bis zum Ende der Übersetzungseinheit reicht. Funktionen oberhalb dieser Deklaration benötigen eine frühere Deklaration, um ihn zu verwenden. Ein Parametername in einem Prototyp hat Funktionsprototyp-Gültigkeitsbereich, der mit dem Prototyp endet. Daher kann auf double c_to_f(double c); eine Definition folgen, die den Parameter degrees nennt.

Verdeckung von innen nach außen verfolgen

#include <stdio.h>

int x = 10;

void show(void)
{
    printf("%d\n", x);
}

int main(void)
{
    int x = 5;
    {
        int x = 1;
        printf("%d\n", x);
    }
    printf("%d\n", x);
    show();
    return 0;
}

Die innere Ausgabe verwendet 1, die nächste verwendet 5, und show gibt 10 aus. Es gilt die nächstgelegene sichtbare Deklaration von x. Beim Verlassen des inneren Blocks wird die äußere lokale Variable wieder sichtbar. Der Aufruf von show macht die lokale Variable von main dort nicht sichtbar: show wurde dort definiert, wo das x mit Dateigültigkeitsbereich sichtbar ist.

Verschiedene Funktionen dürfen jeweils ein lokales i, count oder result deklarieren. Dies sind unterschiedliche Variablen, weil ihre Deklarationen zu verschiedenen Blöcken gehören.

Einen Wert so deklarieren, dass er später verwendet werden kann

Dieser Code lässt sich nicht kompilieren:

if (temp > 30.0) {
    int warning = 1;
}
printf("%d", warning);

Die Ausgabe liegt außerhalb des Gültigkeitsbereichs von warning. Muss der Wert danach verwendet werden, deklariere und initialisiere ihn vor der bedingten Anweisung:

int warning = 0;
if (temp > 30.0) {
    warning = 1;
}
printf("%d", warning);

Die Initialisierung liefert auch den Wert für den Pfad, bei dem die Bedingung falsch ist.

Eine versehentlich neue Variable vermeiden

Die Deklaration int total = 0; innerhalb einer Schleife erzeugt bei jedem Eintritt in ihren Block eine neue lokale Variable. Wenn du Werte in einem äußeren total aufsummieren wolltest, verwende eine Zuweisung wie total += value;. Aktiviere -Wshadow, um verdeckte Namen leichter zu finden.

Der Gültigkeitsbereich beginnt, bevor der Initialisierer ausgewertet wird. Innerhalb eines Blocks liest int x = x + 1; das neue, nicht initialisierte x, auch wenn ein äußeres x existiert. Verwende einen anderen Namen, wenn der Initialisierer den äußeren Wert benötigt.

Der Gültigkeitsbereich beschreibt, wo ein Name im Quellcode sichtbar ist. Die Speicherdauer beschreibt, wie lange das zugehörige Objekt während der Programmausführung existiert. Eine statische lokale Variable hat Blockgültigkeitsbereich, während ihr gespeicherter Wert während der gesamten Ausführung existiert.

Die Speicherdauer beschreibt, wie lange der Speicher einer Variablen existiert. Verwende automatische Variablen für Aufgaben, die zu einem Aufruf gehören, und statischen Speicher, wenn ein Wert zwischen Aufrufen erhalten bleiben muss.

Einen neuen Wert mit einem gespeicherten Wert vergleichen

Parameter und gewöhnliche Variablen mit Blockgültigkeitsbereich haben automatische Speicherdauer. Jeder Funktionsaufruf erhält seine eigenen Instanzen. Eine Deklaration ohne Initialisierer wie int sum; liefert keinen brauchbaren Anfangswert. Initialisiere einen Akkumulator, bevor du ihn liest: int sum = 0;.

Variablen mit Dateigültigkeitsbereich und als static deklarierte Variablen mit Blockgültigkeitsbereich haben statische Speicherdauer. Sie existieren während der gesamten Programmausführung. Die Initialisierung erfolgt einmal vor dem Programmstart; ohne ausdrücklichen Initialisierer beginnen numerische Objekte bei null.

int next_ticket(void)
{
    static int n = 0;
    n++;
    return n;
}

Drei Aufrufe in getrennten Anweisungen geben 1, 2 und 3 zurück. Der Initialisierer wird beim Eintritt in die Funktion nicht erneut ausgeführt. Entfernst du static, entsteht bei jedem Aufruf ein neues automatisches n = 0, sodass alle drei Aufrufe 1 zurückgeben.

Der Name n hat weiterhin Blockgültigkeitsbereich. Andere Funktionen können ihn nicht direkt benennen. Auch rekursive Aufrufe teilen sich dieselbe statische lokale Variable; sie erhalten keine getrennten statischen Kopien wie bei automatischen lokalen Variablen.

Einmal initialisieren, bei Bedarf zuweisen

Ein statischer numerischer Initialisierer muss in C ein konstanter Ausdruck sein. static int limit = 12; ist zulässig; static int limit = read_sensor(); ist unzulässig. Nimm eine Zuweisung zur Laufzeit im ausführbaren Code vor, wenn ein Wert aus einem Aufruf stammen muss. Eine Anweisung wie n = 0; wird immer ausgeführt, wenn die Ausführung sie erreicht. Stünde sie am Anfang von next_ticket, würde sie den Zähler bei jedem Aufruf zurücksetzen.

Die Speicherklassenspezifizierer verstehen

Moderne Compiler wählen die Registerbelegung selbst, sodass das Schreiben von register den Code selten verbessert. auto int x; bedeutet in C17 dasselbe wie ein gewöhnliches lokales int x;. C23 erlaubt außerdem die Typinferenz mit auto x = 3.5;, was ein double deklariert.

C17 hat außerdem _Thread_local, in C23 thread_local geschrieben, für Thread-Speicher. Die Grammatik zählt typedef zu den Speicherklassenspezifizierern, obwohl es einen Typ benennt, statt Speicher auszuwählen. In C17 steht normalerweise nur ein Speicherklassenspezifizierer in einer Deklaration; _Thread_local kann zusätzlich zu static oder extern stehen.

Ein extern int count; im Blockgültigkeitsbereich erzeugt keine automatische lokale Kopie. Es deklariert ein Objekt mit Bindung und statischer Speicherdauer. Berücksichtige immer, wo die Deklaration steht, bevor du entscheidest, was ein Speicherklassen-Schlüsselwort bewirkt.

Eine globale Variable wird im Dateigültigkeitsbereich außerhalb aller Funktionen deklariert. Sie behält während der gesamten Ausführung einen Wert und kann mehreren Funktionen Zugriff auf gemeinsam genutzten Zustand geben.

Das gemeinsam genutzte Objekt verfolgen

#include <stdio.h>

double total_km = 0.0;

void add_trip(double km)
{
    total_km += km;
}

int main(void)
{
    add_trip(12.5);
    add_trip(7.25);
    printf("%.2f\n", total_km);
    return 0;
}

Beide Aufrufe aktualisieren dasselbe Objekt und ergeben 19.75. Der Parameter km ist weiterhin eine Kopie; die Funktion weist unabhängig davon einer globalen Variablen, die sie benennen kann, einen Wert zu. Die Wertübergabe verhindert diese Zuweisung nicht.

Globale Variablen haben statische Speicherdauer. Numerische globale Variablen beginnen standardmäßig bei null und benötigen konstante Ausdrücke als Initialisierer: int error_count; beginnt bei 0, und double limit = 2.5 * 4; beginnt bei 10.0.

Sichtbarkeit und Verdeckung prüfen

Ein globaler Name ist nur unterhalb seiner Deklaration sichtbar. Eine Funktion oberhalb der Definition benötigt eine frühere Deklaration, etwa extern double total_km;.

Enthält add_trip stattdessen:

double total_km = 0.0;
total_km += km;

so erzeugt und aktualisiert die Funktion ein lokales Objekt. Die globale Variable bleibt unverändert. Entferne die zusätzliche Deklaration, um die gemeinsam genutzte Summe zu aktualisieren; -Wshadow hilft, versehentliche Verdeckung zu erkennen.

Eingaben ausdrücklich angeben, wenn gemeinsamer Zustand unnötig ist

Ein gemeinsam genutzter Fehlerzähler kann nützlich sein, wenn mehrere Funktionen Fehler melden. Eine Berechnung, die eine globale Variable liest, hat jedoch eine Eingabe, die in ihrer Parameterliste fehlt. Tests müssen diesen Zustand herstellen, und um einen falschen Wert zurückzuverfolgen, musst du die Stellen finden, die ihn möglicherweise schreiben.

Eine Alternative für die Streckenberechnung ist:

double with_trip(double total, double km)
{
    return total + km;
}

Der Aufrufer verwendet total = with_trip(total, 12.5);. Ein Test übergibt beide Eingaben direkt, ohne globale Variablen vorbereiten zu müssen.

Gemeinsam genutzte Namen beschränken

Gewöhnliche Variablen mit Dateigültigkeitsbereich haben externe Bindung. Nutze eine solche Variable über Deklarationen und eine Definition gemeinsam; wiederholte Definitionen in verschiedenen Dateien zerstören diese Anordnung. static im Dateigültigkeitsbereich bewirkt dagegen interne Bindung, sodass eine andere Datei ein eigenes unabhängiges Objekt mit demselben Namen haben kann. Beide Objekte bestehen weiterhin während der gesamten Ausführung: Das Schlüsselwort beschränkt hier die Bindung, nicht die Lebensdauer.

Der Präprozessor wandelt Quelltext um, bevor der Compiler C-Ausdrücke und Typen prüft. Seine Direktiven beginnen mit #. Untersuche seine Ausgabe mit gcc -E file.c, wenn sich eine Einbindung oder Makroexpansion schwer erklären lässt.

Deklarationen einbinden und Konstanten benennen

#include <stdio.h> fügt eine Standardheaderdatei ein. Verwende #include "convert.h" für eine Headerdatei des Projekts: GCC durchsucht zuerst das Verzeichnis der einbindenden Datei und dann seine konfigurierten Header-Suchpfade. Die Option -Iinclude fügt ein Suchverzeichnis hinzu. Das Einbinden kopiert Headertext; es linkt keine kompilierten Funktionen.

Ein objektähnliches Makro ersetzt Tokens:

#define MAX_STUDENTS 30

Spätere Verwendungen des Tokens MAX_STUDENTS werden zu 30. Der Präprozessor lässt die Zeichenkette "MAX_STUDENTS" und den anderen Namen MAX_STUDENTS_2 unverändert. Schreibe weder = noch ein abschließendes Semikolon. Mit #define PI 3.14159; wird return PI * r * r; zum fehlerhaften Code return 3.14159; * r * r; expandiert. Eine Direktive endet normalerweise am Zeilenumbruch; ein abschließender umgekehrter Schrägstrich setzt sie fort.

Vor dem Rechnen expandieren

Bei einem funktionsähnlichen Makro steht kein Leerzeichen zwischen seinem Namen und der öffnenden Klammer:

#define SQUARE_BAD(x) x * x
#define SQUARE(x) ((x) * (x))

SQUARE_BAD(2 + 3) wird zu 2 + 3 * 2 + 3, was 11 ergibt. 100 / SQUARE_BAD(5) wird zu 100 / 5 * 5, was 100 ergibt. Das geklammerte Makro ergibt entsprechend 25 und 4. Setze jeden Parameter und den gesamten Ersetzungsausdruck in Klammern, damit umgebende Operatoren seine Gruppierung nicht ändern können.

Schreibst du stattdessen #define SQUARE (x) ((x) * (x)), entsteht ein objektähnliches Makro, dessen Ersetzungstext mit (x) beginnt. Das Leerzeichen ändert die Bedeutung der Definition.

Klammern verhindern keine wiederholte Auswertung

SQUARE(i++) wird zu ((i++) * (i++)) expandiert. Es ändert i zweimal ohne Sequenzierung, sodass das Verhalten undefiniert ist. Eine echte Funktion wie square(i++) wertet das Argument einmal aus, bevor sie in den Rumpf eintritt. Bevorzuge für Berechnungen Funktionen, insbesondere wenn ein Eingabeausdruck den Zustand ändert.

Ein funktionsähnliches Makro hat keine deklarierten Parameter- oder Rückgabetypen. Sein expandierter C-Code wird weiterhin auf Typen geprüft, aber es hat keinen Prototyp, der Argumentkonvertierungen festlegt. Makros bleiben für Include-Guards, bedingte Kompilierung und ganzzahlige konstante Ausdrücke nützlich. In C17 ist eine const int-Variable kein ganzzahliger konstanter Ausdruck; ein Makro oder eine enum-Konstante kann einen case-Wert liefern. C23 führt außerdem constexpr ein.

Argumente in Tokens oder Text umwandeln

#define SHOW(expr) printf(#expr " = %d\n", expr)
#define CAT(a, b) a##b

SHOW(3 + 4); verwendet #, um das Argument in Text umzuwandeln, und gibt 3 + 4 = 7 aus. CAT(temp, 1) verwendet ##, um Tokens zum Namen temp1 zu verbinden. Die Stringifizierung verwendet die übergebenen Argument-Tokens, ohne Makros innerhalb dieses Vorkommens zu expandieren; ein gewöhnliches Vorkommen des Arguments wird expandiert.

Makros folgen nicht dem Blockgültigkeitsbereich. Eine Definition bleibt bis zu #undef NAME oder bis zum Ende der Übersetzungseinheit aktiv, auch wenn die Direktive zwischen geschweiften Klammern geschrieben wurde. Entferne eine alte Definition mit #undef, bevor du ihr einen anderen Ersetzungstext gibst.

Die bedingte Kompilierung wählt aus, welche Quelltextzeilen den Compiler erreichen. Sie kann Debug-Ausgaben aktivieren, plattformspezifischen Code auswählen oder eine Headerdatei vor wiederholtem Einbinden schützen.

Existenz oder Wert prüfen

#define DEBUG 0

#ifdef DEBUG
/* Kept: DEBUG exists. */
#endif

#if DEBUG
/* Removed: DEBUG expands to zero. */
#endif

#ifdef DEBUG fragt, ob das Makro definiert ist. #if DEBUG wertet seinen Ersetzungswert als ganzzahligen konstanten Ausdruck aus. Innerhalb von #if zählt ein nicht definierter Bezeichner als null; ein falsch geschriebener Makroname kann einen Zweig stillschweigend entfernen. Die Ausdrücke defined DEBUG und defined(DEBUG) prüfen beide die Existenz.

Verwende #ifndef NAME für die umgekehrte Existenzprüfung. Schließe jede bedingte Anweisung mit #endif. #elif fügt eine weitere Bedingung hinzu und #else stellt die Alternative bereit. C23 ergänzt #elifdef und #elifndef; C17 kann diese Prüfungen mit #elif defined(NAME) oder #elif !defined(NAME) ausdrücken.

Die Einstellung beim Erstellen wählen

#ifdef DEBUG
printf("debug: c = %.1f\n", c);
#endif

gcc -std=c17 -DDEBUG main.c definiert DEBUG als 1 und behält die Ausgabe bei. Ohne diese Definition wird die Zeile vor der Kompilierung entfernt. -DLEVEL=2 liefert einen Wert, als stünde #define LEVEL 2 vor dem Text der Datei.

Das unterscheidet sich von einem gewöhnlichen if, dessen Bedingung zur Laufzeit ausgewertet wird. Präprozessorbedingungen können keine gewöhnliche Laufzeitvariable lesen. #if 0 entfernt einen Block, auch wenn sein Code bereits /* */-Kommentare enthält, die ein sicheres Einschließen in einen weiteren solchen Kommentar verhindern würden.

Eine Headerdatei schützen

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);

#endif

Das erste Einbinden definiert CONVERT_H und behält den Prototyp bei. Späteres Einbinden in derselben Übersetzungseinheit überspringt den Inhalt. Verwende einen unverwechselbaren Namen für den Include-Guard, der auf dem Namen der Headerdatei beruht; vermeide führende Unterstriche, die für die Implementierung reserviert sind. Eine andere Übersetzungseinheit beginnt ihren eigenen Präprozessierungslauf und bindet die Deklarationen für sich ein. Ein Include-Guard verhindert nicht, dass verschiedene Objektdateien dasselbe externe Symbol definieren.

Viele Compiler unterstützen #pragma once, aber es ist keine ISO-C-Direktive. Include-Guards funktionieren mit standardisierten bedingten Direktiven.

Die vordefinierten Informationen lesen

Zu den Versionswerten gehören 199901L für C99, 201112L für C11, 201710L für C17 und 202311L für C23. __func__ enthält den Namen der aktuellen Funktion, ist aber ein vordefinierter Bezeichner und kein Makro.

Ein plattformabhängiger Zweig kann defined(_WIN32) oder defined(__linux__) prüfen und anschließend #else für eine Alternative verwenden. Um eine nicht unterstützte Erstellung ausdrücklich abzulehnen, schreibe eine Bedingung, gefolgt von #error "This program needs C11 or later" und #endif. Ein fehlendes #endif erzeugt dagegen einen Direktivenfehler wie „unterminated conditional directive“.

Bei der getrennten Kompilierung wird jede Quelldatei vor dem Linken des Programms in eine Objektdatei umgewandelt. So können unveränderte Objektdateien beim Erstellen wiederverwendet werden, und zusammengehörige Funktionen erhalten einen klaren Platz.

Die Erstellungsschritte verfolgen

Eine Übersetzungseinheit ist eine .c-Datei nach der Präprozessierung einschließlich der Inhalte ihrer eingebundenen Headerdateien. Jede Einheit wird unabhängig kompiliert.

Eine Objektdatei enthält Maschinencode und Symbolinformationen über Namen, die sie definiert oder benötigt. Auf Unix-ähnlichen Systemen hat sie gewöhnlich die Endung .o. Der Linker verbindet Verwendungen externer Namen mit Definitionen aus Objektdateien und Bibliotheken.

Zwei Dateien kompilieren und linken

Angenommen, convert.h deklariert double c_to_f(double c);, convert.c bindet diese Headerdatei ein und definiert die Funktion, und main.c bindet die Headerdatei ein und ruft sie auf.

gcc -Wall -Wextra -std=c17 -c main.c
gcc -Wall -Wextra -std=c17 -c convert.c
gcc main.o convert.o -o temp

Der erste Befehl erzeugt main.o, ohne zu linken. Der zweite erzeugt convert.o. Der letzte erstellt die ausführbare Datei temp aus beiden Objektdateien. Du kannst auch mit einem Befehl kompilieren und linken:

gcc -Wall -Wextra -std=c17 main.c convert.c -o temp

Übergib die Quelldateien zum Kompilieren und die Objektdateien zum Linken. Headerdateien gelangen über #include hinein; führe sie nicht als getrennt zu kompilierende Programmquellen auf. Ändert sich nur convert.c, verwende main.o wieder, erstelle convert.o erneut und linke erneut. Ändert sich eine gemeinsam genutzte Headerdatei, erstelle jede Objektdatei erneut, deren Quelldatei sie einbindet.

Den fehlgeschlagenen Schritt untersuchen

Ein Übersetzungsfehler betrifft eine Übersetzungseinheit: ungültige Syntax, eine falsche Argumentanzahl oder widersprüchliche sichtbare Typen. Der Linker kann diese Fehler nicht beheben.

Ein Linkerfehler betrifft das assemblierte Programm. Erstellst du nur main.c, kann die Kompilierung dank des Prototyps gelingen, während das Linken „undefined reference to c_to_f“ oder „Undefined symbols“ meldet. Die Deklaration kündigt eine Funktion an; sie liefert nicht deren Maschinencode. Ergänze convert.c bei einer kombinierten Erstellung oder convert.o beim Linken.

Zwei gelinkte externe Definitionen derselben Funktion verursachen einen Fehler wegen eines doppelten Symbols. Ein gewöhnliches Programm hat ein main; das Linken zweier Quellen, die beide diese Funktion definieren, schlägt fehl. Auf ihre Datei beschränkte static-Funktionen können in verschiedenen Übersetzungseinheiten gleiche Namen haben, weil sie interne Bindung besitzen.

Auch Bibliotheken liefern Definitionen. Auf vielen Linux-Systemen benötigt Code, der in <math.h> deklarierte Funktionen verwendet, eine Linkoption für die Mathematikbibliothek: gcc main.c -o app -lm. Setze diese Bibliotheksoption hinter den Code, der sie benötigt.

Die Schnittstelle einbinden, die Implementierung kompilieren

Vermeide #include "convert.c". Das kopiert Funktionsrümpfe in eine andere Übersetzungseinheit. Wird convert.c ebenfalls kompiliert und gelinkt, erscheinen seine externen Definitionen doppelt. Die .h-Datei eines Moduls stellt seine Deklarationen gemeinsam bereit; seine .c-Datei wird einmal als Quelldatei kompiliert.

Die Headerdatei eines Moduls stellt seine Schnittstelle gemeinsam bereit; seine Quelldatei liefert die Implementierung. Sowohl Aufrufer als auch Implementierung binden die Headerdatei ein, damit ihre Deklarationen übereinstimmen.

Die Schnittstelle einmal deklarieren

Eine geschützte convert.h enthält:

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);
double f_to_c(double f);

#endif

Die Implementierung in convert.c bindet sie vor den Rümpfen ein:

#include "convert.h"

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

double f_to_c(double f)
{
    return (f - 32.0) * 5.0 / 9.0;
}

Ein Aufrufer bindet dieselbe Headerdatei und <stdio.h> ein. Der Aufruf printf("%.1f %.1f\n", c_to_f(25.0), f_to_c(212.0)); gibt 77.0 100.0 aus.

Definiert die Implementierung float c_to_f(float c), macht das Einbinden ihrer Headerdatei die widersprüchlichen Typen für den Compiler sichtbar. Bei unabhängiger Kompilierung ohne diese Deklaration kann die Abweichung unentdeckt bleiben.

Den richtigen Inhalt wählen

Eine Headerdatei mit int count = 0; definiert in jeder einbindenden Übersetzungseinheit ein Objekt und verursacht doppelte externe Definitionen. Selbst int count; ist eine vorläufige Definition. Die Standardeinstellung von GCC meldet seit Version 10 wiederholte Kopien beim Linken, während manche Toolchains gemeinsame Symbole zusammenführen und den Fehler verbergen. Verwende extern int count; in der Headerdatei und eine Definition in einer Quelldatei.

Das Einbinden zuverlässig gestalten

Ein Include-Guard verhindert wiederholte Verarbeitung innerhalb einer Übersetzungseinheit, auch beim indirekten Einbinden über andere Headerdateien. Kompatible Prototypen dürfen sich wiederholen, aber Typdefinitionen wie ein enum können Fehler wegen erneuter Definition verursachen.

Eine eigenständige Headerdatei bindet ein, was ihre Deklarationen benötigen. Verwendet ein Prototyp size_t, binde dort <stddef.h> ein. Aufrufer sollten keine besondere Reihenfolge beim Einbinden benötigen.

Bei Headerdateien des Projekts bewirken Anführungszeichen, dass GCC zuerst das Verzeichnis der einbindenden Datei durchsucht. Füge ein separates Headerverzeichnis mit -Iinclude hinzu, wie in gcc -Iinclude -std=c17 -c src/main.c. Die Objektdatei der Implementierung muss weiterhin gelinkt werden.

Die Bindung bestimmt, ob sich Deklarationen an verschiedenen Stellen auf dieselbe Entität beziehen. Sie unterscheidet sich vom Gültigkeitsbereich, der beschreibt, wo ein Name verwendet werden kann, und von der Speicherdauer, die beschreibt, wie lange ein Objekt existiert.

Einen Namen mit einem Objekt verbinden

Funktionen und gewöhnliche Variablen mit Dateigültigkeitsbereich haben standardmäßig externe Bindung. static im Dateigültigkeitsbereich bewirkt interne Bindung. Gewöhnliche automatische lokale Variablen und Parameter haben keine Bindung.

Um einen Fehlerzähler gemeinsam zu nutzen, setze diese Deklarationen in eine geschützte Headerdatei:

extern int error_count;
void log_error(int code);

Eine Quelldatei bindet diese Headerdatei ein und stellt Folgendes bereit:

int error_count = 0;

void log_error(int code)
{
    printf("error: %d\n", code);
    error_count++;
}

Diese Quelldatei bindet für printf auch <stdio.h> ein. Andere Quelldateien binden die gemeinsam genutzte Headerdatei ein, keine zweite Definition. Nach drei Aufrufen bezieht sich jeder Aufrufer, der error_count liest, auf dasselbe Objekt und sieht 3.

Deklaration und Definition unterscheiden

extern int error_count; deklariert ein vorhandenes Objekt und reserviert keinen neuen Speicher. int error_count = 0; definiert es. Ein Initialisierer ändert den Fall: Im Dateigültigkeitsbereich ist extern int error_count = 0; trotz des Schlüsselworts eine Definition. Belasse den Initialisierer in der einen definierenden Datei.

Bei gewöhnlichen öffentlichen Funktionsdeklarationen ist extern optional: double c_to_f(double c); deklariert bereits eine Funktion mit externer Bindung. Binde die öffentliche Deklaration in ihrer definierenden Datei ein, damit der Compiler die Kompatibilität prüfen kann.

Zustand hinter Funktionen verbergen

static int count = 0;

void counter_increment(void)
{
    count++;
}

int counter_value(void)
{
    return count;
}

Der gespeicherte Wert existiert während der gesamten Ausführung, aber nur diese Übersetzungseinheit kann über den Namen count darauf zugreifen. Setze die öffentlichen Funktionsprototypen in eine Headerdatei. Eine andere Datei kann den Zähler über diese Funktionen erhöhen und lesen, ohne die interne Variable direkt zu ändern. Auch eine Hilfsfunktion kann static sein, wenn andere Dateien sie nicht benötigen.

Eine falsche Bindungswahl untersuchen

Eine Definition static int count; in einer Headerdatei erzeugt in jeder einbindenden Übersetzungseinheit einen unabhängigen internen Zähler. Die Aktualisierung eines Zählers aktualisiert die anderen nicht. Include-Guards führen diese Objekte nicht zusammen: Jede Übersetzungseinheit präprozessiert ihre eigene Kopie der Headerdatei.

Eine in einer Übersetzungseinheit als static definierte Funktion kann einen externen Aufruf aus einer anderen nicht erfüllen; das Linken schlägt für diesen externen Namen fehl. Gib nur Funktionen, die andere Dateien benötigen, externe Bindung und deklariere diese in der Headerdatei.

Innerhalb einer Funktion gibt static einer lokalen Variablen dauerhaften Speicher, ohne ihren Gültigkeitsbereich zu erweitern. Außerhalb von Funktionen gibt es einem Objekt oder einer Funktion interne Bindung. Variablen mit Dateigültigkeitsbereich haben mit oder ohne dieses Schlüsselwort statische Speicherdauer.

make liest Makefile oder makefile im Projektverzeichnis und aktualisiert das angeforderte Ziel. Ohne Zielargument erstellt es normalerweise das erste gewöhnliche Ziel.

Ausgaben und Eingaben festhalten

Eine Regel beginnt mit target: prerequisites. Ihr Rezept steht entweder in den folgenden, mit Tabulator eingerückten Zeilen oder nach einem Semikolon in derselben Zeile:

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g

temp: main.o convert.o; $(CC) $(CFLAGS) -o temp main.o convert.o

main.o: main.c convert.h; $(CC) $(CFLAGS) -c main.c

convert.o: convert.c convert.h; $(CC) $(CFLAGS) -c convert.c

.PHONY: clean
clean:; rm -f temp main.o convert.o

Hier ist temp das Standardziel. make clean fordert die Aufräumaktion an. Schreibst du ein Rezept in die nächste Zeile, verwende ein echtes Tabulatorzeichen: Leerzeichen können „missing separator“ verursachen. Eine Editoreinstellung, die Leerraumzeichen sichtbar macht, hilft, den Unterschied zu erkennen.

Entscheidungen über erneutes Erstellen verfolgen

Make aktualisiert zuerst die Abhängigkeiten eines Ziels. Anschließend erstellt es das Ziel erneut, wenn es fehlt oder eine Abhängigkeit einen neueren Änderungszeitpunkt hat.

• Erste Erstellung: Beide Quelldateien kompilieren, dann temp linken, drei Befehle.
• Keine Änderungen: Es müssen keine Programmrezepte ausgeführt werden.
• Nur convert.c ändern: Erneut kompilieren und linken, zwei Befehle; main.o wiederverwenden.
• convert.h ändern: Beide Quelldateien erneut kompilieren und linken, drei Befehle.

Die Headerdatei betrifft beide Übersetzungseinheiten, obwohl keine der beiden Quelldateien bearbeitet wurde. Stell dir vor, wie Eingabedateien in Objektdateien und diese anschließend in die ausführbare Datei einfließen. Änderungen wirken sich entlang dieser festgehaltenen Beziehungen aus.

Header-Abhängigkeiten berücksichtigen

Die unvollständige Regel main.o: main.c erfasst Änderungen an convert.h nicht. Make liest keinen C-Quelltext, um Einbindungen zu entdecken; es folgt den deklarierten Abhängigkeiten. Führe eingebundene Headerdateien auf oder lade vom Compiler generierte Abhängigkeitsdateien, um das Linken veralteter Objektdateien zu vermeiden.

Abhängige Shell-Vorgänge zusammenhalten

Getrennte Rezeptzeilen verwenden normalerweise getrennte Shells. Eine Zeile, die nur cd build enthält, ändert das Verzeichnis für die nächste Zeile nicht. Verwende einen Befehl wie cd build && gcc -c ../main.c, wenn die Kompilierung von diesem Verzeichniswechsel abhängt. Sieh dir geplante Rezepte mit make -n vorab an.

Variablen und Musterregeln vermeiden wiederholte Compilerbefehle und erhalten dabei den Abhängigkeitsgraphen. Die Beispiele setzen jedes Rezept nach einem Semikolon in seine Regelzeile. Kürze ein Makefile erst, nachdem seine Abhängigkeiten für die Erstellung korrekt sind.

Gemeinsam genutzte Einstellungen benennen

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g
OBJS = main.o convert.o

temp: $(OBJS); $(CC) $(CFLAGS) -o $@ $^

%.o: %.c convert.h; $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

.PHONY: clean
clean:; rm -f temp $(OBJS)

$(CC) expandiert die Compilervariable; $(CFLAGS) expandiert ihre Optionen. CPPFLAGS enthält üblicherweise Präprozessoroptionen wie -DDEBUG oder -Iinclude. Die Optionen -Wall -Wextra aktivieren Warnungen, -g fügt Debuginformationen hinzu und -O2 aktiviert die Optimierung. Nicht definierte make-Variablen werden zu leerem Text expandiert. Schreibe $(CC), nicht $CC: Letzteres bedeutet die einbuchstabige Variable C, gefolgt von einem wörtlichen C.

Automatische Variablen innerhalb einer Regel lesen

Für main.o ist der Stamm des Musters main, sodass %.c zu main.c wird. Das Kompilierrezept verwendet $<, um diese Quelldatei an den Compiler zu übergeben, und $@, um main.o zu benennen. Die Headerdatei ist eine Abhängigkeit, wird aber nicht als weitere Eingabe für die Kompilierung übergeben.

In der Linkregel sind alle Abhängigkeiten Objektdateien. $^ wird zu main.o convert.o expandiert, und $@ wird zu temp. Würdest du dort $< verwenden, würde nur main.o übergeben und die Definitionen in convert.o gingen verloren.

GNU make hat eingebaute Regeln, die x.c unter Verwendung von CC, CPPFLAGS und CFLAGS zu x.o kompilieren können. Eine ausdrückliche Abhängigkeitsregel ohne Rezept kann dieses eingebaute Rezept verwenden. GNU make kann sogar mit make hello ein einfaches Programm aus hello.c ohne Makefile erstellen.

Aktionsziele als Pseudoziele kennzeichnen

clean bezeichnet eine Aktion und keine zu erstellende Datei. .PHONY: clean stellt sicher, dass die Aktion auch ausgeführt wird, wenn eine Datei namens clean existiert. rm -f toleriert, dass Dateien bereits fehlen. Auch ein all-Ziel, das mehrere Programme zusammenfasst, ist gewöhnlich ein Pseudoziel.

Headerlisten generieren und erneutes Erstellen untersuchen

Füge -MMD -MP zu den Compileroptionen hinzu, um neben jeder Objektdatei eine .d-Datei zu schreiben. -MMD hält Abhängigkeiten von eigenen Headerdateien fest; -MP fügt leere Regeln hinzu, die helfen, wenn eine erfasste Headerdatei entfernt wird. Lade die Listen nach dem gewöhnlichen Standardziel mit:

-include $(OBJS:.o=.d)

Die Ersetzung wandelt Objektdateinamen in Namen von Abhängigkeitsdateien um. Das führende Minus toleriert fehlende .d-Dateien bei der ersten Erstellung. Entferne diese generierten Dateien in clean zusammen mit den Objektdateien.

make -n zeigt Befehle vorab, make -B erzwingt erneutes Erstellen und make -j4 erlaubt bis zu vier Rezepte gleichzeitig. Korrekte Abhängigkeiten sind auch für parallele Erstellungen wichtig. Eine Änderung des Texts von CFLAGS allein macht vorhandene Objektdateien nicht älter als eine Abhängigkeit. Verwende nach einer Änderung der Optionen make -B oder erstelle nach einer Bereinigung erneut, damit jede Objektdatei die neuen Einstellungen verwendet.