---
title: "Como instalar um compilador C e C++ no Windows, Linux e macOS"
description: "Aprende a instalar o GCC com MSYS2 no Windows, build-essential no Linux e Xcode no macOS, incluindo comandos de compilação e setup do VS Code."
url: "https://www.alemasone.com/pt/instalar-compilador-c-cpp-windows-linux-macos/"
language: "pt"
published: 2024-07-20
updated: 2026-09-19
categories: ["Programação E Desenvolvimento"]
translations:
it: "https://www.alemasone.com/it/installare-gcc-windows-linux-macos/"
en: "https://www.alemasone.com/en/install-c-cpp-compilers-windows-linux-macos/"
es: "https://www.alemasone.com/es/instalar-compilador-c-cpp-windows-linux-macos/"
fr: "https://www.alemasone.com/fr/installer-compilateur-c-cpp-windows-linux-macos/"
de: "https://www.alemasone.com/de/c-cpp-compiler-installieren-windows-linux-macos/"
---
# Como instalar um compilador C e C++ no Windows, Linux e macOS
No Linux e macOS, o compilador instala-se com um comando. No Windows, hoje em dia, o caminho correto é através do **MSYS2**, que te dá o GCC via MinGW-w64 e o atualiza sozinho. O antigo MinGW do SourceForge, aquele com o Installation Manager que encontras em tantos tutoriais (inclusive na primeira versão deste), está parado há anos, só produz programas a 32 bits e já não deve ser usado.
O compilador transforma o código-fonte num programa executável. Para C e C++, os dois mais usados são: **GCC**, que anda por aí desde 1987 e está disponível em todo o lado, e o **[Clang](https://clang.llvm.org/)**, mais recente, com mensagens de erro mais claras e definido como padrão no macOS. A última versão do GCC é a 16, lançada em abril de 2026, que para C++ utiliza o padrão C++20 por defeito.
Abaixo encontras a instalação nos três sistemas, os comandos para compilar e a configuração do Visual Studio Code.
## Windows: MSYS2 e MinGW-w64
[MinGW-w64](https://www.mingw-w64.org/) é a versão do GCC que produz executáveis nativos para Windows. O MSYS2 é o ambiente que a distribui e mantém atualizada.
1. Descarrega o instalador no [sítio oficial do MSYS2](https://www.msys2.org/) e instala-o mantendo o caminho predefinido `C:\msys64`.
2. Ao terminar, abre-se um terminal MSYS2. Atualiza os pacotes base:
```bash
pacman -Syu
```
Se a janela se fechar durante a atualização, não te preocupes: volta a abrir através do menu Iniciar (**MSYS2 UCRT64**) e repete o comando até que não haja mais nada para atualizar.
3. Instala o grupo de ferramentas de compilação a 64 bits:
```bash
pacman -S mingw-w64-ucrt-x86_64-toolchain
```
Quando te perguntar quais pacotes instalar, prime Enter para selecionar todos e confirma com Y. Se também precisares do debugger, já está incluído: `gdb` faz parte do grupo.
4. Adiciona a pasta dos compiladores ao PATH do Windows, para que os possas usar de qualquer terminal. Procura por **Editar as variáveis de ambiente do sistema** no menu Iniciar (ou vai a **Definições** → **Sistema** → **Sobre** → **Definições avançadas do sistema**), prime em **Variáveis de Ambiente**, seleciona `Path` entre as variáveis de utilizador, depois **Editar** → **Novo** e escreve:
```text
C:\msys64\ucrt64\bin
```
5. Confirma com **OK** em todas as janelas, abre um **novo** Prompt de comando e verifica:
```bat
gcc --version
g++ --version
```
> **Também existem caminhos mais curtos.** O **[w64devkit](https://github.com/skeeto/w64devkit)** é um ficheiro único para descompactar, sem gestor de pacotes: prático se o usares apenas ocasionalmente. E se só precisares de aprender C no Windows, o [Subsistema Windows para Linux (WSL)](https://learn.microsoft.com/it-it/windows/wsl/) também serve perfeitamente: instalas o [Ubuntu](/pt/instalar-wine-ubuntu-programas-windows/) com `wsl --install` e segues a parte de Linux abaixo.
## Linux
No Debian, Ubuntu e derivados, tudo o que precisas está num único pacote:
```bash
sudo apt update
sudo apt install build-essential gdb
```
Inclui GCC, G++, make e as bibliotecas de desenvolvimento. No Fedora:
```bash
sudo dnf install gcc gcc-c++ make gdb
```
No Arch Linux:
```bash
sudo pacman -S base-devel gdb
```
Verifica com `gcc --version`. Não é preciso mais nada: os caminhos já estão configurados.
## macOS
No [Mac, o compilador padrão](/pt/virtualizacao-mac-apple-silicon-windows-linux/) é o Clang, que vem com as ferramentas de linha de comandos do Xcode. Instalas-as com este comando, que abre uma janela de confirmação:
```bash
xcode-select --install
```
A partir daí, os comandos `gcc` e `g++` existem, mas na verdade executam o Clang. Para aprender, não muda nada.
Se precisares mesmo do GCC, por exemplo para um projeto que o exija, instalas-no com o [Homebrew](https://brew.sh/):
```bash
brew install gcc
```
Os comandos chamar-se-ão `gcc-16` e `g++-16`, seguidos do número da versão, para não entrarem em conflito com os do sistema.
## Compilar pelo terminal
Os comandos são os mesmos em todo o lado, muda apenas o nome do ficheiro produzido.
Compilar um único ficheiro C:
```bash
gcc programma.c -o programma
```
Compilar C++, solicitando um padrão recente e todos os avisos (warnings):
```bash
g++ -std=c++20 -Wall -Wextra programma.cpp -o programma
```
Executar o resultado:
```bash
./programma
```
No Windows, pelo Prompt de comando, o executável chama-se `programma.exe` e corre ao escrever `programma`.
Opções que deves conhecer desde o início:
| Opção | O que faz |
|---------|---------|
| `-Wall -Wextra` | Mostra avisos: deteta erros que o compilador aceitaria silenciosamente |
| `-g` | Inclui informações de debug, necessárias para usar o debugger |
| `-O2` | Otimiza o código; deve ser usado para a versão final, não durante o desenvolvimento |
| `-std=c++20` | Define o padrão da linguagem, evitando surpresas entre computadores diferentes |
> **Com mais de três ficheiros, esquece a compilação manual.** Escreve um `Makefile` ou usa o [CMake](https://cmake.org/). Recompilar tudo a cada modificação faz-te perder tempo e, mais cedo ou mais tarde, esqueces-te de um ficheiro e passas meia hora num erro que nem existe.
## Configurar o Visual Studio Code
O Visual Studio Code não tem um compilador próprio: usa o que tiveres instalado. Bastam dois passos.
1. Instala a extensão **[C/C++](https://code.visualstudio.com/docs/languages/cpp)** da Microsoft através do painel de extensões. Em alternativa, tens o **[clangd](https://clangd.llvm.org/)**, que é mais rápido no preenchimento automático e nos avisos.
2. Abre a pasta do projeto e cria um ficheiro fonte. Prime F5: na primeira execução, o editor pergunta qual compilador queres usar e gera automaticamente os ficheiros `tasks.json` e `launch.json` na subpasta `.vscode`.
Se o compilador não aparecer na lista, no Windows a culpa costuma ser do PATH. Verifica se `gcc --version` funciona num novo terminal; depois, fecha e volta a abrir o editor por completo: ele só lê as variáveis de ambiente ao arrancar.
Para compilar sem o debugger, o terminal integrado (Ctrl + ò) aceita os mesmos comandos vistos acima.
## Erros frequentes
**`gcc non è riconosciuto come comando`** no Windows: a pasta `bin` não está na variável PATH, ou o terminal já estava aberto quando a adicionaste.
**`fatal error: iostream: No such file or directory`**: estás a compilar um ficheiro C++ com `gcc` em vez de usares `g++`.
**Tens dois GCC diferentes**: se ainda tiveres a versão antiga do `C:\MinGW\bin` no PATH, remove essa linha, caso contrário o Windows pode encontrar primeiro a versão antiga. O `where gcc` diz-te qual está a ser usada.
**`undefined reference to ...`**: a compilação foi bem-sucedida, mas falta a ligação a uma biblioteca ou a outro ficheiro fonte. Quando há mais do que um ficheiro, tens de indicar todos ou usar um sistema de build.
**O executável não corre noutro computador com Windows**: faltam as bibliotecas de runtime. Resolve isto compilando com `-static`, que as inclui no executável.
## Perguntas frequentes
### MinGW e MSYS2 são a mesma coisa?
Não. O MinGW-w64 é o conjunto de ferramentas que permite ao GCC gerar programas para Windows; o MSYS2 é o ambiente que os distribui, atualiza e fornece um terminal estilo Unix. Hoje em dia, instala-se o MSYS2 precisamente para obter o MinGW-w64 numa versão atualizada.
### GCC ou Clang: qual escolher?
Para aprender, ambos servem. O Clang é o que vem por defecto no macOS e tem mensagens de erro mais claras, o que ajuda bastante no início. O GCC é o padrão no Linux e encontras-no com mais frequência em projetos existentes. Muitos programadores usam os dois: compilar com dois compiladores diferentes faz aparecer erros que apenas um deixaria passar.
### Ainda posso usar o antigo MinGW do SourceForge?
Funciona, mas não é atualizado há anos, só cria programas a 32 bits e está desatualizado em relação aos padrões recentes de C++. Se já o tiveres instalado, desinstala-o, remove o `C:\MinGW\bin` do PATH e passa para o MSYS2.
### Posso compilar programas para Windows a partir do Linux?
Sim, instalando a versão cross-compiler do MinGW-w64, disponível como pacote nas principais distribuições. Compilas com `x86_64-w64-mingw32-gcc` e obténs um `.exe` funcional, útil para distribuir um programa sem precisares de um computador com Windows.
### Preciso do Visual Studio em vez do Visual Studio Code?
São coisas diferentes. O Visual Studio é um ambiente de desenvolvimento completo com o seu próprio compilador da Microsoft (MSVC), enquanto o Visual Studio Code é um editor que utiliza o compilador que tu lhe deres. Para aprender C e C++, o editor com GCC chega perfeitamente e é muito mais leve.
### Como se instala um debugger?
No Linux e com MSYS2, instalas o `gdb` juntamente com o compilador, como mostrado acima. No macOS, usa-se o `lldb`, que já está incluído nas ferramentas do Xcode. Em ambos os casos, o Visual Studio Code reconhece-o automaticamente quando gera a configuração de depuração.