Docs executáveis de C: Funções de string

Q: Por que não posso comparar strings com == em C?

a == b compara os dois endereços, não os caracteres. Dois arrays separados guardando "gato" ficam em endereços diferentes, então a comparação é falsa mesmo com o texto igual. Use strcmp(a, b) == 0, de .

Q: Qual a diferença entre strcpy e strncpy?

O strcpy copia até o '\0' da origem sem ideia de quão grande é o destino. O strncpy para depois de no máximo n bytes - mas, se a origem tiver esse comprimento, ele copia nenhum terminador, então você precisa escrever dst[n - 1] = '\0'; por conta própria. Nenhum dos dois é automaticamente seguro; a disciplina de tamanho é sua.

Q: Como encontrar uma substring em C?

strstr(palheiro, agulha) devolve um ponteiro para a primeira ocorrência, ou NULL se não houver nenhuma. Como ele devolve um ponteiro para dentro da string original, achou - palheiro dá o índice. Use strchr quando estiver procurando um único caractere.

Toda função de <string.h> é um pequeno laço sobre um array de char que para no terminador nulo. Uma vez que isso fica claro, a biblioteca deixa de parecer uma lista de nomes crípticos e passa a parecer o punhado de laços que você mesmo teria escrito. Esta página cobre as que fazem quase todo o trabalho real - e as regras de dimensionamento que as impedem de escrever além do fim dos seus buffers.

Tudo aqui precisa de um include:

#include <string.h>

strlen: quantos caracteres

O strlen conta bytes até o terminador, sem incluí-lo. Ele devolve size_t, então imprima com %zu.

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

int main(void) {
    char word[32] = "banana";

    printf("strlen = %zu\n", strlen(word));
    printf("sizeof = %zu\n", sizeof word);
    return 0;
}

O strlen é 6; o sizeof é 32. O primeiro é o texto, o segundo é o armazenamento - veja strings para entender por que essa distinção importa tanto.

O strlen percorre a string inteira a cada chamada, então não o coloque numa condição de laço sobre a mesma string que não muda:

/* reconta a string inteira a cada iteracao */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* conta uma vez */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy e strncpy: copiando

strcpy(dst, src) copia os caracteres mais o terminador. Ele não faz ideia de quão grande é dst, então o chamador precisa garantir que dst comporte pelo menos strlen(src) + 1 bytes.

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

int main(void) {
    char src[] = "portatil";
    char dst[16];

    strcpy(dst, src);
    printf("%s\n", dst);

    /* a regra de tamanho, verificada explicitamente */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("cabe com %zu bytes de sobra\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

O strncpy recebe uma contagem máxima, mas tem uma armadilha famosa: quando a origem tem pelo menos n bytes, ele copia exatamente n caracteres e nenhum terminador. Sempre termine a string você mesmo:

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

int main(void) {
    char src[] = "um nome de projeto bem longo";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* obrigatorio, nao opcional */

    printf("[%s]\n", dst);
    return 0;
}

O sizeof dst - 1 mais o terminador explícito é o padrão a memorizar. (O strncpy também completa origens curtas com zeros até n bytes, o que é trabalho desperdiçado em buffers grandes - ele foi projetado para registros de largura fixa, não para segurança.)

strcat e strncat: juntando

strcat(dst, src) acrescenta src ao final do que já estiver em dst. O destino precisa comportar as duas strings mais um terminador, e já precisa conter uma string válida - acrescentar a memória não inicializada é comportamento indefinido.

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

int main(void) {
    char path[64] = "/home/ada";

    strcat(path, "/");
    strcat(path, "notas.txt");

    printf("%s\n", path);
    printf("usou %zu de %zu bytes\n", strlen(path) + 1, sizeof path);
    return 0;
}

Repare no char path[64] = "/home/ada"; em vez de char path[64]; - o inicializador é o que o torna uma string válida para o primeiro strcat.

strncat(dst, src, n) acrescenta no máximo n caracteres e sempre adiciona um terminador, então n é o espaço restante, não o tamanho total do buffer:

strncat(dst, src, sizeof dst - strlen(dst) - 1);

Chamadas repetidas de strcat varrem o destino de novo para achar o fim dele toda vez. Construir uma string longa num laço desse jeito é quadrático; para qualquer coisa de tamanho relevante, controle a sua própria posição de escrita ou use snprintf, tratado em conversão de strings.

strcmp: comparando

O == compara endereços, então é falso para dois arrays distintos guardando o mesmo texto. O strcmp compara os caracteres e devolve o sinal da diferença.

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

int main(void) {
    char a[] = "abacate";
    char b[] = "abacate";
    char c[] = "banana";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (enderecos)? %s\n", pa == pb ? "sim" : "nao");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "sim" : "nao");

    printf("sinal de strcmp(a, c): %s\n", strcmp(a, c) < 0 ? "a antes de c" : "a depois de c");
    return 0;
}

Três regras:

Teste strcmp(a, b) == 0 para igualdade. Escrever if (strcmp(a, b)) significa "se elas diferem", que se lê ao contrário para quase todo mundo.
Só o sinal é definido. Não compare o resultado com 1 ou -1.
A ordenação é por valor de byte, então "Zebra" vem antes de "abacate" em ASCII. Para comparação sem distinção de maiúsculas, passe as duas cópias para minúsculas antes - o strcasecmp que se vê muito por aí é uma extensão POSIX, não C padrão.

strncmp(a, b, n) compara apenas os primeiros n caracteres, que é a forma limpa de testar um prefixo:

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

int main(void) {
    const char *url = "https://coddy.tech";

    if (strncmp(url, "https://", 8) == 0) {
        printf("URL segura\n");
    }
    return 0;
}

strchr e strstr: buscando

strchr(s, ch) encontra a primeira ocorrência de um caractere; strrchr encontra a última. strstr(palheiro, agulha) encontra uma substring. Os três devolvem um ponteiro para dentro da string original, ou NULL quando não há correspondência.

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

int main(void) {
    char email[] = "ada@coddy.tech";

    char *at = strchr(email, '@');
    if (at != NULL) {
        printf("'@' no indice %td\n", at - email);
        printf("dominio: %s\n", at + 1);
    }

    char *dot = strrchr(email, '.');
    printf("extensao: %s\n", dot != NULL ? dot + 1 : "(nenhuma)");

    if (strstr(email, "coddy") != NULL) {
        printf("contem \"coddy\"\n");
    }
    return 0;
}

Subtrair o ponteiro devolvido do início dá o índice; o tipo dele é ptrdiff_t, impresso com %td. Como o resultado aponta para dentro do array original, at + 1 é o resto da string sem cópia nenhuma - um idioma muito comum em C.

Sempre verifique NULL antes de desreferenciar. strchr(email, '@') + 1 numa string sem @ calcula um endereço a partir de NULL e o programa deixa de ser definido.

Dividindo uma string

Não existe uma função de split, mas strchr mais um terminador resolvem no próprio lugar. Este exemplo corta um e-mail em usuário e domínio:

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

int main(void) {
    char input[] = "ada@coddy.tech";
    char user[32];
    char domain[64];

    char *at = strchr(input, '@');
    if (at == NULL) {
        printf("nao e um endereco de email\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("parte do usuario longa demais\n");
        return 1;
    }

    memcpy(user, input, user_len);
    user[user_len] = '\0';

    strncpy(domain, at + 1, sizeof domain - 1);
    domain[sizeof domain - 1] = '\0';

    printf("usuario: %s\n", user);
    printf("dominio: %s\n", domain);
    return 0;
}

O memcpy copia uma quantidade exata de bytes sem se importar com terminadores, que é o que você quer quando já conhece o comprimento. O terminador é então escrito à mão.

Um exemplo trabalhado: normalizando um nome

Juntando o passeio - aparar, comparar, copiar e juntar:

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

int main(void) {
    char first[32] = "  ada  ";
    char last[32]  = "lovelace";
    char full[80];

    /* pula os espacos iniciais */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* corta os espacos finais */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* coloca a primeira letra de cada parte em maiuscula */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* junta com uma copia limitada */
    strncpy(full, start, sizeof full - 1);
    full[sizeof full - 1] = '\0';
    strncat(full, " ", sizeof full - strlen(full) - 1);
    strncat(full, last, sizeof full - strlen(full) - 1);

    printf("[%s]\n", full);
    printf("e Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "sim" : "nao");
    return 0;
}

Toda escrita é limitada pelo sizeof do próprio destino, e todo strncpy é seguido por um terminador explícito. Essa disciplina, aplicada com consistência, é o que torna seguro o código de strings em C.

Regras de dimensionamento para guardar

O strcpy precisa de strlen(src) + 1 bytes livres no destino.
O strcat precisa de strlen(dst) + strlen(src) + 1.
Depois de um strncpy, escreva dst[n - 1] = '\0' você mesmo.
Para o strncat, a contagem é o espaço que sobra: sizeof dst - strlen(dst) - 1.
Verifique NULL no strchr e no strstr antes de usar o resultado.
Use sizeof dst só quando dst for um array de verdade. Dentro de uma função que recebe char *dst, o sizeof dá o tamanho do ponteiro - passe o comprimento do buffer como parâmetro separado.

Perguntas frequentes

O que o strcmp devolve em C?

Zero quando as duas strings são idênticas, um valor negativo quando a primeira vem antes da segunda na ordenação, e positivo quando vem depois. Só o sinal tem significado - nunca suponha que ele devolve -1 ou 1. O teste que você quer é quase sempre if (strcmp(a, b) == 0).

Por que não posso comparar strings com == em C?

a == b compara os dois endereços, não os caracteres. Dois arrays separados guardando "gato" ficam em endereços diferentes, então a comparação é falsa mesmo com o texto igual. Use strcmp(a, b) == 0, de <string.h>.

Qual a diferença entre strcpy e strncpy?

O strcpy copia até o '\0' da origem sem ideia de quão grande é o destino. O strncpy para depois de no máximo n bytes - mas, se a origem tiver esse comprimento, ele copia nenhum terminador, então você precisa escrever dst[n - 1] = '\0'; por conta própria. Nenhum dos dois é automaticamente seguro; a disciplina de tamanho é sua.

Como encontrar uma substring em C?

strstr(palheiro, agulha) devolve um ponteiro para a primeira ocorrência, ou NULL se não houver nenhuma. Como ele devolve um ponteiro para dentro da string original, achou - palheiro dá o índice. Use strchr quando estiver procurando um único caractere.

Conceitos relacionados