Tutorial de Strings em C | Array de char, strlen, strcpy Explicados

📖 O que aprender nesta página

✅ Essencial saber

Uma string é um array de char terminado com \0
printf("%s", s); imprime
char é na verdade um inteiro (código ASCII)
strlen, strcpy, strcmp estão em <string.h>

⭐ Leia se tiver tempo

Conversão de caixa: c + ('a'-'A')
strcpy é inseguro — prefira snprintf
Caracteres não-ASCII não cabem num único char

💪 Não entendeu de primeira? É normal.

Strings combinam ponteiros e arrays, então se qualquer um dos conceitos estiver fraco pode parecer confuso.

Como estudar de novo

Firme arrays primeiro — char s[10] é só um array
Aprenda ponteiros, depois volte aqui
Lembre do \0 final (terminador NUL) — ele marca o fim
Lembre que char é na verdade um inteiro (um código ASCII)
Para funções não familiares como strlen, aprenda primeiro como usá-las, e deixe os detalhes internos pra depois

💡 Dica: "Hello" é na verdade um array de 6 bytes: {'H','e','l','l','o','\0'}. "String = array + terminador" já te basta para começar.

O que é uma string?

C não tem um tipo de string dedicado. Strings são apenas arrays de char.

Ponto-chave: toda string em C termina com um caractere nulo '\0', que marca onde a string para.

    char name[20] = "Claude";   // até 19 caracteres + '\0'

    printf("%s\n", name);        // -> Claude

%s é o especificador de formato de string. Basta passar o nome do array — esse é o endereço de seu primeiro elemento.

A verdade sobre char — caracteres são números (ASCII)

Antes de ir mais fundo, eis o fato-chave:
um char é na verdade um inteiro de 1 byte (8 bits). A letra 'A' que você vê na tela é nada mais que o número 65 interpretado como caractere.

Ideia central: char c = 'A'; e char c = 65; são exatamente a mesma coisa.
printf("%c", 65) → A / printf("%d", 'A') → 65

Cheat sheet ASCII (faixas principais)

Caractere	Decimal	Significado
`'\0'`	0	NUL (terminador de string)
`'\n'`	10	quebra de linha
`' '`	32	espaço
`'0'–'9'`	48–57	dígitos ('0' = 48)
`'A'–'Z'`	65–90	letras maiúsculas
`'a'–'z'`	97–122	letras minúsculas

'a' - 'A' = 32 — a distância entre maiúsculas e minúsculas alimenta vários truques comuns.

Exemplo: caracteres e números são intercambiáveis

#include <stdio.h>

int main(void) {
    char c = 'A';
    printf("c = %c\n", c);     // → A  (como caractere)
    printf("c = %d\n", c);     // → 65 (como numero)

    // aritmetica em caracteres funciona
    printf("%c\n", c + 1);    // → B  (65+1=66)
    printf("%c\n", 'Z' - 3);  // → W

    // armazenar 65 num char eh o mesmo que 'A'
    char d = 65;
    printf("%c\n", d);        // → A
    return 0;
}

Idiomas clássicos

① De maiúscula para minúscula

char c = 'A';
char lower = c + ('a' - 'A');   // 'A' + 32 = 'a'
// ou: char lower = c + 32;

② Converter caractere de dígito para valor inteiro

char ch = '7';            // isso eh 55 (ASCII de '7')
int n = ch - '0';        // 55 - 48 = 7
printf("%d\n", n);       // → 7

③ Testes de caractere (maiúscula / dígito)

if (c >= 'A' && c <= 'Z') // maiuscula?
if (c >= '0' && c <= '9') // digito?
// <ctype.h> tambem fornece isupper(c), isdigit(c)

Por que char é um inteiro, afinal?

Lá nos anos 60, o ASCII (American Standard Code for Information Interchange) definiu um mapeamento de letras, dígitos e símbolos para números de 7 bits. C herdou esse mapeamento tratando caracteres como inteiros. Esse design simples é o que torna a aritmética de caracteres tão fácil em C.

Ressalva: caracteres não-ASCII não cabem num único char.
char c = 'あ'; dispara um erro ou aviso. Caracteres não-ASCII precisam de vários bytes (3 bytes em UTF-8), então moram num array de char ou num wchar_t. Só ASCII (letras, dígitos, pontuação) é seguro num único char.

Layout de memória de array de char

Vamos ver como a string "Hello" é disposta na memória.

char msg[6] = "Hello"; ← aloca 6 bytes (5 caracteres + '\0')

Cuidado com o tamanho! "Hello" tem 5 caracteres, mas você precisa de 6 bytes — os 5 caracteres mais o '\0' final. Um array pequeno demais causa bug de buffer overflow.

Entrada/saída de strings

Use %s para ler e escrever strings. Com scanf, note que você não precisa de &!

    char name[20];

    printf("Nome? ");

    scanf("%s", name);          // sem &

    printf("Ola, %s\n", name);

Por que sem &? O nome de um array como name decai para o endereço do primeiro elemento, então o endereço já é passado automaticamente.

[!] Pegadinhas do scanf("%s"): para em espaço em branco e não verifica tamanho da entrada. Entrada longa pode estourar o array — na prática, fgets é mais seguro.

Contando o tamanho da string

strlen da biblioteca padrão é o jeito fácil. Para ver como funciona, vamos construir uma versão caseira.

    // Conta ate '\0'

    int myStrlen(char s[]){

      int i = 0;

      while(s[i] != '\0') i++;

      return i;

    }

    int main(void){

      char msg[] = "Hello";

      printf("%d\n", myStrlen(msg)); // -> 5

    }

Essa é exatamente a razão pela qual '\0' é tão importante — é o marcador que diz onde a string termina.

Funções de string.h

As funções de string mais importantes, disponíveis via #include <string.h>.

Função	Objetivo	Exemplo	Notas
`strlen(s)`	Tamanho da string	`strlen("abc")` → 3	Não inclui `'\0'`
`strcpy(dst, src)`	Copia uma string	`strcpy(s, "Hello")`	`dst` tem que ter tamanho suficiente
`strncpy(dst, src, n)`	Copia até `n` caracteres	`strncpy(s, src, 10)`	Ajuda a prevenir buffer overflow
`strcat(dst, src)`	Concatena	`strcat(s, " World")`	`dst` tem que caber o resultado
`strcmp(s1, s2)`	Compara strings	`strcmp(a, b) == 0`	0 = igual; +/- mostram ordem
`strncmp(s1, s2, n)`	Compara os primeiros `n` caracteres	`strncmp(s, "ab", 2)`	Prático para checar prefixos
`strchr(s, c)`	Encontra um caractere	`strchr(s, 'o')`	Retorna `NULL` se não encontrado
`strstr(s, sub)`	Encontra uma substring	`strstr(s, "llo")`	Retorna `NULL` se não encontrada

Exemplo de strcpy e strcat

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

int main(void) {
    char greeting[50];
    strcpy(greeting, "Hello");     // greeting = "Hello"
    strcat(greeting, ", World!"); // greeting = "Hello, World!"
    printf("%s (%lu caracteres)\n", greeting, strlen(greeting));
    return 0;
}

Nunca compare strings com ==!
if (s1 == s2) compara endereços, não conteúdos.
Sempre use strcmp(s1, s2) == 0.

Cuidado com buffer overflow:
strcpy e strcat não checam o tamanho de destino.
Use um array grande o suficiente, ou limite a cópia com strncpy.

Experimente — strings

Um programinha que imprime uma string e seu tamanho.

string.c

Saída

Clique em "Executar" para rodar...

💡 Experimente estas ideias também

Converta a string para maiúsculas sem usar strupr
Conte o tamanho você mesmo — sem strlen
Concatene duas strings
Conte quantas vezes um dado caractere (ex.: 'e') aparece

Teste de Revisão

Teste seu entendimento desta aula!

Q1. O que tem no fim de uma string em C?

Caractere de nova linha \n

Caractere nulo \0

Espaço

Strings em C são sempre terminadas com um caractere nulo \0, que é como o código diz onde a string termina.

Q2. Que tamanho de array é necessário para guardar "Hello"?

"Hello" tem 5 caracteres mais o terminador nulo, então 6 bytes no total. Você precisa de char s[6] ou maior.

Q3. Qual função copia uma string?

strcpy

strcmp

strlen

strcpy copia, strcmp compara e strlen retorna o tamanho. Inclua <string.h> para usá-las.

Aula 22: Strings