Obter comprimento do array Char em C

Em C, “comprimento” pode significar o número de elementos reservados em um array de char ou o número de caracteres antes do terminador nulo de uma string. Use sizeof para obter o espaço ocupado pelo array e sua quantidade de elementos enquanto o tipo do array ainda estiver disponível. Use strlen somente com uma string válida terminada em nulo.

Como obter o comprimento de um array de caracteres em C usando o operador sizeof

sizeof array informa o tamanho do array em bytes de C. Divida esse valor por sizeof array[0] para obter a quantidade de elementos. Em um array de char, cada elemento ocupa um byte de C; um byte de C não corresponde necessariamente a um octeto de oito bits.

Execute este exemplo:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#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'

O inicializador de letters reserva quatro elementos e não inclui um terminador. O literal de string inicializa word com cinco elementos: quatro caracteres visíveis e o \0 terminador. Subtraia um somente quando souber que o array contém esse terminador e quiser obter o comprimento da string. %zu é o especificador de conversão de printf correspondente a size_t.

sizeof mede o array inteiro somente quando o tipo do array está disponível. Em um parâmetro de função como char text[], o parâmetro é ajustado para um ponteiro; nesse caso, sizeof text mede o ponteiro. Passe a quantidade de elementos separadamente quando uma função precisar do comprimento do array. Consulte size_t para saber mais sobre o tipo sem sinal usado para tamanhos. O destino localizado em português não está disponível para esse link; por isso, o alvo original foi mantido.

Como obter o comprimento de um array de caracteres em C usando a função strlen

strlen, declarada em <string.h>, conta os caracteres até o primeiro \0, sem incluí-lo. O argumento precisa apontar para uma string válida terminada em nulo. A função não conhece a capacidade do array e não consegue encontrar com segurança o fim de um array sem terminador. Consulte strings terminadas em nulo para entender essa representação. O destino localizado em português não está disponível para esse link; por isso, o alvo original foi mantido.

Por exemplo, strlen("Code") retorna quatro: o literal tem cinco elementos no array, mas o terminador não é contado. Essa chamada é adequada porque o literal fornece o terminador. Não chame strlen em um array de tamanho explícito, a menos que saiba que há um terminador dentro dos limites acessíveis do array.

Como obter o comprimento de um array de caracteres em C por contagem manual

A contagem manual é útil quando há um limite conhecido ou um terminador válido. Para um array com uma quantidade conhecida de elementos count, percorra os índices de 0 a count - 1; não leia array[count]. Se quiser obter o comprimento de uma string armazenada nesse array, pare em \0 e garanta que a varredura não ultrapasse o limite do array.

Este exemplo usa a quantidade de elementos do array como limite e também para no terminador. Como text é inicializado a partir de um literal de string, o terminador está dentro do array. O laço verifica o limite antes de ler cada elemento, portanto nunca acessa text[sizeof text]. O exemplo imprime 4, correspondente aos quatro caracteres de Code.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

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

Para dados sem terminador, use a quantidade de elementos fornecida separadamente e processe somente esses elementos; não continue a leitura até \0, a menos que haja garantia de que o terminador está dentro do limite.

Como obter o comprimento de um array de caracteres em C usando ponteiros

Um ponteiro pode percorrer uma string, mas não guarda a capacidade do array. Para uma string válida terminada em nulo, o percurso pode avançar enquanto *ptr != '\0'; essa condição exige o mesmo terminador que strlen. Este exemplo obtém o endereço de um array criado a partir de um literal de string, portanto há garantia de um terminador dentro do limite conhecido. Ele verifica o ponteiro de fim antes de desreferenciá-lo e também para no terminador. O exemplo imprime 4, correspondente aos quatro caracteres de Code.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

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

Para dados sem terminador, mantenha uma contagem ou um ponteiro de fim separado e pare no limite conhecido. Quando uma função recebe um ponteiro para o primeiro elemento, passe a quantidade de elementos como outro argumento se ela precisar percorrer um array cujo comprimento não seja indicado por um terminador de string. A aritmética de ponteiros, por si só, não determina onde um array termina. Consulte comprimento de um array em C para entender a distinção relacionada ao tamanho de arrays.

Conclusão

Escolha a medida adequada para a tarefa: sizeof array / sizeof array[0] fornece a quantidade de elementos de um array quando seu tipo completo está disponível; subtraia o terminador somente em um array que você sabe que contém esse terminador, quando quiser obter o comprimento da string. strlen conta os caracteres anteriores a \0 em uma string válida terminada em nulo. A contagem manual e o percurso com ponteiros exigem um terminador válido ou um limite explícito. Mantenha disponível o comprimento dos arrays ao passá-los para funções, pois esses parâmetros são ponteiros.