Blog Kor51

Boilerplate projet C++

Pour tout projet moderne C++ vous devez utilisez ce type de configuration. Apprenez à maitriser ces outils, pour des projets sérieux en C++.

Voici un exemple de boilerplate pour un projet C++ utilisant CMake, Conan, et Doxygen avec le compilateur LLVM sous Linux. Ce boilerplate inclut une structure de projet simple et un script build.sh qui gère l'installation des dépendances via Conan, configure le projet avec CMake, et compile le tout.

Structure du projet

my_project/
├── CMakeLists.txt
├── conanfile.txt
├── docs/
│   └── Doxyfile
├── include/
│   └── example.h
├── src/
│   └── main.cpp
├── build.sh
└── README.md

1. CMakeLists.txt

Voici un fichier CMakeLists.txt pour configurer le projet C++ avec CMake :

cmake_minimum_required(VERSION 3.15)
project(my_project VERSION 1.0.0 LANGUAGES CXX)

# Utiliser le compilateur LLVM
set(CMAKE_CXX_COMPILER clang++)

# Activer les warnings et les standards modernes de C++
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Ajouter les options de compilation
add_compile_options(-Wall -Wextra -pedantic)

# Ajout des informations de compilation
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Inclure Conan
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()

# Ajouter les dossiers include et src
include_directories(${CMAKE_SOURCE_DIR}/include)
include_directories(${CMAKE_SOURCE_DIR}/src)

# Ajouter l'exécutable
add_executable(my_project src/main.cpp)

# Lier les bibliothèques Conan au projet
target_link_libraries(my_project ${CONAN_LIBS})

# Générer la documentation avec Doxygen
find_package(Doxygen)
if (DOXYGEN_FOUND)
    set(DOXYGEN_IN ${CMAKE_SOURCE_DIR}/docs/Doxyfile)
    set(DOXYGEN_OUT ${CMAKE_BINARY_DIR}/docs)

    add_custom_target(doc_doxygen ALL
        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_IN}
        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        COMMENT "Generating API documentation with Doxygen"
        VERBATIM
    )
endif()

2. conanfile.txt

Ce fichier conanfile.txt est utilisé pour définir les dépendances de votre projet à gérer avec Conan :

[requires]
# Listez vos dépendances ici, par exemple :
fmt/10.0.0

[generators]
cmake

3. docs/Doxyfile

Générez un fichier Doxyfile pour la documentation Doxygen :

doxygen -g docs/Doxyfile

Ensuite, modifiez les options principales dans le fichier Doxyfile :

  • PROJECT_NAME = "my_project"
  • OUTPUT_DIRECTORY = "docs/output"
  • INPUT = "include src"

4. include/example.h

Ajoutez un fichier d'exemple pour tester le projet :

#pragma once

namespace my_project {
    void say_hello();
}

5. src/main.cpp

Un fichier source simple qui utilise le fichier d'en-tête :

#include <iostream>
#include "my_project/example.h"

int main() {
    my_project::say_hello();
    return 0;
}

Et le contenu de example.h :

#include <iostream>

namespace my_project {
    void say_hello() {
        std::cout << "Hello from my_project!" << std::endl;
    }
}

6. build.sh

Le script de build build.sh pour installer les dépendances via Conan, configurer CMake, et compiler le projet :

#!/bin/bash

# Arrêter le script en cas d'erreur
set -e

# Dossier de build
BUILD_DIR="build"

# Nettoyer le dossier de build s'il existe déjà
if [ -d "$BUILD_DIR" ]; then
    rm -rf "$BUILD_DIR"
fi

# Créer le dossier de build
mkdir -p "$BUILD_DIR"
cd "$BUILD_DIR"

# Installer les dépendances via Conan
conan install .. --build=missing

# Configurer CMake avec le générateur Ninja (facultatif)
cmake .. -G "Ninja" -DCMAKE_BUILD_TYPE=Release

# Lancer la compilation
cmake --build .

# Lancer les tests ou l'exécutable
./my_project

# Générer la documentation
cmake --build . --target doc_doxygen

echo "Build et documentation terminés."

7. README.md

Ajoutez un fichier README.md pour documenter votre projet :

# My Project

Un projet C++ simple utilisant CMake, Conan, et Doxygen.

## Prérequis
- Conan
- CMake >= 3.15
- Doxygen
- LLVM (clang++)

## Compilation
Pour compiler le projet, exécutez simplement :

   ```bash
./build.sh
   ```

Cela installera les dépendances, configurera CMake, compilera le projet et générera la documentation avec Doxygen.

Utilisation

  1. Rendez le script build.sh exécutable :
   chmod +x build.sh
  1. Exécutez le script pour compiler votre projet :
   ./build.sh

Le script build.sh va : - Nettoyer et recréer le dossier build. - Installer les dépendances via Conan. - Configurer CMake pour utiliser le compilateur clang++. - Compiler le projet avec les options de CMake. - Lancer l'exécutable. - Générer la documentation Doxygen.

Ce boilerplate fournit une base solide pour un projet C++ moderne utilisant CMake et Conan, avec des configurations pour la documentation et l'automatisation de la compilation sous Linux.