Functies en programmastructuur in C

Een functie bundelt één taak zodat een ander deel van het programma die kan aanroepen. Geef de functie een naam die de taak beschrijft en kies de invoer en het resultaat voordat je het functieblok schrijft. In een gewoon C-programma met een hostomgeving begint de uitvoering in main.

Maak een definitie

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

De definitie heeft een retourtype (int), een naam (square), een parameterlijst (int n) en een functieblok tussen accolades. De parameter is de lokale variabele die invoer ontvangt. Een argument is de waarde die bij een aanroep wordt opgegeven: in square(6) is die waarde 6. De aanroep levert 36 op. Definieer elke functie op bestandsniveau, buiten andere functies; standaard-C staat geen geneste functiedefinities toe.

Elke parameter heeft een eigen type nodig. Schrijf int max(int a, int b), met een komma tussen de declaraties. Geef bij een aanroep waarden op zonder hun typen: max(8, 3).

Geef een waarde terug aan de aanroepende functie

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

Een return beëindigt de huidige aanroep onmiddellijk. Bij max(8, 3) wordt de eerste return uitgevoerd, zodat de tweede nooit wordt bereikt. Een teruggegeven expressie wordt geconverteerd naar het retourtype van de functie. Kies dat type zo dat het soort resultaat dat je nodig hebt behouden blijft.

Gebruik voor een resultaat met een breuk overal drijvendekommarekenen:

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

De aanroep c_to_f(37.0) geeft 98.6 terug. Een geheeltallige versie met c * 9 / 5 + 32 geeft 98 terug, omdat de deling de breuk weglaat. Als je de volgorde wijzigt in 9 / 5 * c + 32, wordt eerst 9 / 5 geëvalueerd tot 1, wat voor 37 de waarde 69 oplevert. Een drijvendekomma-retourtype alleen kan een geheeltallige berekening die al binnen het functieblok is uitgevoerd niet ongedaan maken.

Gebruik het resultaat

Een aanroep die een waarde teruggeeft, is een expressie. Met de definitie hierboven geeft square(3) + square(4) de waarde 25. In square(square(2)) geeft de binnenste aanroep 4 terug; dat wordt het argument van de buitenste aanroep, die 16 oplevert. Een instructie zoals square(5); is toegestaan, maar gooit de teruggegeven waarde weg.

Afdrukken en teruggeven hebben verschillende taken. printf toont tekst; return levert een resultaat dat de aanroepende functie kan opslaan of in een andere expressie kan gebruiken. Als een gewone functie die niet void is de afsluitende accolade bereikt zonder iets terug te geven en de aanroepende functie het resultaat gebruikt, is het gedrag ongedefinieerd. Compileer met -Wall -Wextra om ontbrekende return-instructies op te sporen.

Functies die geen waarde opleveren

Een void-functie voert een taak uit zonder een waarde terug te geven. Ze kan met return; voortijdig eindigen. Zo kan void print_line(int width) een regel met streepjes afdrukken, maar int x = print_line(5); is ongeldig omdat de aanroep geen waarde oplevert. Om geen invoer te ontvangen schrijf je void in de parameterlijst, zoals in int read_sensor(void).

int main(void) geeft een status terug aan de hostomgeving. Gebruik return 0; voor succes; <stdlib.h> biedt ook EXIT_SUCCESS en EXIT_FAILURE. Als het einde van main wordt bereikt, wordt automatisch nul teruggegeven. Andere functies die een waarde teruggeven krijgen die uitzondering niet.

Een functieaanroep heeft een declaratie nodig die de compiler al heeft gezien. Als de definitie later komt, zet je een prototype vóór de eerste aanroep. Het prototype vertelt de compiler hoe die de aanroep moet controleren zonder het functieblok te leveren.

Scheid de declaratie van het functieblok

#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;
}

Het prototype eindigt met een puntkomma. De definitie heeft een functieblok en geen puntkomma tussen de parameterlijst en de openingsaccolade. Een handige indeling is: headerbestanden, prototypes, main en daarna de overige definities. De uitvoer is hier 77.0.

Parameternamen zijn optioneel in prototypes: double c_to_f(double); declareert dezelfde functie. Namen zoals c kunnen een invoerwaarde verduidelijken, maar hoeven niet overeen te komen met de namen in de definitie. Alle declaraties moeten overeenkomen in retourtype en parametertypen. Een gebruikte functie heeft één definitie nodig; door compatibele prototypes te herhalen ontstaan geen extra functies.

Wat de compiler controleert

Met een prototype controleert de compiler het aantal argumenten en converteert elke opgegeven waarde naar het gedeclareerde parametertype. Bij double c_to_f(double c); hebben zowel c_to_f() als c_to_f(20.0, 5.0) een onjuist aantal argumenten en is een diagnostische melding vereist.

Een verschil tussen numerieke typen kan daarentegen een toegestane conversie zijn:

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

Bij half(7.9) geeft de conversie de parameter eerst de waarde 7. Geheeltallige deling levert daarna 3 op. Bij half(-7.9) geeft de conversie -7 en levert de deling -3 op. In beide gevallen wordt de breuk afgekapt naar nul. De aanroep behoudt de oorspronkelijke double-waarde niet alleen omdat het argument met een decimale punt is geschreven. Voeg -Wconversion toe als je waarschuwingen over zulke conversies wilt.

Geef expliciet aan wanneer er geen parameters zijn

In C17 verhindert een lege parameterlijst in een declaratie een volledige controle van de argumenten; die staat geen willekeurige argumenten voor de uiteindelijke functie toe. Gebruik consequent (void). GCC 15 heeft het standaard C-dialect gewijzigd in gnu23, dus met -std=c17 maak je bij deze voorbeelden de bedoelde standaard expliciet.

Herstel een declaratieprobleem

Een niet-gedeclareerde functie aanroepen is in strijd met modern C. Neem het standaardheaderbestand op dat de functie declareert, zoals <stdio.h> voor printf, of voeg een eigen passend prototype toe. Huidige versies van GCC en Clang wijzen impliciete declaraties normaal gesproken af.

Een prototype zoals double area(double r); kan niet overeenkomen met een definitie die float teruggeeft en float ontvangt. Neem het headerbestand van een module op in het bestand dat de functies definieert, zodat de compiler ze kan vergelijken. Probeer een typeverschil niet op te lossen door bij de aanroep een expliciete typeconversie toe te voegen: corrigeer de declaratie en definitie zodat ze dezelfde functie beschrijven.

C geeft elk argument op waarde door: elke parameter begint met een kopie van de waarde van het argument. Een waarde toewijzen aan een gewone geheeltallige parameter verandert die kopie, ook als de parameter dezelfde naam heeft als een variabele van de aanroepende functie.

Volg de kopie

Met <stdio.h> opgenomen en deze definitie vóór de aanroep:

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

De aanroepende functie voert uit:

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

De uitvoer is inside: 42, gevolgd door after: 21. De parameter verandert van 21 in 42; geen enkele instructie wijst een waarde toe aan score van de aanroepende functie.

Bewaar een teruggegeven resultaat

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

De functie berekent een waarde; de toewijzing van de aanroepende functie werkt de eigen variabele bij. De waarde van een lokale variabele teruggeven is veilig: int total = a + b; return total; kopieert de waarde naar buiten voordat de automatische lokale variabele ophoudt te bestaan. Berekeningen die alleen parameters en teruggegeven resultaten gebruiken, kun je testen zonder verborgen gedeelde toestand in te richten.

Bekijk waarom verwisselen met alleen waarden mislukt

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

Na int p = 3, q = 7; swap(p, q); heeft de aanroepende functie nog steeds p == 3 en q == 7. Het functieblok heeft de kopieën verwisseld. Om objecten van de aanroepende functie via parameters te wijzigen zijn hun adressen nodig, die als pointerwaarden worden doorgegeven.

Leg de volgorde van argumenten vast als die ertoe doet

Argumenten kunnen expressies zijn zoals a + 1 of square(b). Ze worden allemaal geëvalueerd voordat het blok van de aangeroepen functie begint, maar hun evaluatievolgorde is niet gespecificeerd. Twee aanroepen van een next_ticket() die toestand wijzigt, kunnen in één afdrukopdracht de ticketnummers in beide volgorden leveren. Gebruik afzonderlijke instructies:

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

Vermijd f(i, i++): het niet-geordend lezen en wijzigen van i levert ongedefinieerd gedrag op.

Een aanroep pauzeert de aanroepende functie totdat een resultaat beschikbaar is. Door de actieve aanroepen te volgen zie je hoe een programma naar de juiste plaats terugkeert en waarom recursie een stopregel nodig heeft.

Houd per actieve aanroep één record bij

De meeste implementaties gebruiken een aanroepstapel (call stack). Elke actieve aanroep heeft een stackframe met de parameterwaarden, automatische lokale variabelen en de plaats waar de aanroepende functie verdergaat. De standaard specificeert het gedrag zonder deze specifieke geheugenindeling te vereisen.

Als main de functie print_table aanroept en print_table de functie c_to_f, keert de omzetfunctie als eerste terug. De uitvoering gaat verder binnen print_table, die later terugkeert naar main. Gewone automatische lokale variabelen horen bij één aanroep. Een statische lokale variabele is anders: alle aanroepen delen de ene opgeslagen waarde.

Volg een recursieve berekening omlaag

Een recursieve functie roept zichzelf aan voor een kleiner probleem. Een basisgeval keert direct terug; een recursief geval komt dichter bij het basisgeval.

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

Bij factorial(4) kan de eerste aanroep de vermenigvuldiging niet voltooien voordat factorial(3) terugkeert. Die aanroep wacht op factorial(2), die op factorial(1) wacht.

Op het diepste punt zijn vier aanroepen van factorial actief. Elk heeft een eigen n; het bereiken van n == 1 verandert de waarden van de eerdere aanroepen niet.

Volg de retourwaarden omhoog

De aanroep van het basisgeval geeft 1 terug. De aanroep met n == 2 berekent nu 2 * 1 en geeft 2 terug. De volgende geeft 3 * 2, oftewel 6, terug; de eerste geeft 4 * 6, oftewel 24, terug. Vul retourwaarden bij het terugkeren in het uitvoeringsspoor in, nadat het resultaat van de aangeroepen functie bekend is.

De stopvoorwaarde moet bereikbaar zijn voor de ondersteunde invoerwaarden. Als de test n == 1 zou zijn, zou een start bij nul steeds aanroepen met -1, -2 en lagere waarden opleveren in plaats van één te bereiken. Als de recursie doorgaat, raken de beschikbare middelen uitgeput en kan het programma crashen. De ruimere test n <= 1 stopt bij deze invoerwaarden, hoewel de wiskundige faculteit wordt gebruikt voor niet-negatieve gehele getallen.

Controleer zowel de diepte als het resultaattype

Correct stoppen garandeert niet dat het resultaat past. Op een platform met een 32-bits int is de grootste waarde 2147483647. factorial(12) geeft 479001600, wat past; factorial(13) zou 6227020800 nodig hebben, wat niet past. Overloop bij gehele getallen met teken leidt tot ongedefinieerd gedrag.

Een lus kan de faculteit berekenen met één doorlopend product binnen één functieaanroep. Recursie is nuttig wanneer het volgende probleem dezelfde structuur heeft maar kleiner is. Voor positieve gehele getallen is het optellen van cijfers een ander voorbeeld: sum_digits(472) heeft 2 + sum_digits(47) nodig, daarna 2 + 7 + sum_digits(4), wat 13 oplevert. Een uitvoeringsspoor moet zowel de kleiner wordende invoer als de latere combinatie van retourwaarden tonen.

Het geldigheidsgebied is het deel van de broncode waar je een naam kunt gebruiken. Bekijk de accolades en declaraties om te bepalen welke variabele een expressie aanduidt; de volgorde van aanroepen verandert deze regels niet.

Bepaal de grens van het geldigheidsgebied

Een variabele die binnen een blok wordt gedeclareerd, heeft een geldigheidsgebied binnen dat blok. Dit begint direct na de declarator en eindigt bij de afsluitende accolade van het blok. Parameters zijn zichtbaar binnen hun functieblok. Een declaratie in een for-kop, zoals for (int i = 0; i < 10; i++), maakt i beschikbaar binnen die lus, maar niet erna.

Een naam die buiten alle functies is gedeclareerd, heeft een geldigheidsgebied op bestandsniveau, vanaf de declaratie tot het einde van de vertaaleenheid. Functies boven die declaratie hebben een eerdere declaratie nodig om de naam te gebruiken. Een parameternaam in een prototype heeft een geldigheidsgebied van een functieprototype, dat eindigt bij het prototype. Zo kan op double c_to_f(double c); een definitie volgen die de parameter degrees noemt.

Volg naamverberging van binnen naar buiten

#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;
}

De binnenste afdrukopdracht gebruikt 1, de volgende gebruikt 5 en show drukt 10 af. De dichtstbijzijnde zichtbare declaratie van x geldt. Als je het binnenste blok verlaat, wordt de buitenste lokale variabele weer zichtbaar. Door show aan te roepen wordt de lokale variabele van main daarin niet zichtbaar: show is gedefinieerd op een plaats waar de x op bestandsniveau zichtbaar is.

Verschillende functies mogen elk een lokale i, count of result declareren. Dit zijn verschillende variabelen omdat hun declaraties bij verschillende blokken horen.

Declareer een waarde waar later gebruik die kan bereiken

Deze code compileert niet:

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

De afdrukopdracht staat buiten het geldigheidsgebied van warning. Als de waarde daarna moet worden gebruikt, declareer en initialiseer die dan vóór de voorwaardelijke instructie:

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

De initialisatie levert ook de waarde voor het pad waarop de voorwaarde onwaar is.

Voorkom een onbedoelde nieuwe variabele

Als je int total = 0; binnen een lus declareert, ontstaat elke keer dat het blok wordt binnengegaan een nieuwe lokale variabele. Als je in een buitenste total wilde optellen, gebruik dan een toewijzing zoals total += value;. Schakel -Wshadow in om verborgen namen op te sporen.

Het geldigheidsgebied begint voordat de initialisator wordt geëvalueerd. Binnen een blok leest int x = x + 1; de nieuwe, niet-geïnitialiseerde x, ook als een buitenste x bestaat. Gebruik een andere naam als de initialisator de buitenste waarde nodig heeft.

Het geldigheidsgebied beschrijft waar een naam zichtbaar is in de broncode. De opslagduur beschrijft hoelang het object bestaat terwijl het programma draait. Een statische lokale variabele heeft een geldigheidsgebied binnen een blok terwijl de opgeslagen waarde gedurende de hele uitvoering bestaat.

De opslagduur beschrijft hoelang de opslag van een variabele bestaat. Gebruik automatische variabelen voor werk dat bij één aanroep hoort en statische opslag wanneer een waarde tussen aanroepen moet blijven bestaan.

Vergelijk een nieuwe waarde met een bewaarde waarde

Parameters en gewone variabelen met een geldigheidsgebied binnen een blok hebben een automatische opslagduur. Elke functieaanroep krijgt eigen exemplaren. Een declaratie zonder initialisator, zoals int sum;, levert geen bruikbare beginwaarde. Initialiseer een accumulator voordat je die leest: int sum = 0;.

Variabelen op bestandsniveau en variabelen die binnen een blok als static zijn gedeclareerd, hebben een statische opslagduur. Ze bestaan gedurende de hele uitvoering van het programma. Initialisatie gebeurt één keer voordat het programma start; zonder expliciete initialisator beginnen numerieke objecten op nul.

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

Drie aanroepen in afzonderlijke instructies geven 1, 2 en 3 terug. De initialisator wordt niet opnieuw uitgevoerd wanneer de functie wordt binnengegaan. Als je static verwijdert, ontstaat voor elke aanroep een nieuwe automatische n = 0, zodat alle drie de aanroepen 1 teruggeven.

De naam n heeft nog steeds een geldigheidsgebied binnen het blok. Andere functies kunnen die niet rechtstreeks gebruiken. Ook recursieve aanroepen delen dezelfde statische lokale variabele; ze krijgen geen afzonderlijke statische kopieën zoals bij automatische lokale variabelen.

Initialiseer één keer, wijs toe wanneer nodig

Een statische numerieke initialisator moet in C een constante expressie zijn. static int limit = 12; is geldig; static int limit = read_sensor(); is ongeldig. Voer in uitvoerbare code een toewijzing tijdens de uitvoering uit wanneer een waarde uit een aanroep moet komen. Een instructie zoals n = 0; wordt uitgevoerd wanneer de uitvoering die bereikt. Als je die aan het begin van next_ticket plaatst, wordt de teller dus bij elke aanroep op nul gezet.

Lees de opslagklassespecificaties

Moderne compilers kiezen zelf de registertoewijzing, dus register schrijven verbetert de code zelden. auto int x; betekent in C17 hetzelfde als een gewone lokale int x;. C23 staat ook typeafleiding toe met auto x = 3.5;, wat een double declareert.

C17 heeft ook _Thread_local, in C23 geschreven als thread_local, voor threadopslag. De grammatica deelt typedef in bij de opslagklassespecificaties, hoewel het een type benoemt in plaats van opslag te kiezen. In C17 staat normaal gesproken maar één opslagklassespecificatie in een declaratie; _Thread_local kan ook samengaan met static of extern.

Een extern int count; binnen een blok maakt geen automatische lokale kopie. Die declareert een object met koppeling en statische opslagduur. Kijk altijd waar de declaratie staat voordat je bepaalt wat een opslagklassesleutelwoord doet.

Een globale variabele wordt op bestandsniveau gedeclareerd, buiten elke functie. Ze behoudt gedurende de hele uitvoering een waarde en kan verschillende functies toegang geven tot gedeelde toestand.

Volg het gedeelde object

#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 aanroepen werken hetzelfde object bij en leveren 19.75 op. De parameter km is nog steeds een kopie; daarnaast wijst de functie een waarde toe aan een globale variabele die binnen haar bereik ligt. Doorgifte op waarde verhindert die toewijzing niet.

Globale variabelen hebben statische opslagduur. Numerieke globale variabelen beginnen standaard op nul en vereisen constante expressies als initialisator: int error_count; begint op 0 en double limit = 2.5 * 4; begint op 10.0.

Controleer zichtbaarheid en naamverberging

Een globale naam is alleen zichtbaar onder de declaratie. Een functie boven de definitie heeft een eerdere declaratie nodig, zoals extern double total_km;.

Als add_trip in plaats daarvan het volgende bevat:

double total_km = 0.0;
total_km += km;

maakt de functie een lokaal object aan en werkt ze dat bij. De globale variabele blijft ongewijzigd. Verwijder de extra declaratie om het gedeelde totaal bij te werken; -Wshadow helpt onbedoelde naamverberging te herkennen.

Maak invoer expliciet als delen niet nodig is

Een gedeelde foutenteller kan nuttig zijn wanneer verschillende functies fouten melden. Maar een berekening die een globale variabele leest, heeft invoer die niet in de parameterlijst staat. Tests moeten die toestand instellen en om een verkeerde waarde te achterhalen moet je nagaan welke functies die kunnen wijzigen.

Een alternatief voor de ritberekening is:

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

De aanroepende functie gebruikt total = with_trip(total, 12.5);. Een test levert beide invoerwaarden rechtstreeks, zonder globale variabelen in te stellen.

Beperk gedeelde namen

Gewone variabelen op bestandsniveau hebben externe koppeling. Deel er één via declaraties en één definitie; herhaalde definities in verschillende bestanden verstoren die opzet. static op bestandsniveau geeft daarentegen interne koppeling, zodat een ander bestand een eigen onafhankelijk object met dezelfde naam kan hebben. Beide objecten bestaan nog steeds gedurende de hele uitvoering: het sleutelwoord beperkt hier de koppeling, niet de levensduur.

De preprocessor zet brontekst om voordat de compiler C-expressies en typen controleert. De richtlijnen beginnen met #. Bekijk de uitvoer met gcc -E file.c als een opname of macro-expansie moeilijk te verklaren is.

Neem declaraties op en geef constanten een naam

#include <stdio.h> voegt een standaardheaderbestand in. Gebruik #include "convert.h" voor een projectheaderbestand: GCC doorzoekt eerst de map van het bestand dat het headerbestand opneemt en daarna de ingestelde zoekpaden voor headerbestanden. De optie -Iinclude voegt een zoekmap toe. Opnemen kopieert de tekst van het headerbestand; het koppelt geen gecompileerde functies.

Een objectachtige macro vervangt tokens:

#define MAX_STUDENTS 30

Later gebruik van het token MAX_STUDENTS wordt 30. De preprocessor laat de string "MAX_STUDENTS" en de andere naam MAX_STUDENTS_2 ongemoeid. Schrijf geen = en geen afsluitende puntkomma. Met #define PI 3.14159; wordt return PI * r * r; uitgebreid tot de ongeldige code return 3.14159; * r * r;. Een richtlijn eindigt normaal gesproken bij de nieuwe regel; een afsluitende backslash zet de richtlijn voort.

Breid uit vóór het rekenen

Een functieachtige macro heeft geen spatie tussen de naam en het openingshaakje:

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

SQUARE_BAD(2 + 3) wordt 2 + 3 * 2 + 3, wat 11 oplevert. 100 / SQUARE_BAD(5) wordt 100 / 5 * 5, wat 100 oplevert. De gegroepeerde macro geeft respectievelijk 25 en 4. Zet haakjes om elke parameter en om de volledige vervangingsexpressie, zodat omringende operatoren de groepering niet kunnen veranderen.

Als je in plaats daarvan #define SQUARE (x) ((x) * (x)) schrijft, maak je een objectachtige macro waarvan de vervanging met (x) begint. De spatie verandert de betekenis van de definitie.

Haakjes voorkomen geen herhaalde evaluatie

SQUARE(i++) wordt uitgebreid tot ((i++) * (i++)). Dit wijzigt i tweemaal zonder vastgelegde volgorde, dus het gedrag is ongedefinieerd. Een echte functie zoals square(i++) evalueert het argument één keer voordat het functieblok begint. Geef voor berekeningen de voorkeur aan functies, vooral wanneer een invoerexpressie de toestand verandert.

Een functieachtige macro heeft geen gedeclareerde parameter- of retourtypen. De uitgebreide C-code wordt nog steeds op typen gecontroleerd, maar heeft geen prototype dat argumentconversies vastlegt. Macro’s blijven nuttig voor beveiligingen tegen herhaalde inclusie, voorwaardelijke compilatie en geheeltallige constante expressies. In C17 is een const int-variabele geen geheeltallige constante expressie; een macro of een enum-constante kan een case-waarde leveren. C23 introduceert ook constexpr.

Zet argumenten om in tokens of tekst

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

SHOW(3 + 4); gebruikt # om het argument in tekst om te zetten en drukt 3 + 4 = 7 af. CAT(temp, 1) gebruikt ## om tokens samen te voegen tot de naam temp1. Bij omzetting naar een stringliteral worden de opgegeven argumenttokens gebruikt zonder macro’s binnen dat voorkomen uit te breiden; een gewoon voorkomen van het argument wordt wel uitgebreid.

Macro’s volgen het geldigheidsgebied van blokken niet. Een definitie blijft actief tot #undef NAME of het einde van de vertaaleenheid, ook als de richtlijn tussen accolades is geschreven. Verwijder een oude definitie met #undef voordat je de macro een andere vervangingstekst geeft.

Voorwaardelijke compilatie selecteert welke bronregels de compiler bereiken. Daarmee kun je debuguitvoer inschakelen, platformcode kiezen of een headerbestand beschermen tegen herhaalde opname.

Test het bestaan of test een waarde

#define DEBUG 0

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

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

#ifdef DEBUG vraagt of de macro is gedefinieerd. #if DEBUG evalueert de vervangingswaarde als een geheeltallige constante expressie. Binnen #if telt een niet-gedefinieerde identifier als nul; een verkeerd gespelde macronaam kan ongemerkt een tak verwijderen. De expressies defined DEBUG en defined(DEBUG) testen beide het bestaan.

Gebruik #ifndef NAME om te testen of een macro niet bestaat. Sluit elke voorwaardelijke richtlijn af met #endif. #elif voegt een andere voorwaarde toe en #else biedt het alternatief. C23 voegt #elifdef en #elifndef toe; in C17 kun je die tests uitdrukken met #elif defined(NAME) of #elif !defined(NAME).

Kies de instelling tijdens het bouwen

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

gcc -std=c17 -DDEBUG main.c definieert DEBUG als 1 en behoudt de afdrukopdracht. Zonder die definitie wordt de regel vóór het compileren verwijderd. -DLEVEL=2 levert een waarde alsof #define LEVEL 2 vóór de tekst van het bestand stond.

Dit verschilt van een gewone if, waarvan de voorwaarde wordt geëvalueerd wanneer het programma draait. Voorwaarden van de preprocessor kunnen geen gewone variabele lezen die tijdens de uitvoering bestaat. #if 0 verwijdert een blok, ook als de code al /* */-commentaar bevat waardoor het onveilig zou zijn om het blok in nog zo’n commentaar te plaatsen.

Beveilig een headerbestand

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);

#endif

De eerste opname definieert CONVERT_H en behoudt het prototype. Latere opnamen in dezelfde vertaaleenheid slaan de inhoud over. Gebruik een onderscheidende naam voor de beveiliging, gebaseerd op de naam van het headerbestand; vermijd voorloopunderscores die voor de implementatie zijn gereserveerd. Een andere vertaaleenheid begint met een eigen preprocessing en neemt de declaraties voor zichzelf op. Een beveiliging voorkomt niet dat verschillende objectbestanden hetzelfde externe symbool definiëren.

Veel compilers ondersteunen #pragma once, maar dat is geen ISO C-richtlijn. Beveiligingen werken met standaard voorwaardelijke richtlijnen.

Lees de voorgedefinieerde informatie

Versiewaarden zijn onder andere 199901L voor C99, 201112L voor C11, 201710L voor C17 en 202311L voor C23. __func__ bevat de huidige functienaam, maar is een voorgedefinieerde identifier, geen macro.

Een platformtak kan defined(_WIN32) of defined(__linux__) testen en daarna #else gebruiken voor het alternatief. Om een niet-ondersteunde bouw expliciet af te wijzen, schrijf je een voorwaarde gevolgd door #error "This program needs C11 or later" en #endif. Een weggelaten #endif levert daarentegen een richtlijnfout op zoals “unterminated conditional directive”.

Bij afzonderlijke compilatie wordt elk bronbestand omgezet in een objectbestand voordat het programma wordt gekoppeld. Zo kan een bouw ongewijzigde objectbestanden hergebruiken en krijgen samenhangende functies een duidelijke plaats.

Volg de bouwstappen

Een vertaaleenheid is één .c-bestand na preprocessing, inclusief de inhoud van de opgenomen headerbestanden. Elke eenheid wordt onafhankelijk gecompileerd.

Een objectbestand bevat machinecode en symboolinformatie over namen die het definieert of nodig heeft. Op Unix-achtige systemen heeft het meestal de extensie .o. De linker verbindt het gebruik van externe namen met definities uit objectbestanden en bibliotheken.

Compileer twee bestanden en koppel ze

Stel dat convert.h de functie double c_to_f(double c); declareert, dat convert.c dat headerbestand opneemt en de functie definieert, en dat main.c het headerbestand opneemt en de functie aanroept.

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

De eerste opdracht levert main.o op zonder te koppelen. De tweede levert convert.o op. De laatste maakt het uitvoerbare bestand temp uit beide objectbestanden. Je kunt ook in één opdracht compileren en koppelen:

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

Geef de bronbestanden op voor compilatie en de objectbestanden voor koppeling. Headerbestanden komen binnen via #include; vermeld ze niet als afzonderlijk te compileren programmabronnen. Als alleen convert.c verandert, hergebruik je main.o, bouw je convert.o opnieuw en koppel je opnieuw. Als een gedeeld headerbestand verandert, bouw je elk objectbestand waarvan de bron het opneemt opnieuw.

Achterhaal welke stap is mislukt

Een compilatiefout betreft een vertaaleenheid: ongeldige syntaxis, een verkeerd aantal argumenten of tegenstrijdige zichtbare typen. De linker kan deze fouten niet herstellen.

Een linkerfout betreft het samengevoegde programma. Als je alleen main.c bouwt, kan het prototype ervoor zorgen dat het compileren slaagt, terwijl het koppelen “undefined reference to c_to_f” of “Undefined symbols” meldt. De declaratie belooft een functie; ze levert niet de machinecode ervan. Voeg convert.c toe aan een gecombineerde bouw of convert.o aan de koppelopdracht.

Twee gekoppelde externe definities van dezelfde functie veroorzaken een fout wegens een dubbel symbool. Een gewoon programma heeft één main; het koppelen van twee bronbestanden die beide deze functie definiëren mislukt. Bestandsgebonden static-functies kunnen in verschillende vertaaleenheden dezelfde naam hebben omdat ze interne koppeling hebben.

Ook bibliotheken leveren definities. Op veel Linux-systemen heeft code die functies uit <math.h> gebruikt een koppeloptie voor de wiskundebibliotheek nodig: gcc main.c -o app -lm. Zet die bibliotheekoptie na de code die de bibliotheek nodig heeft.

Neem de interface op, compileer de implementatie

Vermijd #include "convert.c". Dat kopieert functieblokken naar een andere vertaaleenheid. Als convert.c ook wordt gecompileerd en gekoppeld, komen de externe definities tweemaal voor. Het .h-bestand van een module deelt de declaraties; het .c-bestand wordt één keer als bronbestand gecompileerd.

Het headerbestand van een module deelt de interface; het bronbestand levert de implementatie. Zowel aanroepende bestanden als de implementatie nemen het headerbestand op, zodat hun declaraties overeenkomen.

Declareer de interface één keer

Een beveiligd convert.h bevat:

#ifndef CONVERT_H
#define CONVERT_H

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

#endif

De implementatie in convert.c neemt het bestand vóór de functieblokken op:

#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;
}

Een aanroepend bestand neemt hetzelfde headerbestand en <stdio.h> op. De aanroep printf("%.1f %.1f\n", c_to_f(25.0), f_to_c(212.0)); drukt 77.0 100.0 af.

Als de implementatie float c_to_f(float c) definieert, ziet de compiler de tegenstrijdige typen doordat het headerbestand is opgenomen. Bij onafhankelijke compilatie zonder die declaratie kan het verschil onopgemerkt blijven.

Kies de juiste inhoud

Een headerbestand met int count = 0; definieert een object in elke vertaaleenheid die het opneemt, wat dubbele externe definities veroorzaakt. Zelfs int count; is een voorlopige definitie. De standaardinstelling van GCC sinds versie 10 meldt herhaalde kopieën bij het koppelen, terwijl sommige toolchains gemeenschappelijke symbolen samenvoegen en de programmeerfout verbergen. Gebruik extern int count; in het headerbestand en één definitie in een bronbestand.

Zorg dat opnemen betrouwbaar werkt

Een beveiliging voorkomt herhaalde verwerking binnen een vertaaleenheid, ook bij indirecte opname via andere headerbestanden. Compatibele prototypes mogen worden herhaald, maar typedefinities zoals een enum kunnen fouten door herdefinitie veroorzaken.

Een zelfstandig bruikbaar headerbestand neemt op wat de eigen declaraties nodig hebben. Als een prototype size_t gebruikt, neem daar dan <stddef.h> op. Aanroepende bestanden zouden geen speciale opnamevolgorde nodig moeten hebben.

Bij projectheaderbestanden zoekt GCC met aanhalingstekens eerst in de map van het bestand dat het headerbestand opneemt. Voeg een aparte map voor headerbestanden toe met -Iinclude, zoals in gcc -Iinclude -std=c17 -c src/main.c. Het objectbestand van de implementatie moet nog steeds worden gekoppeld.

Koppeling bepaalt of declaraties op verschillende plaatsen naar dezelfde entiteit verwijzen. Dit staat los van het geldigheidsgebied, dat beschrijft waar je een naam kunt gebruiken, en de opslagduur, die beschrijft hoelang een object bestaat.

Verbind één naam met één object

Functies en gewone variabelen op bestandsniveau hebben standaard externe koppeling. static op bestandsniveau geeft interne koppeling. Gewone automatische lokale variabelen en parameters hebben geen koppeling.

Zet deze declaraties in een beveiligd headerbestand om één foutenteller te delen:

extern int error_count;
void log_error(int code);

Eén bronbestand neemt dat headerbestand op en levert:

int error_count = 0;

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

Dat bronbestand neemt ook <stdio.h> op voor printf. Andere bronbestanden nemen het gedeelde headerbestand op, geen tweede definitie. Na drie aanroepen verwijst elke aanroepende functie die error_count leest naar hetzelfde object en ziet 3.

Maak onderscheid tussen declaratie en definitie

extern int error_count; declareert een bestaand object en reserveert geen nieuwe opslag. int error_count = 0; definieert het object. Een initialisator verandert de situatie: op bestandsniveau is extern int error_count = 0; ondanks het sleutelwoord een definitie. Bewaar de initialisator in het ene bestand met de definitie.

Bij gewone openbare functiedeclaraties is extern optioneel: double c_to_f(double c); declareert al een functie met externe koppeling. Neem de openbare declaratie op in het bestand met de definitie, zodat de compiler de compatibiliteit kan controleren.

Verberg toestand achter functies

static int count = 0;

void counter_increment(void)
{
    count++;
}

int counter_value(void)
{
    return count;
}

De opgeslagen waarde bestaat gedurende de hele uitvoering, maar alleen deze vertaaleenheid kan er met de naam count naar verwijzen. Zet de openbare functieprototypes in een headerbestand. Een ander bestand kan de teller via die functies verhogen en lezen zonder de privévariabele rechtstreeks te wijzigen. Ook een hulpfunctie kan static zijn wanneer andere bestanden die niet nodig hebben.

Achterhaal een verkeerde keuze van koppeling

Een definitie static int count; in een headerbestand maakt een onafhankelijke privételler in elke vertaaleenheid die het opneemt. Als je de ene bijwerkt, worden de andere niet bijgewerkt. Beveiligingen tegen herhaalde inclusie voegen deze objecten niet samen: elke vertaaleenheid verwerkt een eigen kopie van het headerbestand.

Een functie die in één vertaaleenheid als static is gedefinieerd, kan niet voldoen aan een externe aanroep vanuit een andere; het koppelen mislukt voor die externe naam. Geef alleen functies die andere bestanden nodig hebben externe koppeling en declareer die in het headerbestand.

Binnen een functie geeft static een lokale variabele blijvende opslag zonder het geldigheidsgebied te vergroten. Buiten functies geeft het een object of functie interne koppeling. Variabelen op bestandsniveau hebben met of zonder dat sleutelwoord statische opslagduur.

make leest Makefile of makefile in de projectmap en werkt het gevraagde doel bij. Zonder doel als argument bouwt het normaal gesproken het eerste gewone doel.

Leg uitvoer en invoer vast

Een regel begint met target: prerequisites. Het recept staat op volgende regels die met een tab inspringen of na een puntkomma op dezelfde regel:

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 is temp het standaarddoel. make clean vraagt om de opruimactie. Als je een recept op de volgende regel schrijft, gebruik dan een echt tabteken: spaties kunnen “missing separator” veroorzaken. Een instelling van je editor om witruimte zichtbaar te maken helpt het verschil te zien.

Volg de beslissingen om opnieuw te bouwen

Make werkt eerst de afhankelijkheden van een doel bij. Daarna bouwt het het doel opnieuw als dat ontbreekt of als een afhankelijkheid een recentere wijzigingstijd heeft.

• Eerste bouw: compileer beide bronbestanden en koppel daarna temp, drie opdrachten.
• Geen wijzigingen: er hoeven geen recepten voor het programma te worden uitgevoerd.
• Wijzig alleen convert.c: compileer het opnieuw en koppel opnieuw, twee opdrachten; hergebruik main.o.
• Wijzig convert.h: compileer beide bronbestanden opnieuw en koppel opnieuw, drie opdrachten.

Het headerbestand beïnvloedt beide vertaaleenheden, ook al is geen van beide bronbestanden gewijzigd. Stel je voor dat invoerbestanden objectbestanden opleveren en objectbestanden vervolgens het uitvoerbare bestand. Wijzigingen werken door via die vastgelegde relaties.

Neem afhankelijkheden van headerbestanden op

De onvolledige regel main.o: main.c mist wijzigingen in convert.h. Make leest geen C-broncode om opgenomen bestanden te ontdekken; het volgt de gedeclareerde afhankelijkheden. Vermeld opgenomen headerbestanden of laad door de compiler gegenereerde afhankelijkhedenbestanden om te voorkomen dat je verouderde objectbestanden koppelt.

Houd afhankelijke shellbewerkingen bij elkaar

Afzonderlijke receptregels gebruiken normaal gesproken afzonderlijke shells. Een regel met alleen cd build verandert de map niet voor de volgende regel. Gebruik één opdracht zoals cd build && gcc -c ../main.c wanneer het compileren afhangt van die mapwijziging. Bekijk geplande recepten vooraf met make -n.

Variabelen en patroonregels verwijderen herhaalde compileropdrachten terwijl de afhankelijkheidsgraaf behouden blijft. De voorbeelden plaatsen elk recept na een puntkomma op dezelfde regel als het doel en de afhankelijkheden. Verkort een makefile pas nadat de bouwrelaties correct zijn.

Geef gedeelde instellingen een naam

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) wordt vervangen door de waarde van de compilervariabele; $(CFLAGS) door de bijbehorende opties. CPPFLAGS bevat volgens afspraak preprocessoropties zoals -DDEBUG of -Iinclude. De opties -Wall -Wextra schakelen waarschuwingen in, -g voegt debuginformatie toe en -O2 schakelt optimalisatie in. Niet-gedefinieerde make-variabelen worden vervangen door lege tekst. Schrijf $(CC), niet $CC: het laatste betekent de eenletterige variabele C, gevolgd door een letterlijke C.

Lees automatische variabelen binnen een regel

Voor main.o is de stam van het patroon main, zodat %.c verandert in main.c. Het compilatierecept gebruikt $< om dat bronbestand aan de compiler door te geven en $@ om main.o te benoemen. Het headerbestand is een afhankelijkheid, maar wordt niet als extra invoer voor compilatie doorgegeven.

In de koppelregel zijn alle afhankelijkheden objectbestanden. $^ wordt uitgebreid tot main.o convert.o en $@ wordt temp. Als je daar $< zou gebruiken, zou alleen main.o worden doorgegeven en zouden de definities in convert.o ontbreken.

GNU make heeft ingebouwde regels die x.c naar x.o kunnen compileren met CC, CPPFLAGS en CFLAGS. Een expliciete afhankelijkheidsregel zonder recept kan dat ingebouwde recept gebruiken. GNU make kan zelfs met make hello een eenvoudig programma uit hello.c bouwen zonder makefile.

Markeer actiedoelen als schijndoelen

clean benoemt een actie, geen bestand dat moet worden gemaakt. .PHONY: clean zorgt ervoor dat de actie wordt uitgevoerd, ook als er een bestand met de naam clean bestaat. rm -f accepteert dat bestanden al ontbreken. Een all-doel dat verschillende programma’s groepeert, is meestal ook een schijndoel.

Genereer headerlijsten en bekijk wat opnieuw wordt gebouwd

Voeg -MMD -MP toe aan de compilatieopties om naast elk objectbestand een .d-bestand te schrijven. -MMD legt afhankelijkheden van gebruikersheaderbestanden vast; -MP voegt lege regels toe die helpen wanneer een vastgelegd headerbestand wordt verwijderd. Laad de lijsten na het gewone standaarddoel met:

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

De vervanging zet namen van objectbestanden om in namen van afhankelijkhedenbestanden. Het minteken vooraan staat ontbrekende .d-bestanden bij de eerste bouw toe. Verwijder deze gegenereerde bestanden samen met de objectbestanden in clean.

make -n toont opdrachten vooraf, make -B dwingt opnieuw bouwen af en make -j4 staat maximaal vier recepten tegelijk toe. Correcte afhankelijkheden zijn ook belangrijk bij parallel bouwen. Alleen de tekst van CFLAGS wijzigen maakt bestaande objectbestanden niet ouder dan een afhankelijkheid. Gebruik na het wijzigen van opties make -B of bouw opnieuw na het opschonen, zodat elk objectbestand de nieuwe instellingen gebruikt.