C Academy · Les

Projecten met meerdere bestanden

Headers en translation units

Les 2 van 413 stappen

Projecten met meerdere bestanden is een gratis C Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.

Waarom bestanden splitsen

Echte programma's staan niet in één .c-bestand. Door code over meerdere bestanden te verdelen:

groepeer je verwante functies
hoeft de compiler alleen opnieuw te bouwen wat is gewijzigd
kun je code in meerdere projecten hergebruiken
kan een team werken zonder voortdurend conflicten te veroorzaken

Begrijpen hoe de onderdelen worden gekoppeld, is essentieel.

Translatie-eenheden

Elk .c-bestand wordt, nadat de preprocessor zijn #includes heeft uitgebreid, een translatie-eenheid.

De compiler zet elke translatie-eenheid onafhankelijk om in een objectbestand (.o). In deze fase weet de compiler niets van andere bestanden.

Declaratie versus definitie

Een declaratie vertelt de compiler dat een functie bestaat en wat de signatuur ervan is. Een definitie bevat de daadwerkelijke functie-inhoud.

Andere bestanden hebben alleen de declaratie nodig om een functie aan te roepen. De definitie staat precies op één plaats.

int add(int a, int b);          /* declaration: a promise */

int add(int a, int b) {         /* definition: the body */
    return a + b;
}

Het headerbestand

Declaraties zet je in een header (.h). Elk bestand dat de functie wil gebruiken, neemt de header op.

De header is de openbare interface; het bijbehorende .c-bestand is de private implementatie.

/* math_utils.h */
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int mul(int a, int b);

#endif

Het implementatiebestand

Het .c-bestand neemt zijn eigen header op en definieert de functies.

Door je eigen header op te nemen kan de compiler controleren of de definities overeenkomen met de declaraties.

/* math_utils.c */
#include "math_utils.h"

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

De module gebruiken

Een ander bestand neemt de header op en roept de functies aan. Het hoeft de functie-inhoud nooit te zien.

De compiler vertrouwt op de declaraties; de linker koppelt de aanroepen later aan de echte definities.

/* main.c */
#include <stdio.h>
#include "math_utils.h"

int main(void) {
    printf("%d\n", add(2, 3));
    return 0;
}

Compileren en koppelen

Twee fasen. Eerst compileer je elk bestand met -c naar een objectbestand. Daarna koppel je de objectbestanden tot één uitvoerbaar bestand.

De linker lost elke aanroep van add op door de definitie ervan in math_utils.o te vinden.

gcc -c main.c          # -> main.o
gcc -c math_utils.c    # -> math_utils.o
gcc main.o math_utils.o -o app

Aanhalingstekens versus punthaken

De include-syntaxis bepaalt het zoekpad:

#include "math_utils.h" zoekt eerst in de projectmap
#include <stdio.h> zoekt alleen in systeempaden voor includes

Gebruik aanhalingstekens voor je eigen headers en punthaken voor de standaardbibliotheek.

Het sleutelwoord extern

Als je een globale variabele over meerdere bestanden wilt delen, definieer je deze één keer in een .c-bestand en declareer je deze met extern in de header.

extern betekent: 'deze variabele bestaat ergens anders'. Zo voorkom je dubbele definities.

/* in config.h */
extern int g_verbose;   /* declaration */

/* in config.c */
int g_verbose = 0;      /* the single definition */

Het sleutelwoord static

Op bestandsniveau maakt static een functie of variabele privé voor zijn translatie-eenheid.

Een statische hulpfunctie kan niet vanuit andere bestanden worden gekoppeld. Zo voorkom je naamconflicten en verberg je implementatiedetails. In C is dit de manier om iets als intern te markeren.

/* visible only inside this .c file */
static int helper(int x) {
    return x * 2;
}

De regel van één definitie

Een niet-statische functie of globale variabele mag in het hele programma precies één keer worden gedefinieerd. Declareer deze in meerdere bestanden, maar definieer deze in één bestand.

Twee definities van add veroorzaken een linkerfout zoals multiple definition of 'add'. Daarom blijven functiebodys buiten headerbestanden.

Korte controle

Redeneer na wat er in een headerbestand hoort.

Beantwoord dit in de interactieve les

Samenvatting

Je kunt nu een project met meerdere bestanden structureren:

Elke .c is een vertaaleenheid die afzonderlijk wordt gecompileerd naar een .o
Headerbestanden bevatten declaraties; één .c-bestand bevat elke definitie
De linker lost aanroepen tussen objectbestanden op
extern deelt globale variabelen; static houdt bestand-lokale symbolen privé

Volgende stap: de build automatiseren met Makefiles.

Gratis beginnen

Leer C met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Projecten met meerdere bestanden” gratis?

Ja — de volledige tekst van “Projecten met meerdere bestanden” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.

Wat leer ik in “Projecten met meerdere bestanden”?

Headers en translation units Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C Academy te beginnen?

Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Projecten met meerdere bestanden”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C Academy?

Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C Academy