Windows no es un sistema operativo que cuenta con un buen soporte para la programación en C. Por razones que no quedan del todo claras, Microsoft se ha negado rotundamente a actualizar el soporte del compilador C de Visual Studio, el cual ha quedado estancado en el estándar C89.
Afortunadamente la comunidad Open Source viene al rescate con el proyecto Mingw-w64, que provee el compilador GCC, el debugger GDB, binutils, más las headers y bibliotecas necesarias para producir binarios nativos de Windows. Mingw-w64 es ampliamente utilizado y actualizado constantemente con las últimas versiones de GCC y tecnologías como OpenGL y DirectX.
Hay varias formas de obtener Mingw-w64, pero una de las mejores es usando MSYS2 (Minimal SYStem 2), una línea de comandos y entorno de programación que usaremos para instalar Mingw-w64.
1. Instalando MSYS2
Para comenzar, vamos a msys2.github.io y descargamos el instalador de 64 bits (el que dice “x86_64”) que nos permitirá compilar programas nativos de 32 y 64 bits. Abrimos el archivo y lo instalamos con todas las opciones por defecto. Si al final dejamos tildada la opción “Run MSYS2 now“, vamos a ver la consola de MSYS2 MSYS que luce de esta manera:
MSYS2 usa el gestor de paquetes pacman de Arch Linux para instalar y actualizar el paquetes. Hay que seguir las instrucciones en la página de MSYS2 para actualizar el entorno. Al momento de escribir este artículo (MSYS2 versión msys2-x86_64-20160921) hay que ingresar en la consola (atento a las mayúsculas):
Puede que en alguno de los siguientes pasos aparezca un mensaje pidiendo cerrar la consola. En ese caso debemos cerrar la ventana por la equis y volver a abrirla desde el menú inicio, buscando MSYS2 MSYS.
pacman -Sy pacman
pacman -Syu
pacman -Su
MSYS2 se instala por defecto en el directorio c:\msys64. En el menú inicio de Windows podremos ver que en la carpeta MSYS2 64bit aparecen 3 consolas, lo cual se presta a cierta confusión. Las tres abren una consola bash pero con diferentes variables de entorno establecidas para diferentes usos:
- MSYS2 MSYS: es la consola de MSYS que utilizaremos para correr pacman e instalar paquetes. Se puede compilar programas aquí pero los mismos dependerán de msys-2.0.dll, una capa de emulación POSIX. Basta decir que no utilizaremos ésta para compilar.
- MSYS2 MinGW 32bit: provee un entorno de programación para compilar programas nativos de Windows de 32 bits que dependen de MSVC runtime.
- MSYS2 MinGW 64bit: éste es el entorno de programación que usaremos para compilar programas nativos de Windows de 64 bits.
2. Instalando Mingw-w64
Ahora sí instalaremos Mingw-w64. MSYS2 sólo provee la consola bash y otras herramientas auxiliares, para obtener el compilador debemos instalar Mingw-w64.
Al momento de escribir este artículo había un bug en MSYS2 (versión msys2-x86_64-20160921, corregido en versiones posteriores) por lo tanto debemos ir al directorio C:\msys64 y crear dentro un directorio llamado “mingw64“.
Para descargar e instalar el paquete, abrimos la consola de MSYS2 MSYS e ingresamos:
pacman -S mingw-w64-x86_64-toolchain
Con esto hemos instalado dentro de MSYS2 la “toolchain” necesaria para compilar programas, que incluye binutils, make, pkg-config, y el compilador gcc.
Podemos cerrar la ventana de MSYS2 MSYS, ir al menú inicio y abrir la consola MSYS2 MinGW 64-bit (no MSYS2 MSYS). Si todo salió bien, al ingresar “gcc -v” veremos la versión del compilador:
Finalmente agregamos la ruta de MinGW al path de Windows. Para ello abrimos una consola de línea de comandos (Menú inicio -> cmd) e ingresamos setx path “%path%;C:\msys64\mingw64\bin”:
3. Instalando y configurando Visual Studio Code
Una vez instalado el paquete mingw-w64-x86_64-toolchain, es perfectamente posible compilar programas desde la consola de MSYS MinGW 64-bit, usando la interfaz de línea de comandos para invocar comandos como cc y make.
Sin embargo, si queremos un entorno mucho más amigable, podemos usar Visual Studio Code, el IDE de Microsoft que se presenta como la alternativa ligera y open source a Visual Studio.
Debemos ir a code.visualstudio.com, descargar el instalador y seguir las sencillas instrucciones. Luego debemos crear un directorio en nuestro disco que utilizaremos para el primer proyecto en C. A diferencia de Visual Studio, Visual Studio Code se basa en directorios y no en proyectos, por lo que debemos ir al menú Archivo -> Abrir carpeta y seleccionar el directorio vacío que creamos.
A continuación abrimos la Paleta de comandos (Ctrl + Shift + P), escribimos Extensiones: Instalar Extensiones y presionamos Enter. Esto nos abre el Panel de extensiones en el cual vamos a buscar cpptools, la extensión de Microsoft que agrega soporte para C y C++. Debemos instalarla (haciendo click en Instalar) y habilitarla (haciendo click en Recargar).
En el Explorador de archivos a la izquierda, creamos un archivo llamado hello.c en el cual ingresaremos el código del clásico Hello World:
Guardamos el archivo (Ctrl + S), hacemos click para poner un breakpoint en la línea 6, y luego situando el cursor en la línea 1, que aparece subrayada en verde, vemos que aparece un foco amarillo al cual haremos click para configurar el include path. Esto crea en nuestro directorio un archivo c_cpp_properties.json que indica a la extensión cpptools dónde están los headers de C. Debemos editar la sección Win32 de dicho archivo y cambiar el valor del includePath al directorio C:/msys64/mingw64/include (ingresar tal cual) Guardamos el archivo (Ctrl + S).
Para configurar la compilación del proyecto abrimos la Paleta de comandos (Ctrl + Shift + P) y buscamos Tareas: Configurar ejecutor de tareas, seleccionando la opción Otros. Esto crea un archivo tasks.json que editaremos de la siguiente manera:
Guardamos el archivo (Ctrl + S). Lo que hemos hecho aquí es decirle a Visual Studio Code dónde encontrar el compilador cc que instalamos previamente en MSYS2. Los parámetros indican agregar símbolos de depuración para gdb, el nombre de nuestro archivo de fuente y el nombre del archivo de salida.
Para compilar presionamos Ctrl + Shift + B, si todo salió bien veremos que nuestro ejecutable hello.exe aparece en el explorador de archivos. Sino aparecerá un mensaje de error en el panel Salida y debemos verificar si configuramos bien la ruta y los parámetros.
Finalmente ejecutaremos nuestro programa usando dbg, el clásico debugger de GNU. Debemos abrir la barra lateral de depuración (Ctrl + Shift + D o haciendo click en el insecto), luego hacer click en el icono de la rueda para configurar, y seleccionar la opción C++ (GDB/LLDB). Esto crea un archivo launch.json que editaremos para indicar las rutas de nuestro ejecutable y del debugger. En la configuración C++ Launch hay que editar la propiedad program y agregar la propiedad miDebuggerPath con la ruta de gdb, como se muetra a continuación:
Guardamos el archivo (Ctrl + S), y presionamos F5 o hacemos click en la flecha verde para ejecutar. Si todo salió bien, debe aparecer la consola de nuestro programa y veremos que Code se detiene en el breakpoint que establecimos anteriormente. La barra lateral muestra las variables locales, una sección de inspección y la pila de llamadas. Abajo aparece la consola de depuración que permite enviar comandos a gdb, y arriba está la barra para controlar la ejecución, con los mismos atajos de teclado que Visual Studio:
Como vemos, Visual Studio Code es un entorno muy agradable de usar y bastante completo, ya que a pesar de ser nuevo (apareció en 2015) se ha desarrollado con bastante rapidez. Perfecto para aprender y dar los primeros pasos programando en C bajo Windows.
Próximos pasos
Hemos configurado Visual Studio Code para compilar, ejecutar y depurar de forma visual y sencilla un programa con un sólo archivo fuente, usando directamente el compilador cc. El próximo paso que podrías seguir es editar el archivo tasks.json para usar make en vez de cc y poder compilar programas más complejos (en MinGW el ejecutable se llama mingw32-make.exe). ¿Puedes descubrir cómo?
Orlando Ramírez 
Tengo un problema, ya he instalado MSYS2 y mingw64 de manera exitosa, el problema esta en visual studio code, que no agarra el task de cc.exe, modifique el tasks.json tal cual y no genera el ejecutable hello.exe. Ayuda URGENTE por favor!!!
LikeLike
Hola ungarev, gracias por tu comentario. Debes agregar MinGW al path de Windows, he agregado las instrucciones para hacerlo en el paso 2. ¡Saludos!
LikeLike
Hola, antes que nada agradecer por tan buen tutorial, pero queria consultar algo pues tengo el mismo problema que el comentario anterior, estoy tratando de aplicar este tutorial pero con C++.
Asi que en vez de la ruta “C:/msys64/mingw64/bin/cc.exe” he colocado esta: “C:/msys64/mingw64/bin/cpp.exe”, pero igual no soluciono el problema. Agregado a eso no me aparece ningun error solo al darle “Depurar” me muestra un mensaje que dice “launch: program ‘c:\Users\SODA\Desktop\AUTO ESTUDIO\C++\HOLA.exe’ does not exist” pue slogicamente no me ha generado el ejecutable, Puedes ayudarme?? te anexo cada parte:
tasks.json //////////////////////////////////////////
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
“version”: “0.1.0”,
“command”: “C:/msys64/mingw64/bin/cpp.exe”,
“isShellCommand”: true,
“args”: [“-ggdb”, “HOLA.cpp”, “-o”, “HOLA”],
“showOutput”: “always”
}
c_cpp_properties.json : ///////////////////////////
{
“configurations”: [
{
“name”: “Mac”,
“includePath”: [
“/usr/include”,
“/usr/local/include”
],
“browse”: {
“limitSymbolsToIncludedHeaders”: true,
“databaseFilename”: “”
}
},
{
“name”: “Linux”,
“includePath”: [
“/usr/include”,
“/usr/local/include”
],
“browse”: {
“limitSymbolsToIncludedHeaders”: true,
“databaseFilename”: “”
}
},
{
“name”: “Win32”,
“includePath”:
[“C:/msys64/mingw64/include”],
“browse”: {
“limitSymbolsToIncludedHeaders”: true,
“databaseFilename”: “”
}
}
]
}
launch.json : //////////////////////////////////////
{
“version”: “0.2.0”,
“configurations”: [
{
“name”: “C++ Launch”,
“type”: “cppdbg”,
“request”: “launch”,
“program”: “${workspaceRoot}/HOLA.exe”,
“args”: [],
“stopAtEntry”: false,
“cwd”: “${workspaceRoot}”,
“environment”: [],
“externalConsole”: true,
“linux”: {
“MIMode”: “gdb”
},
“osx”: {
“MIMode”: “lldb”
},
“windows”: {
“MIMode”: “gdb”
},
“miDebuggerPath”: “C:/msys64/mingw64/bin/gdb.exe”
},
{
“name”: “C++ Attach (Windows)”,
“type”: “cppvsdbg”,
“request”: “attach”,
“processId”: “${command.pickProcess}”
}
]
}
Y para descartar ya probe usando el: “C:/msys64/mingw64/bin/cc.exe” y nada. Sigue sin generarme el ejecutable, ayuda porfa!
LikeLike
Hola Edgar, muchas gracias por comentar. He seguido los pasos en otra compu y me he dado cuenta que dejé afuera algo fundamental: ¡agregar MinGW al path de Windows! Ya corregí las instrucciones, tienes que abrir una consola (cmd.exe) e ingresar:
setx path “%path%;C:\msys64\mingw64\bin”
Si tenías abierto el Visual Studio Code reinícialo, compila con Ctrl + Shift + B y debe aparecer el archivo hello.exe en el explorador, entonces lo puedes ejecutar con F5.
Además, para C++ debes usar g++.exe en vez de cpp.exe.
¡Saludos!
LikeLike