---
title: "Cómo instalar un compilador C y C++ en Windows, Linux y macOS"
description: "Aprende a instalar GCC con MSYS2 en Windows, build-essential en Linux y Xcode en macOS. Incluye comandos de compilación y configuración en VS Code."
url: "https://www.alemasone.com/es/instalar-compilador-c-cpp-windows-linux-macos/"
language: "es"
published: 2024-07-20
updated: 2026-09-19
categories: ["Programación Y Desarrollo"]
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/"
fr: "https://www.alemasone.com/fr/installer-compilateur-c-cpp-windows-linux-macos/"
pt: "https://www.alemasone.com/pt/instalar-compilador-c-cpp-windows-linux-macos/"
de: "https://www.alemasone.com/de/c-cpp-compiler-installieren-windows-linux-macos/"
---
# Cómo instalar un compilador C y C++ en Windows, Linux y macOS
En Linux y macOS el compilador se instala con un comando. En Windows, hoy en día, la mejor opción es **MSYS2**, que te ofrece GCC a través de MinGW-w64 y lo actualiza automáticamente. El antiguo MinGW de SourceForge, ese que tiene el Installation Manager que aparece en tantas guías (incluso en la primera versión de esta), se quedó estancado hace años, solo genera programas de 32 bits y ya no debería usarse.
El compilador transforma el código fuente en un programa ejecutable. Para C y C++ los más usados son dos: **GCC**, disponible desde 1987 y presente en todas partes, y **[Clang](https://clang.llvm.org/)**, más moderno, con mensajes de error más claros y predeterminado en macOS. La última versión de GCC es la 16, lanzada en abril de 2026, que para C++ utiliza el estándar C++20 por defecto.
A continuación encontrarás la instalación para los tres sistemas, los comandos para compilar y la configuración de Visual Studio Code.
## Windows: MSYS2 y MinGW-w64
[MinGW-w64](https://www.mingw-w64.org/) es la versión de GCC que genera ejecutables nativos para Windows. MSYS2 es el entorno que lo distribuye y lo mantiene actualizado.
1. Descarga el instalador desde el [sitio oficial de MSYS2](https://www.msys2.org/) e instálalo dejando la ruta predefinida `C:\msys64`.
2. Al finalizar se abrirá una terminal de MSYS2. Actualiza los paquetes base:
```bash
pacman -Syu
```
Si la ventana se cierra durante la actualización, no te preocupes: ábrela de nuevo desde el menú Inicio (**MSYS2 UCRT64**) y repite el comando hasta que ya no haya nada más que actualizar.
3. Instala el grupo de herramientas de compilación de 64 bits:
```bash
pacman -S mingw-w64-ucrt-x86_64-toolchain
```
Cuando te pregunte qué paquetes instalar, pulsa Enter para seleccionarlos todos y luego confirma con Y. Si también necesitas el depurador, ya viene incluido: `gdb`forma parte del grupo.
4. Añade la carpeta de los compiladores al PATH de Windows para poder usarlos desde cualquier terminal. Busca **Editar las variables de entorno del sistema** en el menú Inicio (o ve a **Configuración** → **Sistema** → **Acerca de** → **Configuración avanzada del sistema**), pulsa **Variables de entorno**, selecciona `Path` entre las variables de usuario, luego **Nueva** → **Crear variable** y escribe:
```text
C:\msys64\ucrt64\bin
```
5. Confirma con **Aceptar** en todas las ventanas, abre un **nuevo** Símbolo del sistema y comprueba:
```bat
gcc --version
g++ --version
```
> **También hay caminos más cortos.** **[w64devkit](https://github.com/skeeto/w64devkit)** es un archivo único para descomprimir, sin gestor de paquetes: muy cómodo si lo usas de vez en cuando. Y si solo quieres aprender C en Windows, el [Subsistema de Windows para Linux](https://learn.microsoft.com/it-it/windows/wsl/) también te viene genial: instalas [Ubuntu](/es/instalar-wine-ubuntu-programas-windows/) con `wsl --install` y sigues la parte de Linux que aparece abajo.
## Linux
En Debian, Ubuntu y sus derivadas, todo lo necesario está en un único paquete:
```bash
sudo apt update
sudo apt install build-essential gdb
```
Incluye GCC, G++, make y las librerías de desarrollo. En Fedora:
```bash
sudo dnf install gcc gcc-c++ make gdb
```
En Arch Linux:
```bash
sudo pacman -S base-devel gdb
```
Comprueba con `gcc --version`. No hace falta nada más: las rutas ya están configuradas.
## macOS
En [Mac, el compilador por defecto](/es/virtualizacion-mac-apple-silicon-windows-linux/) es Clang, que viene con las herramientas de línea de comandos de Xcode. Las instalas con este comando, que abrirá una ventana de confirmación:
```bash
xcode-select --install
```
A partir de ahí, los comandos `gcc` y `g++` existen, pero en realidad ejecutan Clang. Para aprender no cambia nada.
Si necesitas GCC específicamente, por ejemplo para un proyecto que lo requiera, puedes instalarlo con [Homebrew](https://brew.sh/):
```bash
brew install gcc
```
Los comandos se llamarán `gcc-16` y `g++-16`, incluyendo el número de versión, para que no entren en conflicto con los del sistema.
## Compilar desde la terminal
Los comandos son los mismos en cualquier sitio, solo cambia el nombre del archivo generado.
Compilar un único archivo C:
```bash
gcc programma.c -o programma
```
Compilar C++, solicitando un estándar reciente y todos los avisos (warnings):
```bash
g++ -std=c++20 -Wall -Wextra programma.cpp -o programma
```
Ejecutar el resultado:
```bash
./programma
```
En Windows, desde el Símbolo del sistema, el ejecutable se llama `programma.exe` y se lanza escribiendo `programma`.
Opciones que debes conocer desde el principio:
| Opción | Qué hace |
|---------|---------|
| `-Wall -Wextra` | Muestra los avisos (warnings): detectan errores que el compilador aceptaría sin decir nada |
| `-g` | Incluye la información de depuración, necesaria para usar el depurador |
| `-O2` | Optimiza el código; debe usarse para la versión final, no mientras estás desarrollando |
| `-std=c++20` | Establece el estándar del lenguaje, evitando sorpresas entre ordenadores distintos |
> **Si tienes más de tres archivos, olvídate de compilar a mano.** Escribe un `Makefile` o usa [CMake](https://cmake.org/). Recompilar todo cada vez que haces un cambio te hará perder tiempo y, tarde o temprano, olvidarás algún archivo y pasarás media hora buscando un error que no existe.
## Configurar Visual Studio Code
Visual Studio Code no tiene compilador propio: utiliza el que hayas instalado. Solo necesitas dos pasos.
1. Instala la extensión **[C/C++](https://code.visualstudio.com/docs/languages/cpp)** de Microsoft desde el panel de extensiones. Como alternativa tienes **[clangd](https://clangd.llvm.org/)**, que es más rápido en el autocompletado y en las notificaciones de errores.
2. Abre la carpeta del proyecto y crea un archivo fuente. Pulsa F5: la primera vez que lo ejecutes, el editor te preguntará qué compilador quieres usar y generará automáticamente los archivos `tasks.json` y `launch.json` en la subcarpeta `.vscode`.
Si el compilador no aparece en la lista, en Windows el culpable suele ser el PATH. Comprueba que `gcc --version` funcione en una nueva terminal; después, cierra y vuelve a abrir el editor por completo: solo lee las variables de entorno al iniciarse.
Para compilar sin el depurador, la terminal integrada (Ctrl + ò) acepta los mismos comandos que hemos visto antes.
## Errores frecuentes
**`gcc non è riconosciuto come comando`** en Windows: la carpeta `bin` no está en la variable PATH, o bien la terminal ya estaba abierta cuando la añadiste.
**`fatal error: iostream: No such file or directory`**: estás compilando un archivo C++ con `gcc` en lugar de usar `g++`.
**Tienes dos versiones de GCC distintas**: si todavía tienes la versión antigua de `C:\MinGW\bin` en el PATH, elimina esa línea; de lo contrario, Windows podría encontrar primero la versión vieja. `where gcc` te indica cuál se está utilizando.
**`undefined reference to ...`**: la compilación ha terminado correctamente, pero falta el enlace a una librería o a otro archivo fuente. Cuando hay más de un archivo, hay que indicarlos todos o utilizar un sistema de construcción (build system).
**El ejecutable no funciona en otro ordenador con Windows**: faltan las librerías de tiempo de ejecución (runtime). Se soluciona compilando con `-static`, que las incluye dentro del ejecutable.
## Preguntas frecuentes
### ¿MinGW y MSYS2 son lo mismo?
No. MinGW-w64 es el conjunto de herramientas que permite a GCC generar programas para Windows; MSYS2 es el entorno que los distribuye, los actualiza y proporciona una terminal estilo Unix. Hoy en día se instala MSYS2 precisamente para obtener MinGW-w64 en su versión más actualizada.
### ¿GCC o Clang: cuál elegir?
Para aprender, ambos sirven. Clang es el que viene por defecto en macOS y ofrece mensajes de error más claros, algo que ayuda mucho al principio. GCC es el estándar en Linux y lo encontrarás con más frecuencia en proyectos existentes. Muchos desarrolladores usan ambos: compilar con dos compiladores distintos puede revelar errores que uno solo dejaría pasar.
### ¿Puedo seguir usando el viejo MinGW de SourceForge?
Funciona, pero no se actualiza desde hace años, solo genera programas de 32 bits y se ha quedado atrás respecto a los estándares modernos de C++. Si ya lo tienes instalado, desinstálalo, elimina `C:\MinGW\bin` del PATH y pásate a MSYS2.
### ¿Puedo compilar programas para Windows desde Linux?
Sí, instalando la versión cruzada (cross-version) de MinGW-w64, disponible como paquete en las principales distribuciones. Se compila con `x86_64-w64-mingw32-gcc` y se obtiene un `.exe` funcional, lo cual es muy útil para distribuir un programa sin necesidad de tener un ordenador con Windows.
### ¿Es necesario Visual Studio en lugar de Visual Studio Code?
Son cosas distintas. Visual Studio es un entorno de desarrollo completo (IDE) con su propio compilador de Microsoft (MSVC), mientras que Visual Studio Code es un editor que utiliza el compilador que tú le indiques. Para aprender C y C++, el editor con GCC es suficiente y mucho más ligero.
### ¿Cómo se instala un depurador?
En Linux y con MSYS2, se instala `gdb` junto con el compilador, como hemos visto arriba. En macOS se utiliza `lldb`, que ya viene incluido en las herramientas de Xcode. En ambos casos, Visual Studio Code lo reconoce automáticamente cuando genera la configuración de inicio (launch configuration).