Skip to main content

Mi primera aplicación en CMake

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

r8vnhill/

CMake utiliza un archivo de configuración llamado CMakeLists.txt, que define cómo construir el proyecto. En este archivo, puedes especificar las dependencias, las opciones de compilación, y los pasos necesarios para construir y ejecutar la aplicación.

Ejemplo básico de CMakeLists.txt​

Aquí te muestro un ejemplo simple de cómo crear una aplicación en C++ que hace eco de los argumentos de línea de comando, similar a la Echo App que hicimos en Kotlin.

CMakeLists.txt
cmake_minimum_required(VERSION 3.29)

project(EchoApp VERSION 1.0.0)

add_executable(EchoApp main.cpp)

Este archivo indica a CMake que queremos construir un proyecto llamado EchoApp y que su código principal se encuentra en main.cpp. En este caso, no hemos añadido dependencias externas como en Gradle, pero veremos cómo se puede hacer eso más adelante.

Código de la Aplicación​

El código fuente para la aplicación se puede escribir en un archivo main.cpp, y su comportamiento será similar al de la Echo App en Kotlin, mostrando la hora actual junto con el mensaje recibido como argumento:

main.cpp
#include <iostream>
#include <chrono>
#include <ctime>

void echo(const std::string &message) {
    const auto now =
        std::chrono::system_clock::to_time_t(
            std::chrono::system_clock::now()
        );
    std::cout << std::ctime(&now) << message << std::endl;
}

int main(const int argc, char *argv[]) {
    for (int i = 1; i < argc; ++i) {
        echo(argv[i]);
    }
    return 0;
}

Este programa, escrito en C++, toma los argumentos de la línea de comando, obtiene la hora actual y muestra el mensaje con una marca de tiempo, similar a lo que hicimos en Kotlin.

Compilando y Ejecutando la Aplicación con CMake​

Para construir y ejecutar la aplicación, necesitarás seguir estos pasos:

  1. Configurar el proyecto: Primero, debes crear un directorio build y configurar el proyecto con CMake.

    mkdir build
    cd build
    cmake ..

    Esto generará los archivos de construcción en el directorio build.

  2. Compilar el proyecto: Luego, compila el proyecto ejecutando el siguiente comando:

    cmake --build .

  3. Ejecutar la aplicación: Finalmente, puedes ejecutar el binario generado:

    ./Debug/EchoApp Hello World

El resultado será similar al siguiente:

Fri Oct 18 20:32:44 2024
Hello
Fri Oct 18 20:32:44 2024
World

Dependencias Externas en CMake​

A diferencia de Gradle, CMake no tiene una gestión de dependencias tan robusta por defecto. Sin embargo, puedes utilizar find_package para buscar bibliotecas instaladas en el sistema o utilizar gestores de paquetes externos como vcpkg o Conan para gestionar dependencias de manera más sencilla.

Aquí tienes un ejemplo básico de cómo añadir una biblioteca externa usando find_package en CMake. Supongamos que necesitas una biblioteca de terceros para manejar la fecha y hora (similar a kotlinx-datetime en Gradle):

# Buscar la biblioteca de fecha y hora
find_package(Boost 1.70 REQUIRED COMPONENTS date_time)

# Incluir la biblioteca en el proyecto
target_link_libraries(EchoApp Boost::date_time)

Comparación entre Gradle y CMake​

Similitudes:​

  • Gestión de compilación: Tanto Gradle como CMake proporcionan herramientas para gestionar la compilación de proyectos grandes y complejos.
  • Configuración de dependencias: Ambos permiten gestionar dependencias externas, aunque CMake requiere un enfoque más manual o el uso de gestores externos como vcpkg o Conan.
  • Ejecutables: Los dos frameworks permiten crear aplicaciones ejecutables desde una configuración declarativa.

Diferencias:​

  • Gestión de dependencias: Gradle facilita la gestión de dependencias con su integración directa de repositorios como Maven Central. CMake, por su parte, necesita herramientas adicionales o configuraciones manuales para manejar bibliotecas externas.
  • Lenguajes soportados: Gradle está más enfocado en el ecosistema de JVM (Java, Kotlin), mientras que CMake se utiliza principalmente en proyectos C/C++ y es más compatible con otros lenguajes de bajo nivel.
  • Simplicidad en la configuración: Gradle tiene una sintaxis más sencilla y declarativa para gestionar tareas y dependencias, mientras que CMake requiere configuraciones más explícitas.
  • Distribución: En Gradle, es fácil empaquetar una aplicación ejecutable sin necesidad de instalar Gradle en la máquina de los usuarios. Con CMake, generalmente necesitarás compilar la aplicación en cada sistema objetivo.

Resumen comparativo​

CaracterísticaGradleCMake
Lenguajes SoportadosEnfocado en lenguajes de la JVM como Kotlin y JavaPrincipalmente utilizado en C/C++, pero también soporta otros lenguajes de bajo nivel
Gestión de DependenciasIntegración directa con repositorios como Maven Central, con manejo automático de dependenciasNecesita herramientas adicionales como vcpkg o Conan, o el uso de find_package manualmente
Simplicidad de ConfiguraciónSintaxis declarativa y más sencilla, ideal para proyectos que requieren múltiples configuracionesMás explícito y requiere configuración detallada, lo que puede complicar la configuración
Soporte para EjecutablesFacilita la creación de ejecutables empaquetados independientemente de GradleCMake genera ejecutables, pero requiere compilación en cada sistema donde se ejecutará
Integración de HerramientasAltamente integrado con herramientas modernas de desarrollo como IDEs y CI/CDNecesita más configuraciones manuales, aunque es compatible con muchas herramientas
DistribuciónPermite empaquetar aplicaciones fácilmente para distribución sin necesidad de instalar GradleLa aplicación normalmente necesita ser compilada en cada máquina destino para asegurar compatibilidad
FlexibilidadIdeal para proyectos en el ecosistema JVM, ofrece plugins y una alta integración con otros sistemasMuy flexible y configurable, pero puede requerir mayor esfuerzo para tareas que son más simples en Gradle

Beneficios y limitaciones​

Beneficios

  • Flexibilidad: CMake es extremadamente flexible y soporta una amplia gama de lenguajes y plataformas, lo que lo hace ideal para proyectos multiplataforma, especialmente en C/C++.
  • Compatibilidad: Es compatible con varias herramientas de construcción y entornos, como Make, Ninja, y puede integrarse fácilmente en sistemas de CI/CD.
  • Customización avanzada: Permite personalizar cada aspecto del proceso de compilación, lo que es útil para proyectos complejos que requieren configuraciones detalladas.
  • Independencia del entorno: CMake permite generar archivos de compilación para diversos sistemas, lo que lo hace ideal para proyectos que necesitan ser ejecutados en diferentes entornos de desarrollo y producción.

Limitaciones

  • Complejidad en la configuración: A diferencia de Gradle, que tiene una sintaxis declarativa más sencilla, CMake requiere configuraciones explícitas y detalladas, lo que puede resultar en configuraciones más largas y complicadas.
  • Gestión de dependencias: No ofrece un sistema nativo de gestión de dependencias como Gradle. En CMake, es necesario utilizar herramientas externas (como vcpkg o Conan) o gestionar dependencias de manera manual, lo que añade complejidad al proceso.
  • Curva de aprendizaje: La personalización y flexibilidad que ofrece CMake vienen a expensas de una curva de aprendizaje más empinada, especialmente para nuevxs usuarixs o proyectos sencillos que no requieren configuraciones avanzadas.
  • Distribución complicada: A diferencia de Gradle, que facilita la creación de aplicaciones empaquetadas para su distribución, con CMake la aplicación normalmente necesita ser recompilada en cada sistema objetivo, lo que puede ser más complicado.

¿Qué aprendimos?​

En esta lección, hemos explorado cómo crear una aplicación utilizando CMake y compararla con Gradle. CMake ofrece una flexibilidad y capacidad de configuración que lo hacen ideal para proyectos complejos en C/C++ y otros lenguajes de bajo nivel, pero su complejidad puede ser una barrera para proyectos más sencillos o para quienes buscan una configuración rápida y declarativa, como en Gradle.

Puntos clave​

  • CMake es ideal para proyectos multiplataforma, permitiendo configurar y generar archivos de construcción para diferentes sistemas, pero requiere más configuraciones explícitas.
  • La gestión de dependencias en CMake es más manual, requiriendo herramientas adicionales o configuraciones específicas para buscar y vincular bibliotecas.
  • La flexibilidad de CMake lo hace útil en proyectos complejos, pero a expensas de una curva de aprendizaje más empinada.
  • Gradle ofrece un manejo más sencillo de dependencias y una configuración declarativa, pero está enfocado en lenguajes del ecosistema JVM como Kotlin y Java.

Al final de esta lección, has aprendido las diferencias entre estos dos sistemas de construcción, sus beneficios y limitaciones, y cómo elegir el adecuado según el tipo de proyecto que estés desarrollando.