Voir la source de C++

Cette page fournit les bases pour bien démarrer en C++ (Cpp).

=Installation=

Comme tout langage, il faudra des outils. Le Cpp est un langage compilé, les outils principaux seront un compilateur et un IDE. Ce tutoriel se concentrera sur Windows, mais les partie xmake et WSL intéressera les utilisateurs de GNU/Linux.

==Visual Studio==

Microsoft écrit tous ses outils disponibles gratuitement sous [https://visualstudio.microsoft.com/fr/ Visual Studio Community] (et non VSCode, ne pas confondre). C'est un outil assez gros mais très complet. Une fois installé, créez un nouveau projet C++ et essayer de le débugger !

==Cmake==

Cmake est le système de build le plus commun dans l'écosystème C/C++. Il est assez compliqué pour ce qu'il fait et l'auteur de cette article ne se sent pas d'écrire un tuto pour Cmake.

==Xmake==

Pour ceux qui préfèrent gérer leurs projet plus manuellement, vous pouvez utiliser [https://xmake.io/#/getting_started xmake]. C'est un outil très pratique sous tout système d'exploitation. Sachez tout de même que c'est un outil peu connu : il reste idéal pour les projets perso ou les cours n'imposant pas d'environnement particulier. Xmake s'occupera pour vous de la compilation et de la gestion des dépendances. Pour démarrer rapidement :

'''Installation'''

Pour windows, tapper dans un terminal administrateur :

<code>
winget install xmake
</code>

Les autres OS l'auront aussi dans leur manager de paquets.

'''Nouveau projet'''

Ouvrez une console où votre dossier de projet sera créé 

<source>
xmake create my-project
cd my-project
xmake build
xmake run
</source>

Voilà ! C'était facile non ? Vous pouvez aussi faire <code>git init</code> et mettre votre code sur gitlab.

'''Configuration'''

La configuration se fait par <code>xmake.lua</code>. Lisez la documentation pour tout savoir, mais globalement voici comment utiliser des paquets de [https://conan.io/center conan] (vous pouvez aussi utiliser les paquets de <code>vcpkg</code> et xmake <code>vcpkg</code>):

<source lang="lua">
add_rules("mode.debug", "mode.release")
set_languages("c++17")
set_warnings("allextra")
set_policy("build.warning", true)
set_policy("run.autobuild", true)

------------------------------------------------------------------
-- Lib deps 
------------------------------------------------------------------

add_requires("conan::glm/0.9.9.8", {alias = "glm", })
add_requires("conan::eigen/3.4.0", {alias = "eigen", })

------------------------------------------------------------------
-- Main target definition
------------------------------------------------------------------

target("my-project")
    set_kind("binary")
    add_packages("glm", "eigen")
    add_files("src/**.cpp")
    add_includedirs("src")
</source>

'''Intégration dans VSCode'''

Télécharger les extensions <code>C/C++</code> et <code>xmake</code> et executer <code>xmake project -k compile_commands .vscode</code> pour que l'éditeur sache trouvez le code. Des boutons utiles apparaîtront sur le bas de l'éditeur (build, run, debug). Notez qu'il sera sûrement nécessaire d'éxecuter <code>xmake project -k compile_commands .vscode</code> pour profiter de toutes les fonctionnalités de l'éditeur.

== Utiliser Windows Subsystem for Linux ==

Voir [https://wikibr.binets.fr/Trucs_et_astuces#Faire_du_C++]


=Langage=

Pour toutes vos question, [https://en.cppreference.com/w/cpp/language cppreference.com] vous répondra avec précision. Hélas, il ne s'agit pas d'un tuto. Nous explorerons ici quelques concepts.

==Fonction main() et éléments==

La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.

Comme dans de nombreux langages, on utilise les construction :

* <code>if(cond) { code } ; else if(cond2) { code } ; else { code }</code>
* <code>while(cond) { boucle }</code>
* <code>for(std::size_t i = 0; i < MAX_DE_I; i++) { boucle }</code>
* <code>for(auto element : container) { boucle }</code>.

Les fonctions s'écrivent :

<source lang="c++">

auto doubler(int x) -> int { return 2 * x ; }
int doubler_encore(int x) { return 2 * x ; }

// fonction lambda, compacte pour certains usages "fonctionnels"
auto lambda_qui_double = [](int x){ return 2 * x ; };
</source>

==Variables==

Le C++ est au typage fort (contrairement à son ancêtre le C). Une variable est déclarée avec son type ou celui-ci est déduit.

<source lang="c++">
// une fonction
auto treize() -> int { return 13; }

int main() {
    int a = 13;
    int b = treize();
    auto c = treize();
}
</source>

Une variable peut être constante <code lang="c++"> const int x = 13; </code>

Une variable peut être une référence à une autre (qui doit vivre tant que la référence existe !!!). C'est très utile pour prendre comme paramètre un type lourd

<source lang="c++">
// une fonction
auto treize() -> int { return 13; }

int main() {
    int a = 13;
    int& ref1 = a;
    auto& ref2 = a;
    auto const& const_ref = a;
}

// évite la copie de "entiers" en prenant une référence !
auto sum(std::vector<int> const& entiers) -> int { ... }
</source>


==Entrées-sorties console==

Les opérateurs <code><< ; >></code> permettent de manipuler des "flux". L'IO console se fait ainsi :

<source lang="c++">
int main() {
    // Sortie standard
    std::cout << "Hello, world!" << std::endl;

    // Entrée standard
    int x;
    std::cout << "Entrez un entier : ";
    std::cin >> x; // Attend l'entrée de l'utilisateur et stocke la valeur dans x
    std::cout << "Vous avez entré : " << x << std::endl;

    return EXIT_SUCCESS;
}
</source>

==Objets==

Les objets en C++ sont créés par constructeur et détruits '''de manière déterministe''' à la fin du bloc d'accolades dans lequel il est crée si il est lié à une variable, sinon à la fin de l'expression.

<source lang="c++">
struct rationnel{
   int a{0}; // public par défaut dans les "struct", privée par défaut dans les "class"
   int b{1};
};

int main() {
    const rationnel r1{1, 3}; // construit r = 1/3
    
    if (r1.a == 1) {
        const auto r2 = rationnel{1, 4}; // construit r2 = 1/4
    } // détruit r2
    
    const rationnel par_defaut1; // construit par_defaut1 = 0/1
    const rationnel par_defaut2{}; // construit par_defaut2 = 0/1
    
    rationnel{2, 3}; // construit un temporaire, il est immédiatement détruit
    
    const rationnel r3 = rationnel{r1.b, 2}; // construit r3 = r1.b/2
    return 0; // à la sortie de la fonction, r3, par_defaut2, par_defaut1, r1 sont détruits dans cet ordre
}

</source>

La destruction déterministe est très utile et permet d'utiliser les objets comme gestionnaire de ressource  (équivalent du context manager en python par exemple). Ce mécanisme s'appelle la RAII. Par exemple voici comment créer un buffer OpenGL qui se désalloue automatiquement :

<source lang="c++">
struct buffer
{
  private:
    GLuint m_id;

  public:
    buffer() { glGenBuffers(1, &m_id); }
    ~buffer() {
        if (m_id) { glDeleteBuffers(1, &m_id); }
    }
    // une méthode ordinaire
    auto id() const -> GLuint { return m_id; }
    // points bonus : permet de "move" un buffer vers un autre qui le remplace
    buffer(buffer &&moved) : m_id{ std::exchange(moved.m_id, 0) } {}
};

int main() {
    const auto mybuffer = buffer{}; // glGenBuffers()
    // use my buffer...
    return 0; // ici glDeleteBuffers() est appelé !
}
</source>

Les objets supportent aussi beaucoup de fonctionnalités. N'abuser pas des bonnes choses, combiner toutes ces fonctionnalités est la meilleure méthode pour ne plus s'y retrouver...

* membres privés, protégés, publics
* fonctions virtuelles et virtuelles pure ; classes abstraites
* amis (friend) ; c'est un peu obscure
* héritage : simple, multiple, virtuel ; ne pas en abuser svp
* redéfinissions des constructeurs, constructeur par défaut, de copie ou de move
* redéfinissions des opérateurs arithmétiques, d'appel, d'indexation...

Pour s'exercer à la création de structure, un mini-TD d'inf443 est efficace : [https://imagecomputing.net/course/2023_2024/inf443/lab/content/03/a_cpp_classes/index.html]

==Eléments utiles du standard==

===Conteneurs===

Cf [https://en.cppreference.com/w/cpp/container cppreference]

* std::string ; avec std::string_view, à toujours préférer à char*
* std::array<type, taille> ; à toujours préférer à type[taille], hérité du C
* std::vector<type> ; tableau dynamique, très utile
* std::unordered_set<type> ; hashset
* std::unordered_map<type> ; hashmap

===Vues sur une partie du conteneur (slice)===

Attention : ces vues ne sont pas propriétaire des données sous-jacente : il est de votre responsabilité de vous assurer que les données du conteneur vers lesquelles elles pointent existent encore.

* std::string_view (nécessite C++17)
* std::span<type>  (nécessite C++20)

===Monades et assimilés===

* [https://en.cppreference.com/w/cpp/utility/optional std::optionnal<type>] (C++ 17) : peut contenir une valeur ou rien.
* [https://en.cppreference.com/w/cpp/utility/variant std::variant<type1, type2, ...>] (C++ 17) : peut contenir un seul des types
* [https://en.cppreference.com/w/cpp/utility/expected std::expected<type, erreur>] (C++23) : contient un type ou une erreur

Le visiteur de variant :
<source lang="c++">
#include <iostream>
#include <variant>

// pattern très sympa
template <typename... Base> struct overload : Base... { using Base::operator()...; };
template <typename... T> overload(T...) -> overload<T...>;

int main() {
    const auto var = std::variant<float, bool>{true};
    const auto visitor = overload{
        [](float x) { std::cout << "float: " << x << std::endl; },
        [](bool b) { std::cout << "boolean: " << b << std::endl; }
    };
    std::visit(visitor, var);
}

</source>

==Algorithmes==

De nombreux algorithmes classiques sont implémentés de manière fonctionnelle et générique : [https://en.cppreference.com/w/cpp/algorithm]