Compileren met gcc

In Python typ je python3 kassabon.py en het programma draait. In C gaat dat anders: eerst vertaalt een compiler je broncode naar machinecode, en pas daarna kun je het resultaat uitvoeren. Die extra stap voelt in het begin omslachtig, maar hij levert snelle programma's op en de compiler vangt veel fouten voordat je programma ooit draait.

In deze les compileer je je eerste C-programma met gcc, zet je waarschuwingen aan en leer je het verschil tussen compileren en linken.

Hallo wereld in C

#include <stdio.h>

int main(void) {
    printf("Hallo, wereld!\n");
    return 0;
}

Regel voor regel:

• #include <stdio.h> haalt de declaraties van de standaard in- en uitvoerfuncties binnen, waaronder printf.
• int main(void) is het startpunt. Elk C-programma heeft precies één main. void betekent: geen parameters.
• printf schrijft tekst. \n is een nieuwe regel; die komt er niet vanzelf bij zoals bij Python's print.
• return 0; geeft de exitcode terug aan het besturingssysteem. 0 betekent "gelukt".
• Elke opdracht eindigt met een puntkomma, en blokken staan tussen { } in plaats van inspringing.

Bewaar dit als hallo.c en compileer:

gcc hallo.c -o hallo
./hallo

-o hallo bepaalt de naam van het uitvoerbare bestand (executable). Zonder -o heet het a.out.

Waarschuwingen aanzetten: -Wall -Wextra

Standaard is gcc opvallend stil. Veel verdachte code compileert zonder één melding. Zet daarom altijd waarschuwingen aan:

gcc -std=c17 -Wall -Wextra -o hallo hallo.c

Voorspel eerst: wat zegt gcc over dit programma?

#include <stdio.h>

int main(void) {
    int totaal = 12;
    printf("Totaal: %d euro\n", totaal);
    int ongebruikt;   /* FOUT: wordt nooit gebruikt */
    return 0;
}

Met -Wall krijg je:

hallo.c:6:9: warning: unused variable 'ongebruikt' [-Wunused-variable]

Een melding heeft altijd dezelfde vorm: bestand:regel:kolom: soort: tekst. Begin bij de eerste melding; latere meldingen zijn vaak een gevolg daarvan.

Compileren versus linken

gcc hallo.c -o hallo lijkt één stap, maar het zijn er eigenlijk vier:

1. Preprocessor: verwerkt #include en #define (plakt de header letterlijk in je bestand).
2. Compiler: vertaalt C naar assembly.
3. Assembler: maakt er een objectbestand (.o) van: machinecode, maar nog niet compleet.
4. Linker: plakt objectbestanden en bibliotheken samen tot één executable en koppelt aanroepen (zoals printf) aan de echte code.

Je kunt de stappen los zien:

gcc -c hallo.c        # alleen compileren → hallo.o
gcc hallo.o -o hallo  # alleen linken → hallo

Bij één bestand merk je dit niet. Zodra je project uit meerdere bestanden bestaat (les 5) wordt het belangrijk: elk .c-bestand wordt los gecompileerd en de linker brengt ze samen.

Uitgewerkt voorbeeld: een kassabon

#include <stdio.h>

int main(void) {
    double koffie = 3.20;
    double appeltaart = 4.50;
    int aantal_koffie = 2;

    double totaal = aantal_koffie * koffie + appeltaart;
    printf("2x koffie      %6.2f\n", aantal_koffie * koffie);
    printf("1x appeltaart  %6.2f\n", appeltaart);
    printf("Totaal         %6.2f\n", totaal);
    return 0;
}

Voorspel de uitvoer voordat je het draait. %6.2f betekent: een kommagetal, 6 tekens breed, 2 cijfers achter de punt.

2x koffie        6.40
1x appeltaart    4.50
Totaal          10.90

Typische fouten

undefined reference. Dit is een linkerfout, geen compilerfout:

#include <stdio.h>

double bereken_btw(double bedrag);   /* FOUT: alleen gedeclareerd, nergens gedefinieerd */

int main(void) {
    printf("%.2f\n", bereken_btw(100.0));
    return 0;
}

/usr/bin/ld: /tmp/cc1.o: in function `main':
hallo.c:(.text+0x15): undefined reference to `bereken_btw'
collect2: error: ld returned 1 exit status

De compiler was tevreden (hij kende de declaratie), maar de linker kon de functie zelf niet vinden. Oorzaken: tikfout in de naam, de definitie vergeten, of een .c-bestand niet meegeven aan gcc. Herkenbaar aan ld en collect2 in de melding.

implicit declaration. Je gebruikt printf maar vergat #include <stdio.h>. Moderne gcc-versies maken hier een fout van.

Puntkomma vergeten. De melding wijst vaak naar de regel ná de echte fout: expected ';' before 'return'.

Oefeningen

1. Compileer het kassabonvoorbeeld met -Wall -Wextra. Voeg een derde product toe (thee, 2,80) en pas het totaal aan.
2. Haal #include <stdio.h> weg en compileer opnieuw. Lees de melding: is dit een compiler- of linkerfout?
3. Laat main return 3; doen. Draai het programma en typ daarna echo $?. Wat zie je, en waarom?

Lab: kassabon in C compileren

Samenvatting

• C is een gecompileerde taal: eerst gcc, dan ./programma.
• Compileer altijd met -Wall -Wextra (en in labs -Werror).
• Compileren maakt objectbestanden, linken plakt ze samen. undefined reference is een linkerfout.
• Een foutmelding lees je als bestand:regel:kolom, en je begint bij de eerste.

In de volgende les kijk je naar typen: waarom C precies wil weten hoeveel geheugen een variabele inneemt.