Ottieni la lunghezza di un array di caratteri in C

In C, «lunghezza» può indicare il numero di elementi riservati in un array char oppure il numero di caratteri prima del terminatore nullo di una stringa. Usa sizeof per conoscere la dimensione in memoria e il numero di elementi di un array, finché il tipo dell’array è disponibile. Usa strlen solo con una stringa valida terminata da un carattere nullo.

Come ottenere la lunghezza di un array di caratteri in C con l’operatore sizeof

sizeof array restituisce la dimensione dell’array in byte C. Dividila per sizeof array[0] per ottenere il numero di elementi. In un array char, ogni elemento occupa un byte C; un byte C non corrisponde necessariamente a un ottetto di otto bit.

Esegui questo esempio:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

#include <stdio.h>

int main(void) {
  char letters[] = {'C', 'o', 'd', 'e'};
  char word[] = "Code";
  size_t letters_count = sizeof letters / sizeof letters[0];
  size_t word_capacity = sizeof word / sizeof word[0];
  size_t word_length = word_capacity - 1;

  printf("letters: %zu elements, %zu bytes\n", letters_count, sizeof letters);
  printf("word: %zu characters, %zu elements including '\\0'\n",
         word_length, word_capacity);
  return 0;
}

letters: 4 elements, 4 bytes
word: 4 characters, 5 elements including '\0'

L’inizializzatore di letters riserva quattro elementi e non contiene un terminatore. Il letterale stringa inizializza word con cinque elementi: quattro caratteri visibili e il \0 finale. Sottrai uno solo quando sai che l’array contiene quel terminatore e vuoi ottenere la lunghezza della stringa. %zu è il formato di conversione di printf adatto a size_t.

sizeof misura l’intero array solo quando il tipo dell’array è disponibile. In un parametro di funzione come char text[], il parametro viene convertito in un puntatore; in quel caso sizeof text misura il puntatore. Se una funzione ha bisogno della lunghezza dell’array, passa separatamente il numero di elementi. La pagina collegata su size_t, il tipo senza segno usato per le dimensioni, è disponibile solo in inglese.

Come ottenere la lunghezza di un array di caratteri in C con la funzione strlen

strlen, dichiarata in <string.h>, conta i caratteri fino al primo \0, senza includerlo. Il suo argomento deve puntare a una stringa valida terminata da un carattere nullo. La funzione non conosce la capacità dell’array e non può trovare in sicurezza la fine di un array privo di terminatore. La pagina collegata sulle stringhe terminate da un carattere nullo, che spiega questa rappresentazione, è disponibile solo in inglese.

Per esempio, strlen("Code") restituisce quattro: il letterale ha cinque elementi nell’array, ma il terminatore non viene contato. La chiamata è valida perché il letterale include il terminatore. Non chiamare strlen su un array di dimensione esplicita a meno che tu non sappia che al suo interno, nello spazio accessibile, è presente un terminatore.

Come ottenere la lunghezza di un array di caratteri in C contando manualmente

Il conteggio manuale è utile quando si dispone di un limite noto o di un terminatore valido. Per un array con un numero di elementi noto, indicato da count, visita gli indici da 0 a count - 1; non leggere array[count]. Se vuoi trovare la lunghezza della stringa contenuta nell’array, fermati a \0 e assicurati che la scansione non superi il limite dell’array.

Questo esempio usa il numero di elementi dell’array come limite e si ferma anche al terminatore. Poiché text è inizializzato con un letterale stringa, il suo terminatore si trova all’interno dell’array. Il ciclo verifica il limite prima di leggere ogni elemento, quindi non accede mai a text[sizeof text]. L’esempio stampa 4, il numero dei caratteri di Code.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

#include <stdio.h>

int main(void) {
  char text[] = "Code";
  size_t length = 0;
  size_t capacity = sizeof text / sizeof text[0];

  while (length < capacity && text[length] != '\0') {
    ++length;
  }

  printf("%zu\n", length);
  return 0;
}

Se i dati non hanno un terminatore, usa il numero di elementi fornito separatamente ed elaborane solo quelli; non continuare la scansione fino a \0 a meno che sia garantito che il terminatore si trovi entro il limite.

Come ottenere la lunghezza di un array di caratteri in C usando i puntatori

Un puntatore può scorrere una stringa, ma non contiene informazioni sulla capacità dell’array. Per una stringa valida terminata da un carattere nullo, lo scorrimento può proseguire finché *ptr != '\0'; vale lo stesso requisito di terminazione previsto da strlen. Questo esempio prende l’indirizzo di un array creato da un letterale stringa, quindi il terminatore è garantito entro il limite noto. Verifica il puntatore di fine prima di dereferenziarlo e si ferma anche quando incontra il terminatore. L’esempio stampa 4, il numero dei caratteri di Code.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

#include <stdio.h>

int main(void) {
  char text[] = "Code";
  char *ptr = text;
  char *end = text + sizeof text / sizeof text[0];

  while (ptr < end && *ptr != '\0') {
    ++ptr;
  }

  printf("%zu\n", (size_t)(ptr - text));
  return 0;
}

Per i dati senza terminatore, mantieni un conteggio separato o un puntatore di fine e fermati al limite noto. Se una funzione riceve un puntatore al primo elemento e deve scorrere un array la cui lunghezza non è indicata da un terminatore di stringa, passa anche il numero di elementi come argomento. La sola aritmetica dei puntatori non consente di determinare dove finisce un array. Consulta la lunghezza di un array in C per approfondire la distinzione tra dimensione dell’array e lunghezza della stringa.

Conclusione

Scegli la misura adatta al compito: sizeof array / sizeof array[0] restituisce il numero di elementi dell’array quando il suo tipo completo è disponibile; sottrai il terminatore solo per un array che sai essere terminato, se cerchi la lunghezza della stringa. strlen conta i caratteri prima di \0 in una stringa valida terminata da un carattere nullo. Il conteggio manuale e lo scorrimento con puntatori richiedono un terminatore valido oppure un limite esplicito. Quando passi un array a una funzione, conserva e passa la sua lunghezza, perché i parametri array vengono trattati come puntatori.