C Olá, Mundo

Chegou a hora de escrever o seu primeiro programa em C. Ele é pequeno: só mostra a frase Olá, mundo! na tela. Mas, para chegar até ela, você vai fazer o caminho que todo programa em C faz: escrever o código num arquivo, compilar (transformar o texto em programa) e rodar. Nesta aula você entende cada pedacinho das seis linhas do programa, sem pular nenhum símbolo.

Todos os comandos desta aula foram executados na máquina fictícia da Ana (usuária ana, computador notebook), com o gcc 15.2 do Ubuntu 26.04, numa pasta chamada ~/c. As saídas foram copiadas da tela, sem mudar nada. Se você ainda não instalou o compilador, volte para Instalar no Linux (ou Windows e macOS). Se ainda não tem, você também pode fazer quase tudo no editor do guia, que compila e roda C de verdade no navegador (O Editor do Guia).

A ideia: a receita e o bolo

Pense numa receita de bolo escrita num papel. O papel não é o bolo: alguém precisa ler a receita e fazer o bolo. Em C é igual:

Depois que o bolo está pronto, você pode comê-lo sem a receita. E, se mudar a receita, precisa assar outro bolo: mudou o código, compile de novo. Guarde essa ideia, porque ela explica muitos tropeços do começo. O caminho completo, com pré-processador, compilador e ligador, está em Como o C Vira Programa; aqui você só precisa dos três passos: escrever, compilar, rodar.

1. Criar a pasta e o arquivo

Comece criando uma pasta só para os seus programas, para eles não se misturarem com fotos e documentos. No terminal:

$ mkdir c                « cria a pasta "c" dentro da sua pasta pessoal
$ cd c                   « entra nela

Os dois comandos não mostram nada quando dão certo: o terminal só volta a mostrar o prompt, agora com ~/c no fim. (mkdir e cd são comandos do terminal, não do C. Eles são explicados no Guia Bash.)

Agora crie o arquivo. Qualquer editor de texto serve (o VS Code, o Kate, o gedit… veja Editores e IDEs). Aqui vamos usar o nano, que roda dentro do próprio terminal e já vem no Ubuntu:

$ nano ola.c             « abre o nano com um arquivo novo chamado ola.c

O terminal vira um editor. No alto aparece GNU nano 8.7.1 e o nome ola.c; embaixo, [ Novo arquivo ] e uma lista de atalhos, como ^O Gravar e ^X Sair. O ^ quer dizer a tecla Ctrl. Digite o programa:

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
    return 0;
}

1. Digite as seis linhas exatamente como estão (a linha 2 fica em branco; na linha 4, quatro espaços antes do printf).
2. Aperte Ctrl + O (^O Gravar). Embaixo aparece Escrever para o arquivo: ola.c.
3. Aperte Enter para confirmar o nome. O nano responde [ Escrita 6 linhas ].
4. Aperte Ctrl + X (^X Sair) para voltar ao terminal.

Três cuidados ao salvar:

• A extensão é .c. Ela diz ao compilador e ao editor que o arquivo é código C. (Arquivos .h também são C, mas são outra coisa: aula Arquivos .h e .c.)
• Sem espaços e sem acentos no nome: ola.c, e não olá mundo.c. Funciona com espaços, mas você teria de usar aspas em todo comando.
• Digite, não copie e cole, pelo menos desta vez. Digitar faz você reparar em cada símbolo, e em C os símbolos importam.

Para conferir que o arquivo está na pasta certa e com o conteúdo certo, use ls (lista os arquivos) e cat (mostra o conteúdo):

$ ls
ola.c
$ cat ola.c
#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
    return 0;
}

2. O programa, linha por linha

São seis linhas, e cada símbolo tem uma função. Leia com calma; não precisa decorar nada agora, porque você vai escrever essas linhas tantas vezes que elas vão grudar sozinhas.

Linha 1: #include <stdio.h>

O C "puro" sabe muito pouco: ele nem sabe mostrar texto na tela. Isso fica na biblioteca padrão, um conjunto de ferramentas prontas que vem junto com o compilador, dividida em arquivos chamados cabeçalhos (headers, com a extensão .h). A linha 1 pede: "antes de compilar, cole aqui o cabeçalho stdio.h".

#include

O # marca uma instrução para o pré-processador, um ajudante que prepara o arquivo antes do compilador. include = "incluir": copia o conteúdo de outro arquivo para dentro deste, naquele ponto. Linhas com # não terminam com ;. (O pré-processador tem aula própria: Pré-processador.)

<stdio.h>

O nome do cabeçalho. stdio vem de standard input/output, "entrada e saída padrão" (pronuncia-se "estê-dê-í-ó"). Ele traz o printf, que mostra texto, e outras funções de entrada e saída, como o scanf (aula Entrada com scanf). Os sinais < > dizem "procure este arquivo nas pastas do sistema", onde fica a biblioteca padrão.

Linha 2: a linha em branco

Não faz nada. Ela só separa o "material que eu trouxe" do "programa", para ficar mais fácil de ler. O compilador ignora linhas em branco (mais sobre isso em Sintaxe).

Linha 3: int main(void) {

Aqui começa o programa de verdade. Todo programa em C tem uma função chamada main ("principal"). Uma função é um bloco de instruções com nome. Quando você roda o programa, o sistema procura a main e executa o que está dentro dela, de cima para baixo. Sem main, não existe programa (você vai ver o erro no fim da aula).

int

De integer, "inteiro". Diz que a main, quando terminar, entrega um número inteiro ao sistema: o código de saída, que avisa se o programa deu certo. Você vai vê-lo na seção 6.

main

O nome da função. Tem de ser exatamente main, tudo em minúsculas: Main ou MAIN não servem (a aula Sintaxe mostra o erro).

(void)

Os parênteses guardam o que a função recebe. void quer dizer "vazio": esta main não recebe nada. Em Argumentos da Linha de Comando você vai ver uma main que recebe coisas.

{

A chave de abertura: "aqui começa o corpo da main". Tudo até a chave de fechamento } correspondente pertence a ela.

Linha 4: printf("Olá, mundo!\n");

Esta é a linha que faz alguma coisa: manda o texto para a tela. Ela tem recuo (quatro espaços no começo) porque está dentro da main. O recuo não é obrigatório, mas ajuda muito a ler.

printf

De print formatted, "imprimir formatado" (pronuncia-se "print-éf"). É uma função da biblioteca padrão, que veio com o stdio.h: ela mostra na tela o texto que você der a ela. "Imprimir", em programação, quase sempre quer dizer "mostrar na tela", não "mandar para a impressora". O "formatado" é porque ele também sabe encaixar números no meio do texto (aula Saída com printf).

( )

Os parênteses depois do nome chamam a função: "printf, faça o seu trabalho com isto aqui dentro". O que vai entre eles se chama argumento.

"Olá, mundo!\n"

O texto, entre aspas duplas. As aspas dizem ao compilador "isto é texto para mostrar, não é código", e não aparecem na tela. Um texto entre aspas se chama string (aula Strings). No fim dele, o \n (barra invertida + n, de new line) é a quebra de linha: não aparece como "\n" na tela, faz o cursor pular para a linha de baixo. Sem ele, o prompt do terminal gruda no seu texto (aula Novas Linhas e Escapes).

;

O ponto e vírgula termina a instrução, como o ponto final de uma frase. Esquecê-lo é o erro número um de quem começa, e você vai vê-lo no fim desta aula.

Linha 5: return 0;

return = "devolver". Termina a main e entrega o número 0 ao sistema, que quer dizer "terminei sem problemas". A seção 6 mostra esse número chegando ao terminal.

Linha 6: }

A chave de fechamento: "acabou a main". Toda { precisa de uma }, como parênteses numa conta.

3. Compilar: de texto para programa

O arquivo ola.c é só texto. O computador não sabe rodá-lo. Quem transforma o texto em programa é o compilador gcc (de GNU Compiler Collection, a coleção de compiladores do projeto GNU):

$ gcc ola.c -o ola
$                        « nada! no mundo dos compiladores, silêncio = deu certo

O gcc não diz "pronto" nem "sucesso". Se ele não reclamou, compilou. Repare que agora há um arquivo novo na pasta:

$ ls
ola  ola.c               « "ola" é o programa (no terminal, ele aparece em verde: é executável)

gcc

O compilador.

ola.c

O arquivo de código que ele vai ler (a receita).

-o ola

-o de output, "saída": o nome do programa que ele vai criar (o bolo). Pode ser qualquer nome; usar o mesmo nome do arquivo, sem o .c, é o costume.

Este é o comando mínimo. Na próxima aula, Compilar com gcc, você vai acrescentar opções que escolhem a versão do C e fazem o compilador avisar sobre erros prováveis. A partir dela, o guia usa sempre o comando completo: gcc -std=c23 -Wall -Wextra ola.c -o ola.

4. Rodar o programa

Para rodar um programa que está na pasta atual, escreva ./ e o nome dele:

$ ./ola
Olá, mundo!

Pronto: esse é o seu primeiro programa em C funcionando. As aspas não apareceram, o \n virou uma quebra de linha e o prompt voltou na linha de baixo, como deveria.

Por que ./?

Quando você digita um nome solto, como ls ou gcc, o terminal procura o programa numa lista fixa de pastas do sistema (a variável PATH). A sua pasta ~/c não está nessa lista, por segurança. O . quer dizer "a pasta onde estou agora" e a / separa a pasta do arquivo. Então ./ola é "o programa ola que está aqui". Sem o ./:

$ ola
bash: ola: comando não encontrado

O terminal procurou um comando ola nas pastas do sistema e não achou. Não é um erro do C: o programa está lá, só faltou dizer onde.

Agora é a sua vez. O editor abaixo compila e roda C de verdade no navegador (a primeira vez demora alguns segundos, porque ele baixa o compilador). Ele faz os passos 3 e 4 de uma vez quando você clica em Rodar.

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Olá, Ana!\n");
    return 0;
}

Repare na primeira linha que o editor mostra: $ clang -std=c23 -Wall -Wextra programa.c -o programa. O editor usa o Clang, outro compilador de C, em vez do gcc, e já com as opções completas da próxima aula. O resultado é o mesmo.

5. Sem o -o: o famoso a.out

O -o ola é opcional. Se você não disser o nome do programa, o gcc escolhe um sozinho: a.out.

$ gcc ola.c
$ ls
a.out  ola  ola.c        « apareceu o a.out
$ ./a.out
Olá, mundo!

O a.out é um programa igualzinho ao ola, só com outro nome. Os dois têm até o mesmo tamanho:

$ ls -l
total 36
-rwxrwxr-x 1 ana ana 15952 out 17 10:30 a.out
-rwxrwxr-x 1 ana ana 15952 out 17 10:30 ola
-rw-rw-r-- 1 ana ana    83 out 17 10:30 ola.c

Repare nos tamanhos: as 6 linhas de texto ocupam 83 bytes; o programa pronto, 15952 bytes (cerca de 16 KB). Ele contém o código traduzido para a linguagem do processador e as informações que o sistema precisa para carregá-lo. E o x em -rwxrwxr-x quer dizer "executável": o gcc já cria o programa com permissão para rodar.

6. O return 0; e o código de saída

Todo programa, quando termina, entrega um número ao sistema: o código de saída. Na main, quem escolhe esse número é o return:

return

"Devolver". Termina a função e entrega um valor para quem a chamou. No caso da main, quem chamou foi o sistema operacional.

0

O valor entregue. Por convenção, 0 = "terminei sem problemas"; qualquer outro número = "algo deu errado" (cada programa escolhe o que cada número significa).

;

Como toda instrução, termina com ponto e vírgula.

No terminal, o código de saída do último programa fica guardado em $?. Veja com echo (o comando que mostra um texto):

$ ./ola
Olá, mundo!
$ echo $?
0                        « o 0 do return 0;

Para ver que o número chega mesmo ao sistema, devolva outro valor:

#include <stdio.h>

int main(void) {
    printf("Saindo com 3\n");
    return 3;
}

$ gcc saida3.c -o saida3
$ ./saida3
Saindo com 3
$ echo $?
3                        « o 3 do return chegou ao terminal

Para que serve isso? Scripts e outros programas usam o código de saída para saber se o seu programa deu certo. O próprio gcc faz isso: quando a compilação falha, ele sai com o código 1 (você vai ver na seção "Quando dá errado"). O editor do guia mostra o código de saída embaixo da saída do programa, como [código de saída: 0].

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Até logo!\n");
    return 7;
}

E se eu esquecer o return 0;?

Na main, e só nela, nada de ruim acontece. Desde o C99, a regra é: se a main chegar ao } final sem return, o C age como se lá estivesse return 0;.

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
}

$ gcc semreturn.c -o semreturn
$ ./semreturn
Olá, mundo!
$ echo $?
0                        « mesmo sem return, deu 0

No C antigo (C89, de 1989), essa regra não existia. Compilando o mesmo arquivo como C89, o código de saída vira um número qualquer:

$ gcc -std=c89 semreturn.c -o semreturn89
$ ./semreturn89
Olá, mundo!
$ echo $?
13                       « lixo: por acaso, o número de bytes que o printf escreveu

7. Mostrar mais de uma linha

A main pode ter quantas instruções você quiser. Elas rodam uma depois da outra, de cima para baixo, cada uma terminada com ;:

#include <stdio.h>

int main(void) {
    printf("Olá! Eu sou a Ana.\n");
    printf("Estou aprendendo C.\n");
    printf("Este é o meu primeiro programa.\n");
    return 0;
}

$ gcc apresentacao.c -o apresentacao
$ ./apresentacao
Olá! Eu sou a Ana.
Estou aprendendo C.
Este é o meu primeiro programa.

Cada \n fecha uma linha. O que acontece se tirar um deles está em Novas Linhas e Escapes. Mostrar números junto com o texto (printf("Idade: %d\n", 29);) está em Saída com printf.

Outras formas de escrever o Olá, mundo

Você vai encontrar o mesmo programa escrito de jeitos diferentes. Todos funcionam no gcc 15:

Qual usar? A primeira, por enquanto. Ela é a mais clara e não depende da versão do C.

Quando dá errado

Errar faz parte. Um erro de compilação não estraga nada: o gcc só se recusa a criar o programa até você consertar. Estes são os tropeços mais comuns da primeira vez.

$ ola
bash: ola: comando não encontrado

$ ./ola
bash: ./ola: Arquivo ou diretório inexistente

$ gcc ole.c -o ola
cc1: fatal error: ole.c: Arquivo ou diretório inexistente
compilation terminated.

$ gcc ola.c -o ola.c
gcc: fatal error: input file ‘ola.c’ is the same as output file
compilation terminated.

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n")
    return 0;
}

$ gcc semponto.c -o semponto
semponto.c: In function ‘main’:
semponto.c:4:28: error: expected ‘;’ before ‘return’
    4 |     printf("Olá, mundo!\n")
      |                            ^
      |                            ;
    5 |     return 0;
      |     ~~~~~~
$ echo $?
1                        « o gcc avisa que falhou: código 1

int main(void) {
    printf("Olá, mundo!\n");
    return 0;
}

$ gcc seminclude.c -o seminclude
seminclude.c: In function ‘main’:
seminclude.c:2:5: error: implicit declaration of function ‘printf’ [-Wimplicit-function-declaration]
    2 |     printf("Olá, mundo!\n");
      |     ^~~~~~
seminclude.c:1:1: note: include ‘<stdio.h>’ or provide a declaration of ‘printf’
  +++ |+#include <stdio.h>
    1 | int main(void) {
seminclude.c:2:5: warning: incompatible implicit declaration of built-in function ‘printf’ [-Wbuiltin-declaration-mismatch]
    2 |     printf("Olá, mundo!\n");
      |     ^~~~~~
seminclude.c:2:5: note: include ‘<stdio.h>’ or provide a declaration of ‘printf’

$ cat semmain.c
#include <stdio.h>
$ gcc semmain.c -o semmain
/usr/bin/x86_64-linux-gnu-ld.bfd: /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o: na função "_start":
(.text+0x1b): referência não definida para "main"
collect2: error: ld returned 1 exit status

Referência rápida

Exercícios

Missão final: o cartão de visita

Ana Souza
Programadora C
Recife - PE

// escreva o programa inteiro aqui

#include <stdio.h>

int main(void) {
    printf("Ana Souza\n");
    printf("Programadora C\n");
    printf("Recife - PE\n");
    return 0;
}

Resumo

• Programar em C tem três passos: escrever o código (ola.c), compilar (gcc ola.c -o ola) e rodar (./ola). Mudou o código? Compile de novo.
• #include <stdio.h> traz o printf; int main(void) { … } é onde o programa começa; printf("…"); mostra texto; \n quebra a linha; ; termina a instrução.
• O gcc não diz nada quando dá certo. Silêncio = compilou.
• Programas da pasta atual rodam com ./ na frente.
• Sem -o, o programa se chama a.out, e cada compilação sobrescreve o anterior.
• return 0; entrega o código de saída 0 ("deu certo"), que aparece com echo $?. Desde o C99 ele é opcional só na main; o guia o escreve sempre.
• Próximo passo: Compilar com gcc, onde você aprende o comando completo que o guia usa daqui para a frente.