C string.h

Esta é a página de consulta rápida do <string.h>, a biblioteca de funções para texto (as str…) e para blocos de memória (as mem…). Aqui estão todas, em tabelas: o que cada uma faz, o que devolve, um exemplo com a saída real e a aula onde ela é explicada. Para aprender com calma, veja as aulas Strings, Funções de String e Ponteiros e Strings.

Todas as saídas foram produzidas de verdade: no gcc 15.2 da máquina da Ana (Linux de 64 bits, pasta ~/c/ref, comando gcc -std=c23 -Wall -Wextra) e no editor do guia (Clang em WebAssembly). Quando os dois diferem, a tabela diz.

Atalhos: Antes de tudo · Tamanho, cópia e junção · Comparar · Procurar e dividir · Blocos de memória · strerror · Qual usar · Editor × gcc · Erros comuns · Experimente

Antes de tudo: três regras

Uma string é um array de char que termina em '\0'

Toda função str… anda pelo texto até achar o '\0' (o caractere de código zero). Sem ele, a função continua lendo a memória que vem depois. Aula: Strings.

Nenhuma função sabe o tamanho do seu array

Elas recebem só um ponteiro para o primeiro caractere (aula Ponteiros e Strings). Quem garante que cabe é você. Um strcpy que não cabe escreve além do fim do array, sem erro nenhum na hora.

size_t

É o tipo dos tamanhos (um inteiro sem sinal). Mostre com %zu: printf("%zu", strlen(nome)). Aula: sizeof.

Nas tabelas, d é o destino (onde a função escreve), o é a origem (de onde ela lê), s é uma string e n é um número de bytes.

Tamanho, cópia e junção

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void) {
    char nome[20] = "Ana";
    printf("strlen=%zu sizeof=%zu\n", strlen(nome), sizeof nome);
    char copia[20];
    strcpy(copia, nome);
    printf("strcpy:  [%s]\n", copia);
    strcat(copia, " Souza");
    printf("strcat:  [%s]\n", copia);
    char curto[5];
    strncpy(curto, "Banana", sizeof curto - 1);
    curto[sizeof curto - 1] = '\0';
    printf("strncpy: [%s]\n", curto);
    char frase[20] = "Oi";
    strncat(frase, ", Ana Souza", 5);
    printf("strncat: [%s]\n", frase);
    char *dup = strdup("Caderno");
    char *pedaco = strndup("Caderno", 4);
    printf("strdup:  [%s] strndup: [%s]\n", dup, pedaco);
    free(dup);
    free(pedaco);
    char destino[20] = "";
    char *fim = memccpy(destino, "maçã;pera", ';', sizeof destino);
    printf("memccpy: [%.*s] copiou %td bytes\n", (int)(fim - destino), destino, fim - destino);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra copiar.c -o copiar
$ ./copiar
strlen=3 sizeof=20
strcpy:  [Ana]
strcat:  [Ana Souza]
strncpy: [Bana]
strncat: [Oi, Ana]
strdup:  [Caderno] strndup: [Cade]
memccpy: [maçã;] copiou 7 bytes

No editor, este programa não compila: a biblioteca C do editor só mostra o strndup e o memccpy com um #define _DEFAULT_SOURCE antes dos #include (veja Editor × gcc). Com essa linha, a saída é idêntica.

• strlen × sizeof: strlen(nome) é o tamanho do texto (3); sizeof nome é o tamanho do array (20). Dentro de uma função que recebeu char *s, sizeof s é o tamanho do ponteiro (8 no gcc, 4 no editor), não do array. Aula: sizeof.
• strlen conta bytes, não letras. Em UTF-8, cada letra acentuada ocupa 2 bytes. Aula: Acentos e UTF-8.
• strdup e strndup existem há décadas no Linux (POSIX), mas só entraram no C padrão no C23.

Comparar

#include <stdio.h>
#include <string.h>

int main(void) {
    printf("strcmp(\"Ana\", \"Bia\") = %d\n", strcmp("Ana", "Bia"));
    printf("strcmp(\"Bia\", \"Ana\") = %d\n", strcmp("Bia", "Ana"));
    printf("strcmp(\"Ana\", \"Ana\") = %d\n", strcmp("Ana", "Ana"));
    printf("strcmp(\"ana\", \"Ana\") = %d\n", strcmp("ana", "Ana"));
    printf("strcmp(\"Ana\", \"Ana Souza\") = %d\n", strcmp("Ana", "Ana Souza"));
    printf("strncmp(\"Banana\", \"Bando\", 3) = %d\n", strncmp("Banana", "Bando", 3));
    printf("strncmp(\"Banana\", \"Bando\", 4) = %d\n", strncmp("Banana", "Bando", 4));
    int a[3] = {1, 2, 3}, b[3] = {1, 2, 4};
    printf("memcmp(a, b, sizeof a) = %d\n", memcmp(a, b, sizeof a));
    printf("strcoll(\"abacate\", \"Banana\") = %d\n", strcoll("abacate", "Banana"));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra comparar.c -o comparar
$ ./comparar
strcmp("Ana", "Bia") = -1
strcmp("Bia", "Ana") = 1
strcmp("Ana", "Ana") = 0
strcmp("ana", "Ana") = 1
strcmp("Ana", "Ana Souza") = -1
strncmp("Banana", "Bando", 3) = 0
strncmp("Banana", "Bando", 4) = -3                « no editor: -1
memcmp(a, b, sizeof a) = -1
strcoll("abacate", "Banana") = 31

Procurar e dividir

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *email = "ana.souza@exemplo.com";
    const char *arroba = strchr(email, '@');
    printf("strchr:  [%s] posição %td\n", arroba, arroba - email);
    printf("strrchr: [%s]\n", strrchr(email, '.'));
    printf("strstr:  [%s]\n", strstr(email, "souza"));
    printf("strchr não achou: %s\n", strchr(email, '#') == NULL ? "NULL" : "achou");
    printf("strpbrk: [%s]\n", strpbrk("R$ 12,90", "0123456789"));
    printf("strspn:  %zu\n", strspn("2026-10-17", "0123456789"));
    printf("strcspn: %zu\n", strcspn("Ana\n", "\n"));
    char linha[] = "Ana\n";
    linha[strcspn(linha, "\n")] = '\0';
    printf("sem Enter: [%s]\n", linha);
    char *p = memchr("abc\0def", 'e', 7);
    printf("memchr:  [%s]\n", p);
    char lista[] = "arroz,feijão,,café";
    for (char *item = strtok(lista, ","); item != NULL; item = strtok(NULL, ",")) {
        printf("strtok:  [%s]\n", item);
    }
    printf("depois do strtok: [%s]\n", lista);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra procurar.c -o procurar
$ ./procurar
strchr:  [@exemplo.com] posição 9
strrchr: [.com]
strstr:  [souza@exemplo.com]
strchr não achou: NULL
strpbrk: [12,90]
strspn:  4
strcspn: 3
sem Enter: [Ana]
memchr:  [ef]
strtok:  [arroz]
strtok:  [feijão]
strtok:  [café]
depois do strtok: [arroz]

A saída do editor é idêntica.

• Sempre teste o NULL antes de usar o resultado de strchr, strstr etc.: printf("%s", strchr(email, '#')) com um resultado NULL é comportamento indefinido. Aula: Ponteiro Nulo.
• strtok não funciona numa string literal (char *lista = "a,b"), porque escreve nela; use um array (char lista[] = "a,b"). Ela também guarda a posição numa variável escondida: não dá para usar strtok em duas strings ao mesmo tempo. A versão que resolve isso é a strtok_r, do POSIX: funciona direto no gcc e, no editor, com #define _DEFAULT_SOURCE antes dos #include.

procurar.c:6:20: warning: initialization discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
    6 |     char *arroba = strchr(email, '@');
      |                    ^~~~~~

Blocos de memória: as funções mem…

As mem… trabalham com bytes, não com texto: recebem um void * (qualquer endereço; aula void*) e um número de bytes, e não ligam para o '\0'. Servem para arrays de qualquer tipo e para structs.

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main(void) {
    int notas[5];
    memset(notas, 0, sizeof notas);
    printf("memset 0: %d %d %d %d %d\n", notas[0], notas[1], notas[2], notas[3], notas[4]);
    memset(notas, 1, sizeof notas);
    printf("memset 1: %d\n", notas[0]);
    char senha[8] = "segredo";
    memset(senha, '*', strlen(senha));
    printf("memset '*': [%s]\n", senha);
    int origem[3] = {7, 8, 9}, copia[3];
    memcpy(copia, origem, sizeof origem);
    printf("memcpy: %d %d %d\n", copia[0], copia[1], copia[2]);
    char texto[20] = "abcdef";
    memmove(texto + 2, texto, 4);
    printf("memmove: [%s]\n", texto);
    memset_explicit(senha, 0, sizeof senha);
    printf("memset_explicit: strlen=%zu\n", strlen(senha));
    printf("strerror(ENOENT): %s\n", strerror(ENOENT));
    printf("strerror(EACCES): %s\n", strerror(EACCES));
    printf("strerror(0): %s\n", strerror(0));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra memoria.c -o memoria
$ ./memoria
memset 0: 0 0 0 0 0
memset 1: 16843009
memset '*': [*******]
memcpy: 7 8 9
memmove: [ababcd]
memset_explicit: strlen=0
strerror(ENOENT): No such file or directory
strerror(EACCES): Permission denied
strerror(0): Success

No editor, o memset_explicit não existe (error: use of undeclared identifier 'memset_explicit'). Sem essa linha, o resto sai igual.

Por que memset_explicit? Com otimização (-O2), o compilador pode apagar um memset(senha, 0, …) feito logo antes de a variável deixar de existir, já que "ninguém mais vai ler". A senha fica na memória. O memset_explicit não pode ser apagado.

strerror: a mensagem de um erro

O uso típico: fprintf(stderr, "Não abri %s: %s\n", nome, strerror(errno)); logo depois de um fopen que devolveu NULL. É o mesmo texto que o perror mostra.

Qual usar?

Editor × gcc

O que muda no <string.h> entre o editor (Clang + wasi-libc) e o gcc 15 (glibc), conferido com os programas desta página:

Iguais nos dois: todos os outros resultados desta página, os sinais de strcmp/strncmp/memcmp e os textos do strerror (também strerror(0) = Success).

Erros comuns

Este programa junta os enganos mais frequentes com strings. O -Wall pega todos, mas o programa compila e roda:

#include <stdio.h>
#include <string.h>

void limpar(char *s) {
    memset(s, 0, sizeof s);
}

int main(void) {
    char nome[4];
    strcpy(nome, "Ana Souza");
    char a[] = "Ana", b[] = "Ana";
    if (a == b) printf("iguais\n");
    const char *c = "Ana";
    if (c == "Ana") printf("igual ao literal\n");
    char sigla[3];
    strncpy(sigla, "SPX", sizeof sigla);
    limpar(nome);
    printf("%s %s\n", nome, sigla);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra errostr.c -o errostr
errostr.c: In function ‘limpar’:
errostr.c:5:25: warning: argument to ‘sizeof’ in ‘memset’ call is the same expression as the destination; did you mean to provide an explicit length? [-Wsizeof-pointer-memaccess]
    5 |     memset(s, 0, sizeof s);
      |                         ^
errostr.c: In function ‘main’:
errostr.c:12:11: warning: comparison between two arrays [-Warray-compare]
   12 |     if (a == b) printf("iguais\n");
      |           ^~
errostr.c:12:11: note: use ‘&a[0] == &b[0]’ to compare the addresses
errostr.c:14:11: warning: comparison with string literal results in unspecified behavior [-Waddress]
   14 |     if (c == "Ana") printf("igual ao literal\n");
      |           ^~
errostr.c:16:5: warning: ‘strncpy’ output truncated before terminating nul copying 3 bytes from a string of the same length [-Wstringop-truncation]
   16 |     strncpy(sigla, "SPX", sizeof sigla);
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
errostr.c:10:5: warning: ‘__builtin_memcpy’ writing 10 bytes into a region of size 4 overflows the destination [-Wstringop-overflow=]
   10 |     strcpy(nome, "Ana Souza");
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~
errostr.c:9:10: note: destination object ‘nome’ of size 4
    9 |     char nome[4];
      |          ^~~~
$ ./errostr
igual ao literal
 SPX

#include <stdio.h>

int main(void) {
    char *nome = "ana";
    printf("Antes: %s\n", nome);
    nome[0] = 'A';
    printf("Depois: %s\n", nome);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra literal.c -o literal
$ ./literal
Antes: ana
Falha de segmentação     (imagem do núcleo gravada) ./literal
$ echo $?
139

Experimente

#include <stdio.h>
#include <string.h>

int main(void) {
    char nome[40];
    printf("Seu nome: ");
    if (fgets(nome, sizeof nome, stdin) == NULL) {
        return 1;
    }
    // tire o '\n' aqui

    printf("Olá, [%s]! Seu nome tem %zu bytes.\n", nome, strlen(nome));
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void) {
    char nome[40];
    printf("Seu nome: ");
    if (fgets(nome, sizeof nome, stdin) == NULL) {
        return 1;
    }
    nome[strcspn(nome, "\n")] = '\0';

    printf("Olá, [%s]! Seu nome tem %zu bytes.\n", nome, strlen(nome));
    return 0;
}

Resumo

• Tamanho: strlen (bytes até o '\0'; não é o sizeof do array).
• Cópia e junção: strcpy, strcat (não conferem o tamanho), strncpy (pode deixar sem '\0'), strncat, strdup/strndup (memória nova, com free). Prefira snprintf.
• Comparação: strcmp, strncmp, memcmp, strcoll. Teste == 0, < 0 ou > 0, nunca == -1. Nunca == entre strings.
• Busca: strchr, strrchr, strstr, strpbrk, memchr (devolvem ponteiro ou NULL), strspn, strcspn (devolvem contagens). strtok divide, mas estraga a string e pula campos vazios.
• Memória: memset (byte a byte), memcpy (sem sobreposição), memmove (com sobreposição), memset_explicit (para senhas, C23).
• strerror(errno) dá o texto do erro do sistema.