C Novas Linhas e Escapes

Como escrever, dentro de um texto entre aspas, uma aspa? Ou uma tabulação, que você não consegue "ver"? Ou o caminho C:\Users\ana, cheio de barras invertidas? Desde o Olá, mundo você usa o \n para pular a linha. Ele é o mais famoso de uma família: as sequências de escape. Nesta aula você vai conhecer a família inteira, entender por que a saída deve terminar com \n, cair (de propósito) na armadilha do caminho do Windows e aprender a mostrar o % no printf.

Os exemplos foram compilados na máquina fictícia da Ana com o comando padrão do guia, gcc -std=c23 -Wall -Wextra, na pasta ~/c.

A ideia: a barra invertida "avisa" o compilador

Dentro de um texto entre aspas, quase todo caractere é ele mesmo: A é A, 7 é 7. Mas há dois problemas:

• alguns caracteres têm um papel para o compilador: a aspa " quer dizer "o texto acabou";
• outros não dá para digitar de forma visível: se você apertar Enter no meio das aspas, o texto fica "aberto" e dá erro (aula Sintaxe).

A solução é um código de duas letras que começa com a barra invertida \ (em inglês, backslash). A barra é um aviso, como as aspas de quem fala "entre aspas" com os dedos: "o próximo caractere não é ele mesmo; é um código". O nome técnico é escapar o caractere: tirá-lo do seu papel normal. Para o compilador, \n é um caractere só (a quebra de linha), embora você digite dois.

1. As sequências de escape mais usadas

#include <stdio.h>

int main(void) {
    printf("Linha 1\nLinha 2\n");
    printf("Nome\tIdade\n");
    printf("Ana\t29\n");
    printf("Ela disse: \"oi\"\n");
    printf("copo d'água e copo d\'água\n");
    printf("C:\\Users\\ana\n");
    putchar('\'');
    putchar(' ');
    putchar('"');
    putchar('\n');
    return 0;
}

$ gcc -std=c23 -Wall -Wextra escapes.c -o escapes
$ ./escapes
Linha 1
Linha 2
Nome	Idade
Ana	29
Ela disse: "oi"
copo d'água e copo d'água
C:\Users\ana
' "

Repare nas quatro últimas linhas do programa: num caractere (aspas simples, aula Caracteres), quem precisa de escape é a aspa simples ('\''); a dupla vai solta ('"'). Num texto (aspas duplas), é o contrário. A regra: só precisa escapar a aspa igual à que está "abraçando".

Dá para ver cada caractere que o programa mandou para a tela com o comando od -c (octal dump, "despejo de bytes", com -c de caracteres), que mostra até os invisíveis:

$ ./escapes | od -c | head -3
0000000   L   i   n   h   a       1  \n   L   i   n   h   a       2  \n
0000020   N   o   m   e  \t   I   d   a   d   e  \n   A   n   a  \t   2
0000040   9  \n   E   l   a       d   i   s   s   e   :       "   o   i

Cada "casinha" é um caractere. O \n e o \t ocupam uma casinha cada: são um caractere só, que o od desenha com dois símbolos porque eles não têm desenho próprio. (Os números da esquerda contam a posição, em octal; pode ignorar.)

2. A quebra de linha: \n

Você já sabe que o printf não pula linha sozinho (aula Saída com printf). O \n pode ficar em qualquer lugar do texto, e cada um é uma quebra. Dois seguidos dão uma linha em branco:

#include <stdio.h>

int main(void) {
    printf("Cardápio\n\n");
    printf("1. Pão de queijo\n2. Café\n");
    printf("\nBom apetite!\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra linhas.c -o linhas
$ ./linhas
Cardápio
                    « o segundo \n da linha 4
1. Pão de queijo
2. Café
                    « o \n do começo da linha 6
Bom apetite!

"Cardápio\n\n"

O primeiro \n termina a linha do "Cardápio"; o segundo termina uma linha vazia.

"1. Pão de queijo\n2. Café\n"

Um \n no meio: duas linhas com um printf só.

"\nBom apetite!\n"

Um \n no começo: primeiro pula (a linha anterior já tinha terminado, então sobra uma em branco), depois escreve.

Outros jeitos de pular a linha: puts("texto") põe o \n sozinho, e putchar('\n') mostra só a quebra. Os três dão o mesmo caractere.

Termine a saída com \n: o texto pode sumir

O C não manda cada letra para a tela na hora: ele junta o texto numa área de espera, o buffer (em inglês, "amortecedor"), e só "despeja" quando chega um \n ou quando o programa termina normalmente. É como o garçom que espera o pedido da mesa inteira antes de ir à cozinha: dá menos viagens.

O problema aparece quando o programa quebra antes de despejar. Para simular uma quebra, este programa chama abort() (de stdlib.h, "abortar"), que derruba o programa na hora, como um travamento:

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

int main(void) {
    printf("Salvando o arquivo...");
    abort();
}

$ gcc -std=c23 -Wall -Wextra buffer.c -o buffer
$ ./buffer
Abortado                   (imagem do núcleo gravada) ./buffer      « cadê o "Salvando"?

O printf rodou, mas o texto ficou preso no buffer e morreu junto com o programa. Agora, o mesmo programa com \n no fim do texto (buffer2.c):

$ ./buffer2
Salvando o arquivo...
Abortado                   (imagem do núcleo gravada) ./buffer2

O \n despejou o texto na tela antes da queda. Isso importa muito quando você estiver caçando um erro: se o programa cai e a última mensagem não aparece, você vai procurar o problema no lugar errado. Por isso, termine cada mensagem com \n. (Quando você quer mesmo ficar na mesma linha, como num printf("Nome: ") antes de ler o teclado, o C despeja sozinho antes de esperar a digitação; e há o fflush(stdout), "esvaziar a saída", que despeja na hora. A aula stdin, stdout e stderr conta os detalhes.)

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

int main(void) {
    printf("Salvando o arquivo...");
    abort();
}

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

int main(void) {
    printf("Salvando o arquivo...\n");
    abort();
}

3. A tabulação: \t

O \t é a tecla Tab dentro do texto. O terminal tem "paradas" de 8 em 8 colunas (na coluna 8, 16, 24…), como as marcas de uma régua, e o Tab pula até a próxima parada. Por isso ele serve para alinhar colunas:

#include <stdio.h>

int main(void) {
    printf("Produto\tQtd\tPreço\n");
    printf("Arroz\t2\t5\n");
    printf("Feijão\t1\t8\n");
    printf("Macarrão integral\t3\t4\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra tabela.c -o tabela
$ ./tabela
Produto	Qtd	Preço
Arroz	2	5
Feijão	1	8
Macarrão integral	3	4

As três primeiras linhas ficaram alinhadas: "Produto", "Arroz" e "Feijão" têm menos de 8 letras, e o Tab levou todas até a coluna 8. Mas "Macarrão integral" tem 17 letras: o Tab pulou para a parada seguinte, a 24, e a linha desalinhou. O \t é bom para tabelas simples, com textos curtos. Para alinhar de verdade, com a largura que você escolher, o printf tem os formatos de largura (%-20s, por exemplo), na aula Formatos do printf.

Um Tab parece vários espaços, mas é um caractere. O comando cat -A (mostrar All, tudo) desenha cada Tab como ^I e o fim de cada linha como $ (os acentos viram códigos estranhos, como M-CM-': é o jeito do cat -A mostrar os bytes do UTF-8):

$ ./tabela | cat -A
Produto^IQtd^IPreM-CM-'o$
Arroz^I2^I5$
FeijM-CM-#o^I1^I8$
MacarrM-CM-#o integral^I3^I4$

#include <stdio.h>

int main(void) {
    printf("Nome Nota\n");
    printf("Ana 9\n");
    printf("Bruno 7\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Nome\tNota\n");
    printf("Ana\t9\n");
    printf("Bruno\t7\n");
    return 0;
}

4. Aspas dentro do texto: \"

A aspa dupla fecha o texto. Então, para mostrar uma aspa dupla, escape-a: \". Veja o que acontece quando a Ana esquece:

#include <stdio.h>

int main(void) {
    printf("Ela disse "oi"\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra aspa.c -o aspa
aspa.c: In function ‘main’:
aspa.c:4:24: error: expected ‘)’ before ‘oi’
    4 |     printf("Ela disse "oi"\n");
      |           ~            ^~
      |                        )

Para o compilador, a aspa antes de oi fechou o texto "Ela disse ". Aí veio a palavra oi, solta, que não faz sentido ali: "esperava ) antes de oi". O conserto é escapar as duas aspas de dentro:

    printf("Ela disse \"oi\"\n");

Saída: Ela disse "oi". No editor do guia, o Clang diz só expected ')' e aponta, com uma nota, o ( que ficou sem par (to match this '(').

5. A barra invertida: \\ e o caminho do Windows

Se a barra invertida começa um escape, como mostrar uma barra de verdade? Escapando a própria barra: \\ vira uma \. Isso pega muita gente com os caminhos do Windows, que separam as pastas com barra invertida. Copie um caminho para dentro das aspas e veja:

#include <stdio.h>

int main(void) {
    printf("C:\novos\testes\n");
    printf("C:\pasta\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra caminho.c -o caminho
caminho.c: In function ‘main’:
caminho.c:5:24: warning: unknown escape sequence: ‘\p’
    5 |     printf("C:\pasta\n");
      |                        ^
$ ./caminho
C:
ovos	estes          « \n pulou a linha e \t virou um Tab!
C:pasta              « o \p "sumiu" com a barra

"C:\novos\testes\n"

O compilador leu C: + \n (quebra de linha) + ovos + \t (Tab) + estes. Sem aviso nenhum, porque \n e \t são escapes válidos: para ele, você quis isso mesmo.

warning: unknown escape sequence: ‘\p’

"Sequência de escape desconhecida: \p". Não existe escape \p; o gcc avisa e usa só o p, jogando a barra fora. No editor do guia: unknown escape sequence '\p' [-Wunknown-escape-sequence].

Dois jeitos de consertar:

(Quem vem do C++ ou do Python pode procurar as "strings cruas", em que a barra não é escape, como o R"(…)" do C++. O C não tem isso: em C, é \\ ou /.)

#include <stdio.h>

int main(void) {
    printf("Arquivo salvo em C:\Dados\notas.txt\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Arquivo salvo em \"C:\\Dados\\notas.txt\"\n");
    return 0;
}

6. O % no printf: %%

O % não é um escape da linguagem: para o C, "50%" é um texto normal. Mas para o printf ele é especial: marca uma lacuna, como %d (aula Saída com printf). Então, um % solto no texto do printf vira uma lacuna estranha:

#include <stdio.h>

int main(void) {
    printf("Desconto de 50% hoje!\n");
    printf("Juros: 2%\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra porcento.c -o porcento
porcento.c: In function ‘main’:
porcento.c:4:30: warning: ' ' flag used with ‘%o’ gnu_printf format [-Wformat=]
    4 |     printf("Desconto de 50% hoje!\n");
      |                              ^
porcento.c:4:30: warning: format ‘%ho’ expects a matching ‘int’ argument [-Wformat=]
    4 |     printf("Desconto de 50% hoje!\n");
      |                           ~~~^
      |                              |
      |                              int
porcento.c:5:22: warning: unknown conversion type character ‘\x0a’ in format [-Wformat=]
    5 |     printf("Juros: 2%\n");
      |                      ^~
$ ./porcento
Desconto de 50157770je!          « "% ho" virou uma lacuna, e entrou lixo no lugar
Juros: 2%

Que confusão! O printf leu % ho como uma lacuna: %, um espaço (que é uma opção de formato), h e o (a lacuna de número em octal). Como nenhum número foi passado, entrou um valor qualquer da memória (que muda de uma vez para outra), e o "ho" de "hoje" sumiu. Na segunda linha, %\n não é lacuna nenhuma (‘\x0a’ é o código do \n): o gcc avisa "caractere de conversão desconhecido". O resultado muda de um sistema para outro: no editor do guia, a primeira linha sai Desconto de 500je! e a segunda nem aparece.

Para o printf mostrar um %, escreva %%:

#include <stdio.h>

int main(void) {
    printf("Desconto de 50%% hoje!\n");
    printf("Desconto de %d%% hoje!\n", 30);
    puts("No puts, 100% é só 100%.");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra porcento2.c -o porcento2
$ ./porcento2
Desconto de 50% hoje!
Desconto de 30% hoje!
No puts, 100% é só 100%.

50%%

O printf troca %% por um %.

%d%%

Uma lacuna (%d, que recebe o 30) e logo depois um % de verdade.

puts("… 100% …")

O puts não tem lacunas, então o % vai sozinho. Se você escrever %% no puts, aparecem os dois.

7. Escapes por código e o \0

Todo caractere tem um número (o A é 65, aula Caracteres). Dá para escrever um caractere pelo número, de três jeitos:

#include <stdio.h>

int main(void) {
    printf("\x41\x6e\x61\n");
    printf("\101\156\141\n");
    printf("maçã e ma\u00e7\u00e3\n");
    printf("Preço: 10 \u20ac\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra codigos.c -o codigos
$ ./codigos
Ana
Ana
maçã e maçã
Preço: 10 €

\x41

Um byte pelo valor em hexadecimal (base 16, com os dígitos 0–9 e a–f): 41 em hexadecimal é 65, o A. \x6e é o n e \x61 é o a.

\101

O mesmo, em octal (base 8), com até 3 dígitos: 101 em octal também é 65. É por isso que \0 é o caractere de número 0.

\u00e7

Um caractere pelo código Unicode (a grande tabela que dá um número a cada caractere de todas as línguas): 00e7 é o ç, 00e3 é o ã, 20ac é o €. Sempre 4 dígitos hexadecimais (para códigos maiores, \U com 8). C99

Na prática, escreva os acentos direto, como no "maçã": é mais legível, e funciona porque o arquivo está em UTF-8 (aula Acentos e UTF-8). Os escapes por código servem para caracteres invisíveis ou difíceis de digitar.

O \0, a marca de fim

O \0 é o caractere de número zero. Você não o vê, mas ele está no fim de todo texto entre aspas: "Ana" guarda A, n, a e um \0 escondido, que avisa "o texto acabou aqui". Se você escrever um \0 no meio, quem lê o texto para ali:

$ cat nulo0.c
#include <stdio.h>

int main(void) {
    printf("abc\0def\n");
    printf("|\n");
    return 0;
}
$ gcc -std=c23 -Wall -Wextra nulo0.c -o nulo0
nulo0.c: In function ‘main’:
nulo0.c:4:16: warning: embedded ‘\0’ in format [-Wformat-contains-nul]
    4 |     printf("abc\0def\n");
      |                ^~
$ ./nulo0
abc|          « o "def\n" ficou depois da marca de fim: nem a linha pulou

O gcc até avisa: "\0 embutido no formato". Na prática, você quase nunca vai escrever um \0 num texto; o importante é reconhecê-lo. A aula Strings explica tudo sobre essa marca.

Os outros escapes

8. Textos compridos: pedaços lado a lado

Um texto entre aspas não pode quebrar de linha no código. Mas, se ele for comprido, dá para escrevê-lo em vários pedaços seguidos, sem nada entre eles: o compilador cola todos num só, antes de compilar.

#include <stdio.h>

int main(void) {
    printf("Atenção: este programa apaga arquivos. "
           "Confira a pasta antes de continuar.\n");
    printf("linha 1\n"
           "linha 2\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra juntos.c -o juntos
$ ./juntos
Atenção: este programa apaga arquivos. Confira a pasta antes de continuar.
linha 1
linha 2

"…arquivos. " "Confira…"

Dois textos vizinhos viram um só: "…arquivos. Confira…". É um texto só para o printf.

O espaço no fim do primeiro pedaço

O compilador cola os pedaços sem pôr nada no meio. Esqueça o espaço e as palavras grudam: arquivos.Confira.

Sem \n, sem quebra

Quebrar a linha no código não quebra a linha na tela. Para isso, coloque \n dentro dos pedaços, como no segundo printf.

Formas diferentes de pular a linha, e qual usar

Quando dá errado

$ gcc -std=c23 -Wall -Wextra xerro.c -o xerro           « printf("\xe7a\n");
xerro.c: In function ‘main’:
xerro.c:4:21: warning: hex escape sequence out of range
    4 |     printf("\xe7a\n");
      |                     ^

Referência rápida

Exercícios

Missão final: o recibo da lojinha

Lojinha "Da Ana"
Item	Preço
Caderno	R$ 12
Desconto: 10%
Recibo salvo em C:\Recibos

#include <stdio.h>

int main(void) {
    printf("Lojinha "Da Ana"\n");
    printf("Item    Preço\n");
    printf("Caderno R$ 12\n");
    printf("Desconto: 10%\n");
    printf("Recibo salvo em C:\Recibos\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Lojinha \"Da Ana\"\n");
    printf("Item\tPreço\n");
    printf("Caderno\tR$ 12\n");
    printf("Desconto: 10%%\n");
    printf("Recibo salvo em C:\\Recibos\n");
    return 0;
}

Resumo

• A barra invertida começa uma sequência de escape: \n (linha), \t (Tab), \", \', \\, \0. Cada uma vira um caractere.
• Termine as mensagens com \n: sem ele, o texto espera no buffer e pode sumir se o programa cair. fflush(stdout) despeja na hora.
• O \t pula até a próxima parada de 8 colunas: bom para tabelas com textos curtos.
• Caminhos do Windows entre aspas quebram: \n e \t viram especiais em silêncio, e escapes desconhecidos dão unknown escape sequence. Use \\ ou /.
• No printf, o % marca lacunas: para mostrar um, escreva %%.
• \x41, \101 e \u00e7 escrevem um caractere pelo código; os acentos podem ir direto no texto (UTF-8).
• Pedaços lado a lado ("a" "b") são colados pelo compilador: bom para textos compridos.
• Próximo passo: Lendo Erros do Compilador, para entender as mensagens que você viu nesta aula.