Etiquetas

Integrando VSCode, Mingw-w64 y CMake (Parte III)

Lecturas de la serie
Sobre este artículo
     Tiempo estimado de instalación y configuración: 20 minutos
     Nivel: Básico
     Última actualización: 1 de agosto, 2026

1. Instalación de bibliotecas no estándar

Aunque la biblioteca estándar de C++ proporciona un amplio conjunto de funcionalidades, una parte significativa del desarrollo profesional se apoya en bibliotecas de terceros que amplían sus capacidades. En este artículo veremos cómo instalar muchas de estas bibliotecas mediante el gestor de paquetes pacman de MSYS2 y cómo integrarlas correctamente en proyectos gestionados con CMake.

Entre las bibliotecas más utilizadas y recomendables para un programador que comienza a trabajar con C++ contemporáneo, cabría citar:
  • {fmt}lib (https://fmt.dev), para el formato de texto moderno, seguro y eficiente. La funcionalidad de esta biblioteca inspiró la incorporación de las cabeceras <format> en C++20 [1] y <print> en C++23 [2]. Para su instalación a través del gestor de paquetes pacman de MSYS2, basta acceder a la terminal MSYS2 UCRT desde el Inicio de MS Windows y ejecutar el siguiente comando:
pacman -S mingw-w64-ucrt-x86_64-fmt
  • JSON for Modern C++ (https://github.com/nlohmann/json), para la serialización/deserialización de objetos JSON mediante una interfaz moderna e integrada con los contenedores y tipos de la biblioteca estándar. Para su instalación a través de MSYS2, ejecutaremos el siguiente comando:
pacman -S mingw-w64-ucrt-x86_64-nlohmann_json
  • Range-v3 (https://github.com/ericniebler/range-v3), para el manejo efectivo de rangos, vistas y acciones. Sirvió de base para la incorporación de la biblioteca de rangos (Ranges Library) al estándar C++20 [3]. El lector puede acceder a una serie de artículos sobre su funcionalidad a través de este enlace. Para su instalación a través de MSYS2, ejecutaremos el siguiente comando:
pacman -S mingw-w64-ucrt-x86_64-range-v3
  • Boost (https://www.boost.org/), colección de bibliotecas de alta calidad que ha servido históricamente como banco de pruebas para numerosas funcionalidades posteriormente incorporadas al estándar C++. Incluye, entre otras, Boost.Asio (networking y programación asíncrona), Boost.Beast (HTTP y WebSockets), Boost.Numeric (cálculo numérico) o Boost.Hana (metaprogramación). Para su instalación a través de MSYS2, ejecutaremos el siguiente comando:
pacman -S mingw-w64-ucrt-x86_64-boost
Aunque buena parte de la funcionalidad de {fmt} y Range-v3 se encuentra actualmente reflejada en el estándar ISO C++, estas bibliotecas siguen ofreciendo una evolución más ágil, así como funcionalidades extendidas y características avanzadas aún no estandarizadas. Por ello, continúan siendo herramientas de gran interés en numerosos proyectos profesionales.
Los paquetes instalados mediante MSYS2 incluyen todos los componentes necesarios para que CMake pueda localizarlos automáticamente mediante el comando find_package.

2. Ejemplo de uso

Con el fin de comprobar la correcta instalación de las bibliotecas anteriores, así como la estructura típica que adoptarán los ficheros CMakeLists.txt al emplearlas, retomaremos el proyecto básico de CMake de tipo "Hello, world!" creado en el artículo anterior. Sustituiremos el contenido de su fichero main.cpp por un sencillo programa que almacena en un contenedor asociativo (std::map) varios grupos de Pop/Rock junto con sus integrantes. El usuario podrá introducir por terminal el nombre de una banda y, si ésta se encuentra registrada, el programa mostrará sus miembros ordenados lexicográficamente; en caso contrario, emitirá un mensaje de error. Para ello utilizaremos las bibliotecas {fmt} y Range-v3:

   #include <iostream>    #include <map>    #include <string>    #include <vector>    #include <fmt/core.h>    #include <range/v3/algorithm/sort.hpp>    auto main() -> int    {       auto bands = std::map<std::string, std::vector<std::string>>{};       bands["The Beatles"] = {          "Paul McCartney",          "John Lennon",          "Ringo Starr",          "George Harrison"       };       bands["Pink Floyd"] = {          "Nick Mason",          "Syd Barrett",          "Roger Waters",          "Richard Wright",          "David Gilmour",          "Bob Klose"       };       bands["Arctic Monkeys"] = {          "Alex Turner",          "Matt Helders",          "Jamie Cook",          "Nick O'Malley",          "Andy Nicholson",          "Glyn Jones"       };       fmt::print("Search a pop/rock band: ");       auto band_to_search = std::string{};       std::getline(std::cin, band_to_search);       if (auto it = bands.find(band_to_search); it != bands.end()) {          fmt::print("{:_^30}\n", band_to_search);          auto& members = it->second;          ranges::sort(members);          for (auto const& mb : members)             fmt::print("{:^30}\n", mb);       }       else {          fmt::print("Sorry, '{}' is not on the list", band_to_search);       }    }

Por su parte, el fichero CMakeLists.txt del proyecto adoptará ahora la estructura siguiente:

   cmake_minimum_required(VERSION 4.0)    project(rock_bands       VERSION 0.1.0       DESCRIPTION "Proyecto sencillo de C++ con un solo target"       LANGUAGES CXX    )    add_executable(${PROJECT_NAME} main.cpp)    target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_23)    set_target_properties(${PROJECT_NAME} PROPERTIES       CXX_EXTENSIONS OFF       RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/debug       RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/release    )    #-------------------------------------------------------------------    # integración de bibliotecas de terceros:    find_package(fmt REQUIRED)    find_package(range-v3 REQUIRED)    target_link_libraries(${PROJECT_NAME} PRIVATE       fmt::fmt       range-v3    )    #-------------------------------------------------------------------    # política de advertencias:    if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")       target_compile_options(${PROJECT_NAME} PRIVATE /W4 /WX)    elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")       target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -pedantic -Werror)    endif()    #-------------------------------------------------------------------    # mensajes a emitir en configuración:    message("-- CMake Generator: ${CMAKE_GENERATOR}")    get_target_property(CFEATURES ${PROJECT_NAME} COMPILE_FEATURES)    message("-- Target compile features: ${CFEATURES}")    get_target_property(COPTIONS ${PROJECT_NAME} COMPILE_OPTIONS)    message("-- Target compile options: ${COPTIONS}")

En general, un proyecto podrá contener más de un target, cuyos nombres serán típicamente diferentes a los del proyecto. En un caso tan sencillo como el aquí considerado, sin embargo, en el que el target es único, hemos optado por asignar al ejecutable el mismo nombre que el del proyecto. En el código anterior, la variable ${PROJECT_NAME} será sustituida automáticamente por la cadena rock_bands (u otro título alternativo que establezcamos a través del comando project) allá donde aparezca.
El comando find_package localiza una dependencia previamente instalada y pone a disposición de CMake uno o varios objetivos importados [4]. Posteriormente, target_link_libraries vincula dichos objetivos con nuestro ejecutable, incorporando automáticamente las rutas de inclusión y demás parámetros necesarios para su utilización [5].
Como propiedades del target, hemos solicitado el empleo del último estándar oficial de ISO C++ correspondiente a 2023. El ejecutable se ubicará en la subcarpeta /build/debug/ o /build/release/ según la variante de construcción escogida para el proyecto:


En configuraciones GCC típicas generadas por CMake, el flag empleado por defecto durante la compilación en modo Debug es -g (depurador sin optimizador), mientras que en modo Release se activan los flags -O3 y -DNDEBUG (nivel 3 de optimización y aserciones del depurador eliminadas). Puede comprobarse este punto sin más que inspeccionar los flags CMAKE_CXX_FLAGS_DEBUG y CMAKE_CXX_FLAGS_RELEASE en el archivo /build/CMakeCache.txt.

Las opciones de compilación target_compile_options en nuestro archivo CMakeLists.txt distinguen entre los compiladores MS Visual Studio, Clang y GCC, añadiendo los flags con las advertencias del compilador (compiler warnings) recomendadas en cada caso para detectar errores potenciales y fomentar buenas prácticas de programación (véanse [6, 7] para más detalles).

Dos aspectos notables del fichero CMakeLists.txt que cabe resaltar son:
  1. No es necesario indicar la extensión del ejecutable generado por el proyecto. El build tool se encargará de añadir aquélla que corresponda a nuestra plataforma.
  2. Una vez instaladas las bibliotecas, el comando find_package hace innecesario indicar explícitamente las direcciones en las que se ubican.

Referencias bibliográficas

  1. cppreference - std::format – https://en.cppreference.com/cpp/utility/format/format
  2. cppreference - std::print – https://en.cppreference.com/cpp/io/print
  3. cppreference - Ranges library – https://en.cppreference.com/w/cpp/ranges
  4. CMake - find_package – https://cmake.org/cmake/help/latest/command/find_package.html
  5. CMake - target_link_libraries – https://cmake.org/cmake/help/latest/command/target_link_libraries.html
  6. P1389R1 Standing Document for SG20: Guidelines for Teaching C++ to Beginners – https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1389r1.html
  7. Visual Studio - Compiler warnings levels – https://learn.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level?view=msvc-180
Etiquetas:

Comentarios

Publicar un comentario