C Academy · Lektion

extern und Linkage

Teilen Sie Symbole über Dateien hinweg.

extern und Linkage ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Linkage?

Linkage beschreibt, ob ein Name zwischen verschiedenen Quelldateien gemeinsam verwendet werden kann.

Ein Name mit externer Bindung verweist im gesamten Programm auf dasselbe Element. Ein Name mit interner Bindung ist auf seine eigene Datei beschränkt. Das Verständnis von Linkage ist entscheidend für Programme, die aus mehreren Dateien bestehen.

Eine Variable gemeinsam nutzen

Angenommen, zwei Dateien benötigen Zugriff auf einen globalen Zähler. Sie können ihn nicht einfach in beiden Dateien definieren; dadurch entstehen zwei separate Variablen und beim Linken ein Fehler wegen eines doppelten Symbols.

Stattdessen definieren Sie ihn einmal und deklarieren ihn überall sonst mit extern.

/* config.c */
int g_count = 0;   /* the one definition */

Das Schlüsselwort extern

extern teilt dem Compiler mit, dass eine Variable an einer anderen Stelle im Programm existiert, ohne hier Speicher für sie zu reservieren.

Es handelt sich um eine reine Deklaration. Der Linker löst sie später zur einzigen Definition in einer anderen Datei auf.

/* other.c */
extern int g_count;   /* declared, not defined */

void bump(void) {
    g_count++;
}

Deklaration im Header

Das saubere Muster: Platzieren Sie die extern-Deklaration in einem Header und die zugehörige Definition in genau einer Quelldatei.

Jede Datei, die den Header einbindet, kann dann die gemeinsame Variable verwenden.

/* config.h */
#ifndef CONFIG_H
#define CONFIG_H
extern int g_count;
#endif

Eine Definition, viele Deklarationen

Das ist die One Definition Rule für globale Variablen: Eine Variable darf in vielen Dateien mit extern deklariert, aber nur in einer Datei definiert werden.

Die einzige Definition (ohne extern) reserviert den Speicher. Alle extern-Deklarationen verweisen lediglich darauf.

/* config.h */ extern int g_count;  /* declaration */
/* config.c */ int g_count = 0;     /* definition  */

Auch Funktionen haben externe Linkage

Funktionen haben standardmäßig ebenfalls externe Linkage. Deshalb ermöglicht ein Prototyp in einem Header anderen Dateien, diese Funktionen aufzurufen.

Sie können vor einen Prototypen extern schreiben, aber das ist redundant; Funktionen sind extern, solange Sie nichts anderes angeben.

/* both forms mean the same */
int add(int a, int b);
extern int add(int a, int b);

Interne Linkage mit static

Das Schlüsselwort static auf Dateiebene verleiht einem Namen interne Linkage: Er ist nur innerhalb seiner eigenen Quelldatei sichtbar.

Verwenden Sie es für Hilfsfunktionen und globale Variablen, die privat in einem Modul bleiben sollen. Andere Dateien können sie weder sehen noch mit ihnen in Konflikt geraten.

/* parser.c */
static int line_no = 0;   /* private to parser.c */

static void advance(void) {  /* private helper */
    line_no++;
}

extern vs. static

Diese beiden Schlüsselwörter stehen an entgegengesetzten Enden der Linkage.

extern fordert externe Linkage an: Der Name wird dateiübergreifend geteilt. static auf Dateiebene erzwingt interne Linkage: Der Name bleibt privat. Mit der richtigen Wahl legen Sie fest, was Ihr Modul nach außen sichtbar macht.

extern int shared_total;   /* visible everywhere */
static int local_cache;    /* only this file */

Ein häufiger Fehler

Anfänger platzieren manchmal eine gewöhnliche Definition wie int g_count; in einem Header.

Da der Header in mehrere Dateien eingebunden wird, erhält jede Datei ihre eigene Definition, und der Linker meldet ein doppeltes Symbol. Deklarieren Sie im Header immer mit extern und definieren Sie die Variable einmal in einer .c-Datei.

/* WRONG in a header included twice */
int g_count;          /* multiple definition */
/* RIGHT */
extern int g_count;   /* declaration only */

Alles zusammenführen

Diese Struktur aus drei Dateien ist die übliche Methode, um Zustände gemeinsam zu nutzen.

Der Header deklariert die Variable, eine Quelldatei definiert sie und andere verwenden sie nach dem Einbinden des Headers. Der Linker verbindet alle Verweise mit der einzigen Definition.

/* config.h */ extern int g_count;
/* config.c */ #include "config.h"
               int g_count = 0;
/* main.c   */ #include "config.h"
               /* uses g_count */

Hinweis zur Initialisierung

Nur die tatsächliche Definition sollte einen Anfangswert festlegen: int g_count = 0;.

Eine extern-Deklaration darf nicht initialisieren, da sie keinen Speicher reserviert. extern int g_count = 0; wird dadurch zu einer Definition und verfehlt den Zweck.

extern int g_count;       /* ok: declaration */
extern int g_count = 0;   /* becomes a definition */

Kurze Überprüfung

Überprüfen Sie Ihr Verständnis von extern und Linkage.

Zusammenfassung

Sie haben gelernt, dass die Linkage die dateiübergreifende Sichtbarkeit steuert. extern deklariert einen an anderer Stelle definierten Namen; static auf Dateiebene hält einen Namen privat.

Teilen Sie globale Variablen mit einer Definition und mehreren extern-Deklarationen. Als Nächstes werden Sie diese Dateien zu einem Programm kompilieren und linken.

Häufig gestellte Fragen

Ist die Lektion „extern und Linkage“ kostenlos?

Ja — der vollständige Text von „extern und Linkage“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „extern und Linkage“?

Teilen Sie Symbole über Dateien hinweg. Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „extern und Linkage“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy