Arrays en strings in C

Een array geeft één naam aan een vast aantal waarden van hetzelfde type. De elementen staan naast elkaar in het geheugen. Gebruik een array wanneer dezelfde bewerking op veel waarden van toepassing is, zoals bij het bijwerken van een verzameling scores.

Maak de elementen

int scores[5] = {90, 72, 85, 64, 99};
int primes[] = {2, 3, 5, 7};
int counts[6] = {0};

De eerste declaratie maakt vijf gehele getallen. De compiler telt vier waarden in de tweede initialisator, dus primes heeft vier elementen. In de derde is het eerste element expliciet nul en wordt ook elke ontbrekende initialisatiewaarde nul. Zo bevat int a[5] = {1, 2}; de waarden 1, 2, 0, 0, 0. Een benoemde initialisator, beschikbaar sinds C99, kiest een positie: int b[5] = {[2] = 7}; zet 7 in het derde element en nul in de andere.

Een automatische lokale declaratie zoals int data[5]; reserveert ruimte zonder beginwaarden te geven. Schrijf elk element voordat je het leest. Arrays die buiten alle functies zijn gedeclareerd en arrays die met static zijn gedeclareerd, worden op nul geïnitialiseerd als er geen expliciete initialisator is opgegeven.

Benader één waarde via de index

Indexen beginnen bij nul. Voor vijf elementen zijn de geldige posities 0 tot en met 4. scores[1] betekent de tweede score, niet de eerste. Je kunt een element overal gebruiken waar een gewone variabele van hetzelfde type kan worden gebruikt:

scores[1] = 75;
scores[1] += 5;
int last = scores[4];

De tweede score is nu 80. De laatste is nog steeds 99. Een index kan een variabele of een expressie zijn, dus scores[n - 1] benadert het laatste element als n het aantal elementen is en positief is. Bij scores[5] is er geen element om te benaderen.

Tel elementen en bytes

sizeof scores meet de hele array in bytes. Op een systeem met gehele getallen van 4 bytes nemen de vijf elementen 20 bytes in. Door te delen door de grootte van één element maak je de uitkomst onafhankelijk van de grootte van een geheel getal:

size_t n = sizeof scores / sizeof scores[0];
printf("%zu\n", n);

Dit drukt 5 af. size_t is het geheelgetaltype zonder teken dat voor groottes wordt gebruikt; %zu drukt het af. Deze berekening werkt waar scores de eigenlijke array aanduidt. Een functieparameter bevat niet de volledige grootte van de array.

Houd grootte en waarden gescheiden

Met een naam zoals #define NUM_SCORES 5 kunnen de declaratie en de bijbehorende lussen één grootte delen. In C17 maakt een lokale const int n = 5; int a[n]; daarentegen een array met variabele lengte: const maakt van n geen geheeltallige constante expressie. De grootte wordt gekozen wanneer de declaratie wordt uitgevoerd en blijft daarna vast gedurende de levensduur van de array. Een initialisatielijst is niet mogelijk. Ondersteuning voor arrays met variabele lengte is optioneel in C11 en C17; C23 voegt constexpr toe voor constanten tijdens compilatie.

Arrays kunnen niet als geheel worden toegewezen: b = a; is ongeldig. Kopieer hun elementen met een lus of een geschikte geheugenfunctie. Voor twee afzonderlijke arrays vergelijkt a == b adressen, geen elementwaarden. Vergelijk overeenkomstige elementen om te testen of de waarden gelijk zijn. Een bytevergelijking met memcmp test daarentegen hun opgeslagen representaties; gelijke drijvendekommawaarden zoals positieve en negatieve nul kunnen verschillende representaties hebben.

Een tellende lus verbindt de posities van een array met een bewerking. Bepaal welke elementen bruikbare gegevens bevatten en bezoek dan precies die posities. Hetzelfde patroon ondersteunt totalen, zoekopdrachten en wijzigingen.

Bezoek de gebruikte elementen

int t[5] = {12, 15, 9, 14, 10};
int sum = 0;
for (int i = 0; i < 5; i++) {
    sum += t[i];
}
double average = sum / 5.0;

De lus gebruikt de indexen 0, 1, 2, 3 en 4. Het totaal loopt op via 12, 27, 36, 50 en 60, dus het gemiddelde is 12,0. Als je i <= 5 schrijft, voeg je een ongeldige toegang bij index 5 toe. Die extra iteratie is een één-ernaastfout.

Gebruik voor een gemiddelde een drijvendekommagetal bij de deling. Bij een totaal van 61 geeft 61 / 5 het gehele getal 12; 61 / 5.0 geeft 12,2. Als je het eerste resultaat daarna in een double opslaat, kun je het al weggelaten deel achter de komma niet terugkrijgen.

Zoek een maximum of een overeenkomst

Initialiseer bij een niet-lege array het maximum met de eerste waarde:

int max = t[0];
for (int i = 1; i < 5; i++) {
    if (t[i] > max) max = t[i];
}

De eerste vergelijking vervangt 12 door 15. De overige waarden zijn kleiner, dus 15 blijft staan. Beginnen met nul zou misgaan bij een lijst zoals {-8, -3, -11}: nul is groter dan elke opgeslagen waarde, maar staat niet in de lijst.

Bij lineair zoeken controleer je de waarden op volgorde:

int found = -1;
for (int i = 0; i < 5; i++) {
    if (t[i] == 14) {
        found = i;
        break;
    }
}

Hier wordt found gelijk aan 3. De waarde -1 geeft aan dat er geen overeenkomst is, omdat die geen geldige index kan zijn. Meld pas dat er niets is gevonden nadat alle kandidaten zijn gecontroleerd. Als je na het eerste ongelijke element -1 teruggeeft, mis je overeenkomsten verderop in de array.

Tel en herschik

Een frequentiearray slaat per categorie één teller op. Voor cijfers biedt int counts[10] = {0}; de tellers 0 tot en met 9. Nadat je d >= 0 && d < 10 hebt gecontroleerd, verhoogt counts[d]++ de teller voor cijfer d. De controle beschermt de array wanneer de cijferwaarde uit invoer komt.

Om een array om te keren, wissel je paren vanaf de uiteinden:

for (int i = 0; i < 5 / 2; i++) {
    int temp = t[i];
    t[i] = t[5 - 1 - i];
    t[5 - 1 - i] = temp;
}

De eerste wissel verwisselt 12 en 10. De tweede verwisselt 15 en 14. De middelste 9 blijft staan, met {10, 14, 9, 15, 12} als resultaat. Stop halverwege: als je alle vijf posities doorloopt, wissel je elk paar twee keer.

Houd het aantal gebruikte elementen apart van de capaciteit bij

Een array met ruimte voor 100 waarden kan op dit moment slechts 37 bruikbare elementen bevatten. De capaciteit is 100; het aantal gebruikte elementen is 37. Verwerk de posities onder count. Om één waarde toe te voegen, controleer je eerst count < CAPACITY, sla je de waarde op in a[count] en verhoog je daarna count. Als je tot de capaciteit doorloopt, kun je posities lezen die nooit bruikbare waarden hebben gekregen, ook al liggen die posities fysiek binnen de array.

Een functie kan een array verwerken zonder van elk element een afzonderlijke kopie te ontvangen. Via de aanroep heeft de functie toegang tot de opslag van de aanroepende functie. Geef het aantal elementen mee, zodat de functie weet waar ze moet stoppen.

Geef de gegevens en hun lengte mee

#include <stddef.h>

double average(const int a[], size_t n) {
    if (n == 0) return 0.0;
    int sum = 0;
    for (size_t i = 0; i < n; i++) {
        sum += a[i];
    }
    return (double) sum / n;
}

De aanroepende functie kan int values[] = {7, 8, 10}; declareren en average(values, sizeof values / sizeof values[0]) aanroepen. De drie optellingen leveren 25 op; door sum vóór de deling naar double te converteren, krijg je ongeveer 8,33. Bij geen waarden 0,0 teruggeven is de gekozen werkwijze van deze functie voor lege invoer. De kleine waarden in dit voorbeeld houden de geheeltallige som binnen het waardenbereik.

In een parameterdeclaratie wordt int a[] omgezet naar int *a. Die parameter ontvangt het adres van het eerste element. Zelfs int a[10] controleert of vereist geen tien elementen. De aanroepende functie moet een lengte opgeven die overeenkomt met de beschikbare gegevens.

Waarom sizeof de lengte niet meer kent

Op de plaats van de aanroep meet sizeof values de array. Binnen de functie meet sizeof a de pointerparameter. Waar pointers 8 bytes en gehele getallen 4 bytes innemen, geeft deling van deze groottes 2, ongeacht het aantal elementen van de aanroepende functie. Dat resultaat beschrijft geen kopie van twee elementen en ook niet de oorspronkelijke array. Houd de lengte bij als expliciete parameter.

size_t, gedeclareerd door onder meer <stddef.h>, is het type zonder teken dat sizeof oplevert. Het kan objectgroottes voorstellen en %zu drukt het af. Door dit type voor de lusindex te gebruiken, voorkom je dat een index met teken wordt vergeleken met een lengte zonder teken.

Bepaal of elementen mogen veranderen

De const in const int a[] voorkomt toewijzingen aan elementen via deze parameter. Dit past bij een functie die een resultaat uit de gegevens berekent. Een functie die elementen moet bijwerken, laat die kwalificatie weg:

void zero(int a[], size_t n) {
    for (size_t i = 0; i < n; i++) {
        a[i] = 0;
    }
}

Na zero(values, 3) bevatten de drie elementen van de aanroepende functie allemaal nul. De array heeft nog steeds drie elementen. Een scalaire parameter zoals n is een afzonderlijke kopie; als je die kopie wijzigt, verandert een tellervariabele van de aanroepende functie niet.

Laat de aanroepende functie een uitvoerarray en de lengte ervan beschikbaar stellen om meerdere resultaten te produceren. Een functie kan elk resultaat in out[i] plaatsen. C-functies kunnen geen array op waarde teruggeven en het adres van een lokale array teruggeven werkt niet, omdat die array ophoudt te bestaan wanneer de functie terugkeert.

Tel terug met een index zonder teken

Een index zonder teken kan niet negatief worden. In for (size_t i = n - 1; i >= 0; i--) is de test altijd waar; na nul loopt de waarde modulair terug naar een groot positief getal. Bij n == 0 loopt zelfs de eerste aftrekking modulair terug. Begin in plaats daarvan bij het aantal:

for (size_t i = n; i > 0; i--) {
    printf("%d\n", a[i - 1]);
}

Bij drie elementen worden de indexen 2, 1 en 0 benaderd. Bij nul elementen wordt de lusinhoud nooit uitgevoerd. Neem <stdio.h> op voor printf.

Een C-teken wordt opgeslagen als een numerieke code. Daardoor kan een programma een symbool afdrukken, het met een ander symbool vergelijken of met de code rekenen. De tekenset bepaalt welk getal elk symbool voorstelt.

Lees de code en het teken

Een char neemt één byte in: sizeof(char) is per definitie 1. Een tekenconstante zoals 'A' heeft het type int. In de hier gebruikte, op ASCII gebaseerde tekenset is de code 65:

printf("%c %d\n", 'A', 'A');

De uitvoer is “A 65”. %c toont het teken; %d toont het getal. ASCII kent de codes 0 tot en met 127 toe. Cijfers lopen van 48 tot en met 57, hoofdletters van 65 tot en met 90, kleine letters van 97 tot en met 122 en de spatie heeft code 32.

Enkele en dubbele aanhalingstekens maken verschillende dingen. 'A' is één tekencode. "A" is een array met 'A' en een afsluitende nulbyte. Sla één teken op met char c = 'A'; en vergelijk het met c == 'A'.

Schrijf tekens waarvoor een escapesequentie nodig is

Het nulteken verschilt van het zichtbare cijfer '0', dat ASCII-code 48 heeft. Een string gebruikt het nulteken om het einde aan te geven.

Zet codes om in bruikbare waarden

De C-standaard garandeert opeenvolgende cijfercodes. Nadat je hebt gecontroleerd of c een cijfer is, levert c - '0' de waarde ervan op. Zo is '7' - '0' gelijk aan 7, niet aan 55. Door de begincode af te trekken, haal je de positie van het cijfer binnen de tekenset weg.

ASCII-letters zijn ook opeenvolgend, dus door 'A' af te trekken zet je een hoofdletter om in een positie van 0 tot en met 25. Voor een Caesarverschuiving met drie gebruik je:

char shifted = (c - 'A' + 3) % 26 + 'A';

Voor 'X' geeft 65 aftrekken 23; drie optellen geeft 26; de rest na deling door 26 is nul; 65 optellen levert weer 'A' op. Alleen 'X' + 3 geeft code 91, oftewel '['. Rekenen met letters is afhankelijk van de lettervolgorde zoals in ASCII; C garandeert opeenvolgende cijfers, maar vereist geen opeenvolgende letters.

Classificeer en converteer met ctype.h

Neem <ctype.h> op voor isdigit, isalpha, isalnum, isspace, isupper, islower, toupper en tolower. De tests geven bij een overeenkomst een waarde anders dan nul terug en anders nul. toupper('q') geeft 'Q' terug; toupper('3') laat het cijfer ongewijzigd. isspace herkent scheidingstekens zoals spatie, tab en nieuweregelteken.

Een gewone char kan een type met teken zijn. Een byte boven 127 kan dan een negatieve waarde worden, die geen geldig argument is voor deze functies, tenzij het de speciale invoermarkering EOF is. Converteer eerst wanneer je bytes uit een string verwerkt:

if (isalpha((unsigned char) c)) {
    c = (char) toupper((unsigned char) c);
}

In de standaardlocale “C” herkennen deze functies de basisletters, geen volledige UTF-8-tekens die uit meerdere bytes bestaan. De expliciete typeconversie maakt de byte tot een geldig argument; ze decodeert geen UTF-8.

Een C-string is een reeks tekens die eindigt op '\0'. Het afsluitende nulteken maakt deel uit van de opslag, maar niet van de tekstlengte. C heeft geen afzonderlijk ingebouwd stringtype: de tekens staan in een array.

Bekijk de bytes in de array

char word[] = "cat";
char name[20] = "Ada";

word bevat vier bytes: 'c', 'a', 't', '\0'. De arraygrootte is 4 en strlen(word) is 3. Neem <string.h> op voor strlen. De grotere array name bevat de drie letters, hun afsluitende nulteken en nog zestien nulbytes. De capaciteit is 20 en de huidige lengte is 3.

Een initialisator die de tekens één voor één opgeeft, kan dezelfde string maken:

char word[] = {'c', 'a', 't', '\0'};

Als je het laatste element weglaat, maak je drie tekens zonder afsluitend nulteken. C staat ook char word[3] = "cat"; toe. Daarmee vul je alle drie de posities en laat je de nulbyte weg. Zo’n array is geen C-string. Een functie zoals strlen of printf met %s blijft lezen tot ze een nulbyte tegenkomt en kan die array van drie bytes dus niet veilig als tekst verwerken.

Kies een wijzigbare array of een literal

a[0] = 'H'; verandert de kopie in “Hello”. Een literal mag niet worden gewijzigd. Zelfs als je die aan een gewone char * toewijst, is schrijven via die pointer ongedefinieerd gedrag. Met const char * maak je die beperking zichtbaar voor de compiler.

De compiler voegt stringliterals die naast elkaar staan samen: "Hello, " "world" geeft dezelfde tekst als "Hello, world". De resulterende string heeft nog steeds één afsluitend nulteken. Dit is handig om een lange literal over broncoderegels te verdelen.

Druk de tekst af en wijzig die

printf("%s\n", word);
printf("%c\n", word[0]);

De eerste aanroep drukt de hele string af. De tweede drukt het eerste teken af. Een stringliteral in printf staat tussen dubbele aanhalingstekens omdat het tekst is die een formaat bevat; %c ontvangt één tekencode.

Een toewijzing aan een element wijzigt één opgeslagen teken. Bij char name[20] = "Ada"; levert name[0] = 'E'; de string “Eda” op. Als je daarna name[1] = '\0'; instelt, ontstaat de string “E”. De bytes voor 'a' en het oude afsluitende nulteken bestaan later in de array nog steeds, maar stringbewerkingen stoppen bij de eerste nul.

Na de declaratie kan een array geen vervangende tekst ontvangen met name = "Bob";. Kopieer de tekens erin met een gecontroleerde aanroep van strcpy of met een lus, inclusief het afsluitende nulteken. De lengte van de vervangende tekst moet kleiner zijn dan de capaciteit.

Stel afwezigheid van tekst voor

De lege string "" neemt nog steeds één byte in voor '\0'. De lengte is nul en je kunt dit testen met name[0] == '\0'. Een lege string is een echte string met een afsluitend nulteken; een nulpointer verwijst daarentegen naar geen enkele stringopslag.

Het afsluitende nulteken van een string geeft een lus haar stoppunt. Bezoek de bytes ervoor om tekst te tellen, converteren of filteren. Bij het maken van een nieuwe string moet het programma zelf een nieuw afsluitend nulteken schrijven.

Doorloop de string één keer tot het einde

for (size_t i = 0; s[i] != '\0'; i++) {
    /* Process s[i]. */
}

Bij elke iteratie test de lus of de huidige byte bij de tekst hoort. Ze stopt vóór het afsluitende nulteken. Als je strlen(s) in die test aanroept, kan de hele string bij elke iteratie opnieuw worden doorlopen. Test de huidige byte rechtstreeks of bereken één keer size_t len = strlen(s); als de lengte gelijk blijft.

Gebruik voor omzetting naar hoofdletters een wijzigbare array en <ctype.h>:

for (size_t i = 0; s[i] != '\0'; i++) {
    s[i] = (char) toupper((unsigned char) s[i]);
}

“Hello, World 42” wordt “HELLO, WORLD 42”. De conversie behoudt de komma, spaties en cijfers. De conversie naar een type zonder teken maakt elke opgeslagen byte tot een geldig argument voor ctype.

Tel categorieën en woordbeginnen

Het oorspronkelijke “Hello, World 42” heeft 15 tekstbytes: 10 letters, twee cijfers, twee spaties en één komma. Afzonderlijke tellers kunnen isalpha, isdigit en isspace gebruiken. Bepaal voordat je gaat tellen wat een woord betekent. Voor een reeks letters begint een nieuw woord wanneer een letter op een niet-letter volgt of het eerste teken is:

int in_word = 0;
size_t words = 0;
for (size_t i = 0; s[i] != '\0'; i++) {
    int letter = isalpha((unsigned char) s[i]) != 0;
    if (letter && !in_word) words++;
    in_word = letter;
}

Het voorbeeld heeft twee letterreeksen, “Hello” en “World”. De cijfers vormen volgens deze definitie geen woord. Door in_word bij elke iteratie bij te werken, kan een leesteken een reeks beëindigen.

Keer alleen de tekst om

Bepaal voor een string met tekens van één byte eerst één keer len en wissel dan s[i] met s[len - 1 - i] zolang i < len / 2. Bij het omkeren van “stressed” wissel je de eerste en laatste letter, dan het volgende paar, tot “desserts” ontstaat. De nulbyte blijft op index len staan. Als je een wissel bij s[len] begint, verplaats je die nul naar voren. Bytes op deze manier omkeren is geschikt voor ASCII-tekst; tekens van meerdere bytes moeten vóór het herschikken worden gedecodeerd.

Bouw een gefilterd resultaat op

Gebruik verschillende indexen voor lezen en schrijven, omdat sommige invoerbytes worden overgeslagen:

char in[] = "a1b2c3";
char out[sizeof in];
size_t j = 0;
for (size_t i = 0; in[i] != '\0'; i++) {
    if (isalpha((unsigned char) in[i])) {
        out[j++] = in[i];
    }
}
out[j] = '\0';

Het resultaat is “abc”. De doelarray heeft genoeg ruimte omdat filteren deze invoer niet langer kan maken. Zonder out[j] = '\0'; heeft de uitvoer geen vastgelegd stringeinde.

Verschuif voor een Caesarversleuteling hoofdletters ten opzichte van 'A' en kleine letters ten opzichte van 'a' en kopieer andere bytes ongewijzigd. Met sleutel 13 wordt “Hello, World!” omgezet in “Uryyb, Jbeyq!”. Als je die verschuiving herhaalt, krijg je het origineel terug omdat twee verschuivingen samen 26 zijn. Een vergelijking zoals s[i] == 'a' test één teken; gebruik strcmp om volledige tekst te vergelijken.

Tekstlengte kan een aantal bytes of een aantal Unicode-codepunten betekenen. Die aantallen verschillen vaak. Een C-char-array geeft toegang tot afzonderlijke bytes, dus de indexen en stringfuncties volgen niet automatisch volledige niet-ASCII-tekens.

Onderscheid tekens, codepunten en bytes

Een tekencodering beschrijft hoe tekst wordt opgeslagen. ASCII gebruikt de codes 0 tot en met 127 voor basisletters, cijfers, leestekens en besturingstekens. Unicode kent codepunten toe aan tekens uit veel schriftsystemen: “é” heeft codepunt U+00E9 en “€” heeft U+20AC. UTF-8 codeert scalaire Unicode-waarden met één tot vier bytes.

ASCII-codepunten behouden hun codering van één byte. De vooraf samengestelde “é” gebruikt twee bytes, 0xC3 en 0xA9; “€” gebruikt er drie. Veel afzonderlijke emoji-codepunten gebruiken vier bytes. Een weergegeven symbool kan meerdere codepunten bevatten, dus ook een aantal codepunten is niet altijd een aantal zichtbare symbolen.

Meet een UTF-8-string

char s[] = "café";
printf("%zu %zu\n", strlen(s), sizeof s);

Bij UTF-8-uitvoeringstekst drukt dit “5 6” af. De eerste drie letters gebruiken drie bytes en “é” gebruikt er twee, samen vijf tekstbytes. Het afsluitende nulteken voegt de zesde opslagbyte toe. s[3] is de eerste byte van “é”, niet de hele letter.

Als je na vier bytes afkapt, blijft 0xC3 staan maar verdwijnt de vervolgbyte 0xA9. Het resultaat zou geen geldige UTF-8 meer zijn. Een buffergrens in bytes vereist daarom een controle op tekengrenzen als het programma UTF-8-tekst afkapt.

Tel beginbytes in geldige UTF-8

Een vervolgbyte begint met de bits 10. De waarde ligt tussen 0x80 en 0xBF. Een beginbyte of ASCII-byte heeft dat patroon niet:

size_t points = 0;
for (size_t i = 0; s[i] != '\0'; i++) {
    unsigned char c = (unsigned char) s[i];
    if ((c & 0xC0) != 0x80) points++;
}

Het masker 0xC0 behoudt alleen de twee hoogste bits; 0x80 stelt het patroon 10 op die posities voor. De test telt “café” als vier codepunten door de vier beginbytes te tellen. De test gaat uit van geldige UTF-8, valideert geen ongeldige reeksen en voegt geen codepunten samen tot zichtbare symbolen.

Kies bewerkingen die de codering behouden

Het kopiëren van een volledige UTF-8-string behoudt de bytes. Ook volledige strings samenvoegen, hun bytereeksen op gelijkheid vergelijken en zoeken naar een ASCII-teken of een volledige UTF-8-deelstring werken. UTF-8-vervolgbytes kunnen niet worden verward met ASCII-tekens of beginbytes.

strcmp ordent bytewaarden zonder teken, dus die volgorde verschilt van een taalspecifieke alfabetische volgorde. In UTF-8 hebben gewone Latijnse letters met accenten beginbytes boven ASCII 'z'. Een bytevergelijking plaatst die letters daarom na 'z', ongeacht woordenboekconventies.

In de standaardlocale “C” verwerken toupper en isalpha één byte en decoderen ze “é” niet als letter. Een expliciete typeconversie naar unsigned char maakt de aanroep geldig, maar maakt er geen Unicode-conversie tussen hoofdletters en kleine letters van. Daarvoor zijn functies voor brede tekens of een Unicode-bibliotheek nodig. Een Caesar-lus die alleen ASCII verwerkt, kan letters met accenten behouden door alleen bytes van A–Z of a–z te wijzigen.

De nulbyte is de UTF-8-codering van U+0000; andere gecodeerde codepunten bevatten geen nulbyte. Dat past bij de C-conventie voor afsluitende nultekens. UTF-16 kan nulbytes binnen gewone gecodeerde tekst plaatsen, dus een UTF-16-bytearray kan niet als een gewone char-string worden verwerkt.

De functies in <string.h> werken met tekst die eindigt op een nulteken. Ze kunnen de lengte bepalen, de tekst kopiëren of meer tekst toevoegen, maar kopieerfuncties achterhalen de capaciteit van de doelarray niet. Bepaal de benodigde opslagruimte voordat je schrijft.

Meet de lengte zonder het afsluitende nulteken

strlen(s) geeft een size_t terug met het aantal bytes vóór de eerste nulbyte. Zo is strlen("hello") gelijk aan 5 en strlen("") gelijk aan nul. Druk het resultaat af met %zu.

char buf[64] = "hi";
printf("%zu %zu\n", strlen(buf), sizeof buf);

Dit drukt “2 64” af. Het eerste resultaat meet de huidige tekst; het tweede meet de beschikbare opslagruimte in de array. Een latere kopieerbewerking kan het eerste veranderen zonder het tweede te veranderen. Beide aanroepen zijn hier nuttig omdat buf een echte array is en al een geldige string bevat.

Kopieer een volledige string

strcpy(dest, src) kopieert tekst en de afsluitende nulbyte. De benodigde capaciteit is de lengte van de bron plus één:

char dest[12];
const char *src = "Maple";
if (strlen(src) < sizeof dest) {
    strcpy(dest, src);
}

“Maple” gebruikt vijf tekstbytes en één afsluitend nulteken, dus past de tekst. De strikte < is belangrijk: als de lengte van de bron gelijk is aan de capaciteit, blijft er geen positie over voor de nulbyte. Als de controle mislukt, moet het programma de fout afhandelen voordat het de doelarray als nieuwe string gebruikt.

Een arraytoewijzing zoals dest = src; kan de inhoud niet vervangen. De ene char *-variabele aan de andere toewijzen is toegestaan, maar kopieert alleen een verwijzing naar dezelfde opslag. Er ontstaat geen extra kopie van de tekens.

Voeg tekst toe aan een bestaande string

strcat(dest, src) zoekt eerst het afsluitende nulteken dat al in dest staat. De functie vervangt dat nulteken door de eerste byte van de bron en schrijft een nieuw afsluitend nulteken na de toegevoegde tekst. De capaciteit van de doelarray moet voldoende zijn voor beide huidige lengtes plus één.

char full[16];
strcpy(full, "Ada");
strcat(full, " ");
strcat(full, "Lovelace");

De lengte groeit van 3 naar 4 naar 12. Het uiteindelijke “Ada Lovelace” heeft 13 bytes opslagruimte nodig, waardoor drie bytes ongebruikt blijven. Een doelarray van 12 bytes zou één byte te klein zijn, hoewel de zichtbare tekst even lang is.

Voeg nooit tekst toe aan een niet-geïnitialiseerde lokale buffer. Bij char out[20]; strcat(out, "hi"); heeft strcat geen vastgelegd teksteinde om te vinden. Begin met char out[20] = "";, schrijf out[0] = '\0'; of maak van de eerste bewerking een gecontroleerde kopieerbewerking.

Houd rekening met opslag en doorzoektijd

Bron en doel mogen bij strcpy of strcat niet overlappen. Als je tekst binnen dezelfde buffer verplaatst, kan overlap ontstaan, ook als beide locaties afzonderlijk geldig zijn. memmove is de functie die bedoeld is voor overlappende bytegebieden.

strlen moet tot het afsluitende nulteken doorzoeken. strcat moet de huidige doelstring doorzoeken voordat de functie tekst toevoegt. Herhaald toevoegen in een lus doorzoekt dus opnieuw tekst die al is opgebouwd. Als je veel stukken samenvoegt, houd dan de huidige uitvoerlengte bij en schrijf elk stuk op die index. Controleer daarbij de resterende capaciteit en zorg dat het afsluitende nulteken aanwezig blijft. Een bekende lengte is alleen bruikbaar zolang die nog overeenkomt met de werkelijke inhoud.

Stringvergelijking beantwoordt vragen over tekst, terwijl zoeken in een string een plaats binnen die tekst vindt. Geen van beide taken voer je uit door arraynamen met == te vergelijken. Gebruik het bibliotheekresultaat volgens wat het voorstelt: het teken van een vergelijkingsresultaat, een lengte of een locatie van een overeenkomst.

Vergelijk tekst en beginstukken

strcmp(a, b) vergelijkt overeenkomstige bytes als unsigned char-waarden tot er een verschil is of het einde van een string wordt bereikt. Het resultaat is nul bij gelijke tekst, negatief als a eerder komt en positief als die later komt. Alleen het teken is vastgelegd; verwacht niet precies -1 of 1.

if (strcmp(command, "quit") == 0) {
    puts("Goodbye");
}

De expliciete test op nul betekent dat de tekst gelijk is. Een gewone if (strcmp(command, "quit")) voert het blok uit bij ongelijke tekst, omdat een waarde anders dan nul waar is. De vergelijking command == "quit" zou opslaglocaties vergelijken.

In ASCII-volgorde komt “apple” bij de eerste letter vóór “banana”. “Zebra” komt vóór “apple” omdat hoofdletter 'Z' code 90 heeft en kleine letter 'a' code 97. “app” komt vóór “apple” omdat de nulbyte van de eerste string wordt bereikt vóór de 'l' van de andere. Dit is ordening op bytes, geen woordenboekvergelijking.

strncmp(a, b, n) vergelijkt hoogstens n bytes. strncmp(s, "--", 2) == 0 herkent twee streepjes aan het begin, maar betekent niet dat de hele string alleen “--” is. Standaard-C heeft geen functie om hele strings te vergelijken zonder onderscheid tussen hoofdletters en kleine letters. Een programma kan zelf geconverteerde bytes vergelijken; POSIX biedt strcasecmp in <strings.h>.

Zoek een locatie

Gebruik strchr voor de eerste keer dat één teken voorkomt, strrchr voor de laatste keer en strstr voor de eerste volledige deelstring. Ze geven een pointer naar de locatie van de overeenkomst terug, of NULL als er geen overeenkomst is.

char name[] = "report.final.txt";
char *extension = strrchr(name, '.');
if (extension != NULL) {
    printf("%s\n", extension);
}

Dit drukt “.txt” af, inclusief de gevonden punt. Als je met strchr bij de eerste punt zou beginnen, zou “.final.txt” worden afgedrukt. strstr(name, "final") vindt het achterste deel dat begint met “final.txt”; zoeken naar “draft” geeft NULL. Controleer op NULL voordat je een zoekresultaat afdrukt of leest.

Zoek een scheidingsteken of splits tekst

strcspn(s, set) telt de bytes aan het begin die bij geen van de tekens in set horen. Bij "oak:pine,birch" en de verzameling ":," stopt de functie bij de dubbele punt. Voor een geldige invoerstring verwijdert dit patroon het eerste nieuweregelteken:

buf[strcspn(buf, "\n")] = '\0';

Als er geen nieuweregelteken is, is de teruggegeven index de stringlengte en overschrijft de toewijzing dus het afsluitende nulteken dat daar al staat.

strtok splitst een wijzigbare string met elk teken uit een verzameling scheidingstekens:

char colors[] = "red, green,blue";
char *token = strtok(colors, " ,");
while (token != NULL) {
    puts(token);
    token = strtok(NULL, " ,");
}

De tokens zijn “red”, “green” en “blue”. De eerste aanroep geeft de array door; latere aanroepen geven NULL door om verder te gaan. De functie schrijft nulbytes in de invoer en bewaart een verborgen toestand tussen aanroepen. Gebruik beschrijfbare opslag en verwacht niet dat de oorspronkelijke string met scheidingstekens intact blijft. Opeenvolgende scheidingstekens leveren geen lege tokens op.

Een lengtegrens is alleen nuttig als die de juiste grootheid beschrijft. Sommige functies begrenzen bronbytes, andere de capaciteit van de doelarray, en geheugenfuncties verwerken ruwe bytes zonder stringeinden. Lees het contract van elke functie voordat je de grens kiest.

Weet wat n betekent

strncpy(dest, src, n) schrijft precies n posities als de bron korter is en vult aan met nulbytes. Als de bron minstens n bytes tekst heeft, kopieert de functie die bytes zonder afsluitend nulteken. Voor een array met een positieve capaciteit maak je zo een afgekorte kopie met afsluitend nulteken:

strncpy(dest, src, sizeof dest - 1);
dest[sizeof dest - 1] = '\0';

De laatste toewijzing is essentieel wanneer de bron de grens vult. Een naam of opdracht afkappen kan nog steeds de betekenis veranderen, dus wijs te lange invoer af als een volledige kopie vereist is.

strncat(dest, src, n) voegt hoogstens n tekstbytes toe en daarna een afsluitend nulteken. De functie ontvangt niet de totale capaciteit. Voor een geldige string die al in een doelarray staat, is de resterende ruimte voor tekst sizeof dest - strlen(dest) - 1. Als je sizeof dest als n doorgeeft, kan de doelarray overlopen.

Maak tekst op en detecteer afkapping

snprintf, gedeclareerd in <stdio.h>, ontvangt de totale capaciteit van de doelarray. Bij een capaciteit groter dan nul schrijft de functie hoogstens één tekstbyte minder en daarna een afsluitend nulteken:

char buf[8];
int needed = snprintf(buf, sizeof buf, "%s-%d", "item", 2026);
if (needed < 0) {
    puts("Formatting error");
} else if ((size_t) needed >= sizeof buf) {
    puts("Text did not fit");
}

Het volledige resultaat “item-2026” heeft negen tekstbytes. De buffer slaat “item-20” en de nulbyte op, terwijl needed gelijk is aan 9. De retourwaarde telt de tekst die zou zijn geproduceerd, zonder het afsluitende nulteken. Controleer of het resultaat negatief is voordat je het naar size_t converteert.

Kopieer en vul bytes

memcpy(dest, src, n) kopieert precies n bytes, inclusief eventuele nulbytes, zonder naar een afsluitend nulteken te zoeken. Voor twee even grote arrays van gehele getallen kopieert memcpy(b, a, sizeof a) de volledige opslag als de gebieden niet overlappen. Waar elk van vijf gehele getallen vier bytes inneemt, is dat aantal 20 bytes. memmove kopieert bytes met gedefinieerd gedrag voor overlappende gebieden.

memset(a, 0, sizeof a) vult elke byte met nul en zet een array van gehele getallen op nul. Het tweede argument beschrijft elke byte, niet elk element. Bij gehele getallen van vier bytes maakt vullen met 1 de bytes 01 01 01 01, wat bij de gebruikelijke representatie 16.843.009 oplevert, niet het gehele getal 1. Gebruik een lus om geheeltallige waarden anders dan nul toe te wijzen.

memcmp(a, b, n) vergelijkt opgeslagen bytes. Nul betekent dat die bytereeksen overeenkomen. Vergelijk elementen voor waardegelijkheid: de drijvendekommawaarden 0.0 en -0.0 zijn bij vergelijking gelijk, terwijl hun representaties kunnen verschillen.

Herken andere bibliotheekfamilies

De BSD-functies strlcpy en strlcat zijn in 2024 aan POSIX toegevoegd, maar zijn geen kernfuncties van C17. Ze geven een lengte terug die ze probeerden te maken; een resultaat dat minstens zo groot is als de opgegeven grootte duidt op afkapping. strlcpy schrijft een afsluitend nulteken als de grootte positief is. strlcat doet dat alleen als de bestaande tekst binnen die grootte eindigt. Ze zijn beschikbaar in glibc 2.38 en later. Optionele functies uit Annex K, zoals strcpy_s, ontbreken in veel bibliotheken, waaronder glibc.

Een tabel heeft een rij-index en een kolomindex nodig. In C is een tweedimensionale array een array waarvan de elementen zelf arrays zijn. Elke rij heeft evenveel elementen en elke index heeft een eigen grens.

Declareer rijen en kolommen

int grid[3][4];
int m[2][3] = {{1, 2, 3}, {4, 5, 6}};

grid bevat drie rijen met elk vier gehele getallen: in totaal twaalf gehele getallen. De rij-indexen lopen van 0 tot en met 2; de kolomindexen van 0 tot en met 3. grid[1][2] benadert de derde waarde in de tweede rij.

Geneste accolades in de initialisator laten de indeling in rijen zien. Ontbrekende initialisatiewaarden worden nul. Je kunt de compiler de rijen laten tellen in int m[][3] = {{1, 2, 3}, {4, 5, 6}};, maar het aantal kolommen moet je opgeven. Zonder dat aantal kan de compiler niet bepalen waar elke rij eindigt.

Volg de rijgewijze opslag

C slaat een volledige rij op voordat de volgende begint. In grid vormen de eerste vier opgeslagen gehele getallen rij 0, de volgende vier rij 1 en de laatste vier rij 2. grid[1][2] is het zevende gehele getal vanaf het begin, op elementpositie 6 bij indexering vanaf nul: één volledige rij van vier, gevolgd door nog twee elementen.

Waar gehele getallen vier bytes innemen, gebruikt één rij zestien bytes en de hele tabel achtenveertig. Op de plaats van de declaratie:

size_t rows = sizeof grid / sizeof grid[0];
size_t cols = sizeof grid[0] / sizeof grid[0][0];

De eerste deling geeft 3 en de tweede 4. Een rij is zelf een array; daarom meet sizeof grid[0] meer dan één geheel getal.

Doorloop de tabel en bereken totalen

int sales[2][3] = {{4, 0, 7}, {5, 2, 1}};
int total = 0;
for (int r = 0; r < 2; r++) {
    int row_sum = 0;
    for (int c = 0; c < 3; c++) {
        row_sum += sales[r][c];
    }
    printf("%d\n", row_sum);
    total += row_sum;
}

De eerste rij levert 11 op en de tweede 8. Als je die rijtotalen optelt, krijg je 19. Door row_sum binnen de buitenste lus opnieuw in te stellen, begint voor elke rij een nieuw totaal. Als de variabele slechts één keer vóór beide lussen was geïnitialiseerd, zou de tweede afgedrukte waarde ook de eerste rij bevatten.

Voor kolomtotalen zet je de kolomlus buiten en de rijlus binnen, terwijl je nog steeds sales[r][c] gebruikt. De drie totalen worden 9, 2 en 8, samen opnieuw 19. Als je de doorloopvolgorde verandert, hoef je de betekenis van de twee indexen niet te veranderen. Een doorloop met de rijen als buitenste lus volgt de aaneengesloten opslag en verbetert bij grote tabellen vaak het gebruik van de cache.

Houd elke dimensie binnen de grenzen

grid[c][r] verwisselt de betekenis van de indexen. Als c 3 bereikt, vraagt de expressie een vierde rij op die niet bestaat. Dat het volledige object twaalf gehele getallen bevat, betekent niet dat je met een kolomindex de grens van één rij mag overschrijden.

Schrijf twee afzonderlijke indexbewerkingen: grid[1][2]. In C17 evalueert grid[1, 2] de komma-expressie en selecteert grid[2], een rij, in plaats van één element. Bij meer dimensies pas je hetzelfde idee herhaaldelijk toe: int cube[2][3][4] heeft 24 geheeltallige elementen, die je met drie indexen selecteert.

Een functie die een tabel ontvangt, heeft genoeg informatie nodig om elke rij te vinden. Een lijst met strings brengt nog een keuze mee: sla de tekens op in rijen van gelijke breedte of sla verwijzingen op naar strings met verschillende lengtes.

Geef een tabelparameter zijn rijbreedte

void double_grid(int rows, int g[][4]) {
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < 4; c++) {
            g[r][c] *= 2;
        }
    }
}

De eerste dimensie kan worden weggelaten omdat het aantal rijen afzonderlijk wordt doorgegeven. De breedte 4 bepaalt het type van elke rij. Zonder die breedte zou de afstand tussen rijen voor g[r][c] niet bekend zijn. Een declaratie met int g[][] is ongeldig. Wijzigingen via deze parameter blijven bestaan in de tabel van de aanroepende functie; een tabelparameter die alleen wordt gelezen, kan const int g[][4] gebruiken.

Sinds C99 accepteren compilers die parameters met een variabel gemodificeerd type ondersteunen dimensies die eerder in de parameterlijst zijn gedeclareerd:

void print_grid(int rows, int cols, int g[rows][cols]);

GCC en Clang ondersteunen deze C17-vorm. Hiermee kan één functie verschillende rijbreedtes ontvangen; geef positieve dimensies door die overeenkomen met de werkelijke tabel. C23 vereist ondersteuning voor deze parametertypen, terwijl automatische objecten die arrays met variabele lengte zijn een afzonderlijke optionele functie blijven. Parameters met vaste breedte zijn nuttig als de compilerondersteuning beperkt is.

Sla strings op in rijen

char days[7][10] = {
    "Monday", "Tuesday", "Wednesday", "Thursday",
    "Friday", "Saturday", "Sunday"
};

Elke rij heeft opslagruimte voor tien tekens, ongeacht de huidige tekstlengte. “Wednesday” heeft alle tien posities nodig: negen letters en een afsluitend nulteken. days[2] selecteert die hele rij als string; days[2][0] selecteert 'W'.

Je kunt een rij afdrukken met %s, meten met strlen of vergelijken met strcmp. De rij kan ook een gecontroleerde kopie ontvangen. strcpy(days[0], "Mon"); past in tien bytes en wijzigt de tekst van rij 0. De rij blijft tien bytes breed en de volgende rij blijft op dezelfde locatie. Vervangende tekst van tien bytes zou elf bytes nodig hebben en niet passen.

Sla verwijzingen naar literals op

const char *names[] = {"Ann", "Bartholomew", "Li"};

Dit declareert een array van pointers. Elk element verwijst naar een literal met zijn eigen lengte plus een afsluitend nulteken. names[1] verwijst naar “Bartholomew” en names[1][0] is 'B'. De literals mogen niet worden gewijzigd.

De pointerelementen kunnen veranderen, hoewel de tekens van de literals dat niet kunnen. names[0] = "Anna"; verandert naar welke literal het eerste element verwijst; de instructie verlengt “Ann” niet op dezelfde locatie. In de vorm met 2D-rijen is een element een tekenarray met vaste breedte en kan het niet op die manier opnieuw worden toegewezen. Kies beschrijfbare rijen voor tekst die je op dezelfde locatie bewerkt en verwijzingen naar literals voor een lijst met vaste tekstkeuzes. De opdrachtregelparameter argv heeft de vorm van een array van pointers, hoewel de meegegeven argumenttekens wijzigbaar zijn.

Met opdrachtregelargumenten kan de aanroepende partij bij het starten van een programma tekst meegeven. De besturingsomgeving maakt die strings beschikbaar voor main. Controleer hoeveel argumenten zijn aangekomen voordat je ze met een index benadert.

Lees de argumentenlijst

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        printf("%d: %s\n", i, argv[i]);
    }
    return 0;
}

Neem <stdio.h> op voor de uitvoer. argc is het aantal argumenten en argv is de lijst met strings. De gelijkwaardige schrijfwijze char **argv voor de parameter beschrijft dezelfde interface. De lus begint bij 1 omdat index 0 normaal de naam bevat waarmee het programma is gestart.

In een gewone shell levert ./greet Ada Lovelace drie strings op: “./greet”, “Ada” en “Lovelace”. Dus argc is 3 en het laatste gebruikersargument is argv[2]. Op argv[argc], hier argv[3], staat een nulpointer; die is een stopwaarde na de eigenlijke argumentstrings.

Laat de shell tekst groeperen

Aanhalingstekens beïnvloeden hoe de shell argumenten opbouwt. Als je ./greet "Ada Lovelace" uitvoert, geef je één gebruikersargument met een spatie mee. De aanhalingstekens groeperen de woorden en worden geen onderdeel van de argumenttekst. argc is nu 2.

Unix-achtige shells kunnen ook patronen uitbreiden voordat het programma start. Bij ./count *.txt ontvangt het programma doorgaans de namen die de shell vindt als afzonderlijke argumenten. Het ontvangt de resulterende strings, geen verzoek om het patroon zelf uit te breiden. Het precieze uitbreidingsgedrag hangt af van de shell en de instellingen ervan.

Wijs een ontbrekend of extra argument af

Als een programma precies één gebruikersargument nodig heeft, vereis dan argc == 2 voordat je het gebruikt:

if (argc != 2) {
    printf("Usage: %s name\n", argv[0]);
    return 1;
}
printf("Hello, %s\n", argv[1]);

Als argc gelijk is aan 1, is argv[1] de nulpointer die als stopwaarde dient. Je kunt die niet aan strlen doorgeven of met %s afdrukken. Indexen voorbij de stopwaarde liggen buiten de argumentarray.

Nul teruggeven vanuit main geeft aan dat het programma is geslaagd. Een status anders dan nul, zoals de 1 hierboven, laat de shell weten dat het programma niet succesvol is voltooid. <stdlib.h> biedt ook EXIT_SUCCESS en EXIT_FAILURE.

Behandel elk argument als een string

argv[i][0] benadert het eerste teken van het argument; strlen(argv[i]) meet de tekstbytes; strcmp(argv[i], "-v") == 0 controleert een volledige optie. Een argument dat eruitziet als een getal is nog steeds tekst en moet vóór een berekening worden geconverteerd.

argv[0] legt meestal vast hoe het programma is gestart, maar kan leeg zijn als die informatie niet beschikbaar is. Het is nuttig voor berichten, niet als vaste identiteitscontrole. Argumenttekens mogen tijdens het programma worden gewijzigd, maar de meegeleverde opslag biedt geen grond om aan te nemen dat een langere vervangende tekst past. Om een extensie toe te voegen of tekst op een andere manier langer te maken, kopieer je die eerst naar een afzonderlijke buffer met een passende grootte.

Een numeriek argument komt binnen als tekens, niet als geheel getal. Een betrouwbare conversie controleert drie afzonderlijke vragen: vormden cijfers een getal, gebruikte de conversie de vereiste tekst en is de resulterende waarde toegestaan?

Voorkom verlies van foutinformatie

atoi, gedeclareerd in <stdlib.h>, voert een eenvoudige conversie uit. De functie zet “13” om in 13, maar ook “12abc” in 12. Ze geeft zowel voor “0” als voor tekst zoals “abc” die niet met een getal begint nul terug. Een resultaat buiten het waardenbereik is ongedefinieerd gedrag, dus een test op alleen cijfers gevolgd door atoi is bij zeer lange invoer nog steeds onveilig.

Een vormregel zoals “alleen één of meer cijfers” vereist een afzonderlijke controle. Wijs een lege string af en vereis dat elke byte voldoet aan isdigit((unsigned char) c). Die regel accepteert “13” en wijst “13a”, “-5” en “” af. De regel controleert de schrijfwijze, niet of de waarde in een geheel getal van de machine past.

Gebruik strtol en bekijk waar de conversie stopte

#include <errno.h>
#include <stdlib.h>

char *end;
errno = 0;
long count = strtol(argv[1], &end, 10);
if (end == argv[1] || *end != '\0' || errno == ERANGE) {
    puts("Enter a whole number");
    return 1;
}
if (count < 1 || count > 100) {
    puts("Count must be from 1 to 100");
    return 1;
}

Dit fragment volgt op een controle van het aantal argumenten en gebruikt <stdio.h> voor puts. De 10 kiest decimale conversie. end ontvangt de locatie waar de conversie stopte; met &end kan de functie die locatie opslaan. *end leest het teken op die locatie. Pointerrekenen is niet nodig.

Voor “13a” is de teruggegeven waarde 13, maar is *end gelijk aan 'a', dus wordt de tekst afgewezen. Voor een lege string of “abc” is end gelijk aan het begin van het argument. Dat laat zien dat geen getal is verwerkt. Beide controles zijn nodig: alleen op de afsluitende nul testen zou een lege string ten onrechte accepteren.

Zet vóór elke conversie errno terug op nul. Een waarde buiten het bereik van long zorgt ervoor dat strtol een grenswaarde teruggeeft en ERANGE instelt. Zonder die reset kan een oude fout bij deze conversie lijken te horen. Controleer het resultaat voordat je het naar int vernauwt; gebruik INT_MIN en INT_MAX uit <limits.h> als het volledige bereik van int het toegestane bereik is.

Pas de eigen regel van het programma toe

strtol accepteert witruimte aan het begin en een optioneel teken. Bepaal of die vormen zijn toegestaan. Als de interface alleen cijfers vereist, voer dan naast de conversiecontroles ook de controle op een niet-lege reeks cijfers uit. Controleer na een geslaagde conversie het toegestane waardenbereik van de toepassing voordat je een waarde als aantal of index gebruikt. “0” kan volkomen geldige numerieke tekst zijn en toch ongeldig zijn voor een aantal dat positief moet zijn.

Een Caesarprogramma dat een niet-negatieve sleutel accepteert, controleert eerst argc, dan of de invoer alleen cijfers bevat en daarna het volledige resultaat van strtol en het bereik. Door een geldige sleutel met % 26 te reduceren, krijg je vóór de letterberekening een verschuiving van 0 tot en met 25. Sleutel 27 heeft het effect van sleutel 1. Voer de bereikcontrole uit vóór een expliciete typeconversie naar een smaller type of een berekening die kan overlopen. Voor decimale waarden biedt strtod de bijbehorende interface voor eindpositie en bereikfout.

Elke toegang tot een array vereist een geldige index. C vereist tijdens de uitvoering geen grenscontrole, dus moet de programmeur de index binnen het object houden. Toegang buiten het bereik heeft ongedefinieerd gedrag: de taal garandeert geen resultaat.

Herken ongeldige toegang

Voor int a[5] zijn de geldige indexen 0 tot en met 4. Index 5 is al te groot en -1 is negatief. Een compiler kan een zichtbare fout melden, maar veel ongeldige indexen hangen af van invoer tijdens de uitvoering en worden niet tijdens het compileren afgewezen.

Een programma met een fout kan goed lijken te werken, vastlopen of onverwachte waarden opleveren. Een schrijfbewerking kan nabijgelegen gegevens aantasten; het verschijnsel kan pas later in een niet-gerelateerde berekening optreden. Een leesbewerking kan bytes buiten het bedoelde object benaderen. Geen van beide bewerkingen heeft een betrouwbaar resultaat. Herhaling van een geslaagde uitvoering kan niet vaststellen dat de toegang geldig is.

Tel elke schrijfbewerking, inclusief het afsluitende nulteken

char name[8];
strcpy(name, "Christopher");

“Christopher” heeft elf tekstbytes. Bij het kopiëren wordt ook het afsluitende nulteken geschreven, dus probeert deze aanroep twaalf bytes in acht posities te plaatsen. Dat is een bufferoverloop. Op echte systemen kan een overloop andere gegevens of besturingsinformatie beschadigen. In het verleden hebben aanvallen, waaronder die van de Morris-worm uit 1988, zulke fouten in de invoerverwerking uitgebuit.

Een overloop kan slechts één byte zijn:

char s[5];
for (int i = 0; i <= 5; i++) {
    s[i] = 'x';
}

De lusinhoud wordt zes keer uitgevoerd en schrijft naar index 5. Als je de test verandert in i < 5, blijven vijf schrijfbewerkingen voor tekens binnen de array, maar ontstaat nog steeds geen string. Schrijf voor een string van vier 'x'-tekens alleen naar de indexen 0 tot en met 3 en sla daarna '\0' op bij index 4.

Valideer berekende indexen

Een frequentietabel kan een teken omzetten in een index, maar aftrekken alleen garandeert geen geldig bereik:

int counts[26] = {0};
if (c >= 'a' && c <= 'z') {
    counts[c - 'a']++;
}

Bij ASCII-volgorde beperkt die test het resultaat tot 0 tot en met 25. Voor 'A' of een byte met een leesteken kan c - 'a' zonder de test een negatieve index opleveren. Test de oorspronkelijke waarde voordat je een index gebruikt; controleren na het schrijven is te laat.

Valideer bij een tabel de rij en kolom afzonderlijk. In int g[2][3] is een kolomindex van 3 ongeldig, ook als de volgende rij ernaast in het geheugen staat. Gebruik de opslagruimte van de volledige tabel niet als reden om de grens van een rij te overschrijden.

Gebruik controles die bij de bewerking passen

Een arraylus gebruikt een strikte bovengrens; bij toevoegen controleer je het aantal tegenover de capaciteit; bij een string kopiëren controleer je de tekstlengte plus één. Functies ontvangen werkelijke lengtes of capaciteiten van hun aanroepende functies. Deze controles gaan over verschillende grootheden, dus één vast in de code opgenomen grootte kan ze niet allemaal vervangen.

Compileer met waarschuwingen zoals -Wall -Wextra. Met -fsanitize=address -g kunnen GCC en Clang veel ongeldige toegangen op uitgevoerde paden melden en de bronlocatie tonen. Zulke tests helpen fouten te vinden, maar over niet-uitgevoerde paden moet je nog steeds redeneren om de grenzen te controleren. Beoordeel elke lees- en schrijfbewerking met een index door het object, de grens en de voorwaarde die de index geldig houdt te bepalen.

Degene die invoer aanlevert, bepaalt de lengte ervan. Geef leesfuncties een werkelijke buffergrens en controleer wat ze teruggeven. Bepaal daarna of de gegevens een volledige regel vormen en of ze binnen de eigen regels van het programma passen.

Lees één woord met een veldbreedte

Voor char word[16]; leest scanf("%15s", word) hoogstens vijftien tekens die geen witruimte zijn en voegt '\0' toe. De veldbreedte laat één van de zestien posities vrij voor het afsluitende nulteken. %s zonder veldbreedte heeft geen maximale lengte; gets had hetzelfde fundamentele probleem voor regels en is in C11 uit C verwijderd.

Controleer of scanf 1 teruggeeft voordat je een woord gebruikt. De functie leest een woord, geen hele regel met spaties. Overtollige bytes van het woord kunnen ongelezen blijven, dus een veldbreedte beschermt de opslag zonder te bepalen of de hele invoer aanvaardbaar is.

Lees een regel met fgets

char buf[8];
if (fgets(buf, sizeof buf, stdin) == NULL) {
    return 1;
}

fgets leest hier hoogstens zeven tekens en schrijft een afsluitende nulbyte. De functie behoudt een nieuweregelteken als ze dat vóór de grens bereikt. Een regel met “hello” en een nieuweregelteken wordt "hello\n" plus het afsluitende nulteken. Een laatste regel die bij het bestandseinde zonder nieuweregelteken eindigt, kan nog steeds met succes worden gelezen. Als vóór het bestandseinde geen tekens zijn gelezen of als een leesfout optrad, is het resultaat NULL; verwerk die buffer dan niet als nieuwe invoer.

Onderscheid een opgeslagen nieuweregelteken van een onvolledige regel

Zoek een nieuweregelteken voordat je het verwijdert:

size_t end = strcspn(buf, "\n");
int had_newline = buf[end] == '\n';
buf[end] = '\0';

Neem <string.h> op. Als er geen nieuweregelteken is opgeslagen, is end de tekstlengte en overschrijft de toewijzing het bestaande afsluitende nulteken. Een ontbrekend nieuweregelteken kan duiden op een onvolledige regel, een buffer die precies vóór een nieuweregelteken is gevuld of een laatste regel die bij het bestandseinde eindigde. Op zichzelf bewijst dit niet dat er nog tekens over zijn.

Voor de invoerregel “abcdefghij” en een buffer van acht bytes slaat de eerste leesbewerking “abcdefg” op en kan de volgende “hij\n” lezen. Als je het tweede deel als een afzonderlijk antwoord behandelt, splits je één logische invoer. Een programma kan een regel zonder vereist nieuweregelteken afwijzen of de rest ervan lezen en weggooien voordat het opnieuw om invoer vraagt. Leg het invoerbeleid vast voordat je het implementeert.

Gebruik 32 bytes voor maximaal dertig ASCII-tekens in een naam plus een nieuweregelteken en een afsluitend nulteken. Voor UTF-8 is dit een grens in bytes: dertig weergegeven tekens kunnen meer opslagruimte nodig hebben.

Kopieer pas na controle van alle vereisten

char user[10];
if (argc != 2) return 1;
if (strlen(argv[1]) >= sizeof user) {
    puts("Name too long");
    return 1;
}
strcpy(user, argv[1]);

De controle van het aantal argumenten komt eerst. De lengtecontrole laat daarna hoogstens negen tekstbytes toe en laat de tiende positie vrij voor nul. Een schrijffunctie moet de capaciteit expliciet ontvangen, zoals in read_name(out, capacity), omdat sizeof out daarbinnen een pointerparameter meet.

Lees voor numerieke invoer een volledige regel en converteer die met strtol. Controleer daarbij de eindpositie, een eventuele bereikfout en het toegestane waardenbereik. Een mislukte scanf("%d", &n) kan de problematische tekst ongelezen laten staan; als je de aanroep blindelings herhaalt, kan die op dezelfde bytes eindeloos blijven mislukken. Controleer minimaal het aantal geslaagde toewijzingen en handel de ongeldige invoer af voordat je het opnieuw probeert.