As funções de manipulação de strings da biblioteca padrão de C estão declaradas em <string.h>. Entre as mais usadas estão:

Para utilizá-las, é necessário incluir o cabeçalho #include <string.h>.

1. strlen

A função strlen retorna o comprimento de uma string, sem contar o caractere terminador '\0'. O tipo de retorno é size_t, um inteiro sem sinal.

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

int main(void) {
    char texto[] = "abcde";
    size_t comprimento = strlen(texto);

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

Saída: 5.

Uma implementação possível usando aritmética de ponteiros:

#include <assert.h>
#include <stddef.h>

size_t tamanho_da_string(const char *s) {
    assert(s != NULL);

    const char *p = s;
    while (*p != '\0') {
        ++p;
    }

    return (size_t)(p - s);
}

2. strcpy

A função strcpy copia uma string de origem para um destino, incluindo o terminador '\0'. A cópia para quando o '\0' da origem é encontrado.

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

int main(void) {
    char origem[] = "abcdef";
    char destino[32] = {0};

    strcpy(destino, origem);
    puts(destino);

    return 0;
}

Se a origem for "abc\0def", a cópia resultante será apenas "abc", pois strcpy interrompe a cópia no primeiro '\0'.

O destino precisa ter espaço suficiente para receber a string copiada e o terminador. Caso contrário, ocorre escrita fora dos limites do array.

#include <assert.h>

char *copiar_string(char *destino, const char *origem) {
    assert(destino != NULL && origem != NULL);

    char *inicio = destino;
    while ((*destino++ = *origem++) != '\0') {
    }

    return inicio;
}

3. strcat

A função strcat concatena uma string ao final de outra. O array de destino precisa ter espaço suficiente para o conteúdo original, o conteúdo concatenado e o terimnador '\0'.

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

int main(void) {
    char texto[32] = "Olá, ";

    strcat(texto, "mundo");
    puts(texto);

    return 0;
}

Implementação equivalente:

#include <assert.h>

char *concatenar_string(char *destino, const char *origem) {
    assert(destino != NULL && origem != NULL);

    char *fim = destino;
    while (*fim != '\0') {
        ++fim;
    }

    while ((*fim++ = *origem++) != '\0') {
    }

    return destino;
}

4. strcmp

A função strcmp compara duas strings de acordo com os valores dos caracteres. O retorno é:

• positivo, se a primeira string for maior;
• zero, se forem iguais;
• negativo, se a primeira string for menor.

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

int main(void) {
    char a[] = "abcdef";
    char b[] = "abc";
    int resultado = strcmp(a, b);

    if (resultado > 0) {
        puts(">");
    } else if (resultado < 0) {
        puts("<");
    } else {
        puts("=");
    }

    return 0;
}

Uma implementação possível:

#include <assert.h>

int comparar_string(const char *a, const char *b) {
    assert(a != NULL && b != NULL);

    while (*a != '\0' && *a == *b) {
        ++a;
        ++b;
    }

    return (unsigned char)*a - (unsigned char)*b;
}

5. strstr

A função strstr procura a primeira ocorrência de uma substring dentro de outra string. Se encontrar, retorna um ponteiro para o início da ocorrência; caso contrário, retorna NULL.

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

int main(void) {
    char frase[] = "hello world";
    char alvo[] = "world";
    char *pos = strstr(frase, alvo);

    if (pos == NULL) {
        puts("substring não encontrada");
    } else {
        puts(pos);
    }

    return 0;
}

Se alvo for "hello", o retorno aponta para o início de frase. Se for "helo", o retorno é NULL.

Implementação possível:

#include <assert.h>
#include <stddef.h>

char *localizar_substring(const char *texto, const char *padrao) {
    assert(texto != NULL && padrao != NULL);

    if (*padrao == '\0') {
        return (char *)texto;
    }

    for (const char *inicio = texto; *inicio != '\0'; ++inicio) {
        const char *t = inicio;
        const char *p = padrao;

        while (*t != '\0' && *p != '\0' && *t == *p) {
            ++t;
            ++p;
        }

        if (*p == '\0') {
            return (char *)inicio;
        }
    }

    return NULL;
}

6. strtok

A função strtok divide uma string em tokens com base em um conjunto de delimitadores. Na primeira chamada, passa-se a string a ser dividida; nas chamadas seguintes, passa-se NULL para continuar a partir do ponto anterior.

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

int main(void) {
    char entrada[] = "wangyi@163.com";
    const char *delimitadores = "@.";
    char copia[64];

    strcpy(copia, entrada);

    char *token = strtok(copia, delimitadores);
    while (token != NULL) {
        puts(token);
        token = strtok(NULL, delimitadores);
    }

    return 0;
}

A saída é:

wangyi
163
com

strtok modifica a string original, substituinod delimitadores por '\0', e mantém estado interno entre chamadas. Por isso, não é uma função reentrante.