Compilando programas em C

Neste capítulo, vamos aprender a compilar e executar programas com um único arquivo e projetos na linguagem C.

No terminal, abra a pasta dev que criamos anteriormente para guardar nossos projetos.

1
mkdir -p ~/dev
2
cd ~/dev

Dentro dela, crie um diretório chamado c_cpp_projects e navegue para dentro dele.

1
mkdir -p c_cpp_projects
2
cd c_cpp_projects

Programa

Crie um outro diretório chamado `hello_world e também navegue para dentro nele.

1
mkdir -p hello_world
2
cd hello_world

Crie um arquivo chamado hello_world.c.

1
touch hello_world.c

Abra o Visual Studio Code neste diretório.

1
code .

Copie o seguinte código para o arquivo hello_world.c. Lembre-se de salvar o arquivo.

1
#include <stdio.h>
2

3
int main() {
4
  printf("Hello, world!\nThis is my first code in C.\n");
5
  return 0;
6
}

Vamos utilizar o Clang para compilar o código. O comando de compilação do Clang tem a seguinte estrutura:

1
clang [opções] <arquivo>.c -include -o <executável>

[opções] são os argumentos de compilação, como:
- -o <arquivo> para especificar o arquivo de saída;
- -include para incluir um arquivo de cabeçalho;
- -g para incluir informações de debug;
- entre outras.
<arquivo>.c é o nome do arquivo que será compilado.
<executável> é o nome do arquivo executável de saída.

Assim, com o terminal aberto na pasta ~/dev/c_cpp_projects/hello_world, execute:

1
clang hello_world.c -o hello_world

Se tudo ocorrer bem, um arquivo executável será criado. Ele se chamará apenas hello_world. Diferentemente do Windows, em que o executável tem a extensão .exe, no Linux não é necessário adicionar nenhuma extensão ao arquivo executável.

Terminal exibindo três comandos executados. O primeiro é "ls" e mostra o arquivo "hello_world.c" dentro da pasta "hello_world". O segundo é o de compilação, que não retorna nenhum texto. O terceiro é "ls" novamente, que agora mostra os arquivos "hello_world.c" e "hello_world". — Compilação do arquivo "hello_world.c".

Para executar o programa, basta chamar o arquivo executável.

1
./hello_world

Terminal exibindo o comando "./hello_world" e a saída do programa, que é "Hello, world! This is my first code in C.". — Execução do programa "hello_world".

Projeto

Retorne para a pasta c_cpp_projects.

1
cd ~/dev/c_cpp_projects

Crie um novo diretório chamado separate_function e navegue para dentro dele.

1
mkdir -p separate_function
2
cd separate_function

Crie um arquivo chamado main.c. Então abra o Visual Studio Code no diretório atual.

1
touch main.c
2
code .

Copie o seguinte código para o arquivo main.c.

1
#include <stdio.h>
2

3
int sum(int a, int b);
4

5
int main() {
6
    int a = 5, b = 7;
7
    int result = sum(a, b);
8
    printf("The sum of %d and %d is %d.\n", a, b, result);
9
    return 0;
10
}

Crie um outro arquivo chamado functions.c e cole nele o código a seguir.

1
int sum(int a, int b) { return a + b; }

A função principal main chama a função sum, que está definida em outro arquivo. Então, para fazer a compilação, precisamos passar os dois arquivos para o compilador. Internamente, o compilador fará a compilação de cada arquivo separadamente e, em seguida, fará a ligação entre eles.

Para compilar o projeto, execute o comando abaixo no terminal. Definimos os arquivos de entrada main.c e functions.c. Então, usamos a opção -o para especificar o nome do arquivo de saída, que será um executável.

1
clang main.c functions.c -o separate_function
2
./separate_function

Terminal exibindo quatro comandos executados. O primeiro é "ls" e mostra os arquivos "functions.c" e "main.c" dentro da pasta "separate_function". O segundo é o de compilação, que não retorna nenhum texto. O terceiro é "ls" novamente, que agora mostra os arquivos "functions.c", "main.c" e "separate_function". O quarto é a execução do programa, que retorna "The sum of 5 and 7 is 12.". — Compilação do projeto "separate_function".

Git

Podemos usar o Git para versionar nossos projetos. Para isso, precisamos inicializar o repositório Git no diretório do projeto. Faça isso com o comando abaixo.

1
git init

É interessante também criar um arquivo chamado .gitignore para que arquivos privados ou desnecessários não sejam enviados para o repositório. Um desses arquivos é o executável que acabamos de criar.

Crie o arquivo .gitignore e adicione o nome do executável separate_function dentro dele.

1
echo "separate_function" >> .gitignore

Então, precisamos adicionar os arquivos ao repositório, o que comumente é chamado de staging. O comando abaixo adiciona todos os arquivos do diretório atual, exceto aqueles que estão listados no arquivo .gitignore.

1
git add .

Podemos verificar quais arquivos foram adicionados com o comando abaixo.

1
git status
2
# On branch main
3

4
# No commits yet
5

6
# Changes to be committed:
7
#   (use "git rm --cached <file>..." to unstage)
8
#   new file:   .clang-format
9
#   new file:   .clang-tidy
10
#   new file:   .gitignore
11
#   new file:   functions.c
12
#   new file:   main.c

Por fim, faremos o commit dos arquivos com a mensagem Initialize project. Para definir a mensagem, usamos a opção -m seguida do texto entre aspas.

1
git commit -m "Initialize project"

Podemos verificar o histórico de commits com o comando abaixo.

1
git log
2
# commit 45b6e7e35917c5ccace23370cae78f0bbf61d3b2 (HEAD -> main)
3
# Author: Gabriel Malosto <gabriel@email.com>
4
# Date:   Mon Apr 28 00:51:26 2025 -0300
5

6
#   Initialize project
7
# (END)

O log abre um ambiente de leitura, em que podemos navegar pelas mensagens de commit. Para sair dele, pressione q q .