C++ est un langage de programmation orientée objet. Il offre la possibilité d'avoir le contrôle total sur la gestion de la mémoire.

Visual Studio est un environnement de développement intégré prenant en charge le développement de projet C++. Quelques configurations sont le plus souvent nécessaires pour mener à bien le développement d'un projet C++ sous Visual Studio.

Une application console vide est une application qui s'exécute en ligne de commande. Il est initialisé par défaut sans aucun fichier source.

// Visual Studio (Créer une Application Console Vide C++)

...
# Ouvrir le menu des projets
Fichier > Nouveau > Projet
...
# Définir le type de projet
Tous les langages C++ >
Toutes les plateformes > Windows
Tous les type de projet > Console
...
# Sélectionner le type de projet
Projet Vide > Suivant
...
# Définir les informations sur le projet
Nom du projet > rdvcpp
Emplacement > [chemin/repertoire/projet]
Solution > Créer une nouvelle solution
Nom de la solution > rdvcpp
...
Créer
...

// main.cpp (Editer le programme principal)

...
#include <iostream>

int main(int argc, char** argv)
{
    std::cout << "[rdvcpp] Demarrage du projet C++..." << std::endl;
    return 0;
}
...

// Visual Studio (Exécuter le projet)

...
Déboguer > Exécuter sans débogage
...

Une application console est une application qui s'exécute en ligne de commande. Le projet est initialisé par défaut avec un fichier source C++. .

// Visual Studio (Créer une Application Console C++)

...
# Ouvrir le menu des projets
Fichier > Nouveau > Projet
...
# Définir le type de projet
Tous les langages C++ >
Toutes les plateformes > Windows
Tous les type de projet > Console
...
# Sélectionner le type de projet
Application Console > Suivant
...
# Définir les informations sur le projet
Nom du projet > rdvcpp
Emplacement > [chemin/repertoire/projet]
Solution > Créer une nouvelle solution
Nom de la solution > rdvcpp
...
Créer
...

// main.cpp (Editer le programme principal)

...
#include <iostream>

int main(int argc, char** argv)
{
    std::cout << "Bonjour tout le monde." << std::endl;
    return 0;
}
...

// Visual Studio (Exécuter le projet)

...
Déboguer > Exécuter sans débogage
...

Une application console est une application qui s'exécute en ligne de commande. Le projet est initialisé par défaut pour être construit avec l'outil CMake.

// Visual Studio (Créer un projet C++ CMake)

...
# Ouvrir le menu des projets
Fichier > Nouveau > Projet
...
# Définir le type de projet
Tous les langages C++ >
Toutes les plateformes > Windows
Tous les type de projet > Console
...
# Sélectionner le type de projet
Projet CMake > Suivant
...
# Définir les informations sur le projet
Nom du projet > rdvcpp
Emplacement > [chemin/repertoire/projet]
Solution > Créer une nouvelle solution
Nom de la solution > rdvcpp
...
Créer
...

// src/main.cpp (Editer le programme principal)

...
#include "headers.h"

int main(int argc, char** argv)
{
    std::cout << "Bonjour tout le monde." << std::endl;
    return 0;
}
...

// src/headers.h (Editer le fichier header des libraires standards)

...
#pragma once

#include <iostream>
...

// CMakeLists.txt (Editer le fichier CMake racine)

...
cmake_minimum_required (VERSION 3.8)

if (POLICY CMP0141)
  cmake_policy(SET CMP0141 NEW)
  set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
endif()

project ("rdvcpp")

add_subdirectory ("src")
...

// src/CMakeLists.txt (Editer le fichier CMake des sources)

...
add_executable (rdvcpp "main.cpp" "headers.h")

if (CMAKE_VERSION VERSION_GREATER 3.12)
  set_property(TARGET rdvcpp PROPERTY CXX_STANDARD 20)
endif()
...

// Visual Studio (Exécuter le projet)

...
Déboguer > Exécuter sans débogage
...

Un fichier source C++ contient la définition d'un projet C++. 

// Visual Studio (Ajouter un fichier source C++)

...
# Ouvrir le menu des éléments
[nom-projet] > Fichiers sources > Clic droit > Nouvel élément
...
# Sélectionner le fichier C++
Installé > Visual C++ > Fichier C++ (.cpp)
Nom > [nom-fichier].cpp
Emplacement > [/chemin/repertoire/projet]
Ajouter
...

Tout fichier présent dans l'explorateur de projet peut être renommé. 

// Visual Studio (Renommer un fichier)

...
# Renommer un fichier sous Visual Studio
[nom-projet] > Fichiers sources > [nom-fichier].cpp > Clic droit > Renommer > [nom-fichier-new].cpp
...

Tout répertoire présent dans l'explorateur de projet peut être renommé. 

// Visual Studio (Renommer un répertoire)

...
# Renommer un répertoire sous Visual Studio
[nom-projet] > [nom-repertoire] > Clic droit > Renommer > [nom-repertoire-new]
...

Les tabulations sont des gestionnaires d'indentation. Elles sont utilisées lors de l'indentation de code pour mieux formater le code afin de faire ressortir les blocs de code. Une tabulation correspond en général à un ensemble de 4 espaces. Le nombre d'espace est imposé par les préférences de l'équipe de développement. Lorsque les tabulations ne sont pas remplacées par des espaces, l'affichage d'une même base de code peut différer d'un éditeur à l'autre et cela peut être très embêtant. 

// Visual Studio (Remplacer les tabulations par des espaces)

...
# Remplacer les tabulations par des espaces
Edition > Avancé > Définir la mise en retrait > Espaces
...

Un symbole de préprocesseur est utilisé par le préprocesseur pour déterminer les portions de codes à exécuter en fonction des options de compilation. 

// Visual Studio (Définir un symbole de préprocesseur)

...
# Ouvrir les propriétés du projet
[nom-projet] > Clic droit > Propriétés
# Ajouter un symbole de préprocesseur
Propriétés de configuration > C/C++ > Préprocesseur
Définitions de préprocesseur > Modifier
Ajouter > DEUBU_ON
OK > OK
...

Le passage des arguments en ligne de commande est le moyen de fournir des paramètres à un exécutable à partir de la ligne de commande. La procédure diffère si le projet est initialisé sans l'outil CMake. 

// Visual Studio (Définir des arguments en ligne)

...
# Ouvrir les propriétés du projet
[nom-projet] > Clic droit > Propriétés
# Définir les arguments en ligne
Propriétés de configuration > Débogage
Arguments de débogage > Modifier
Ajouter > un deux trois quatre
OK > OK
...

Le passage des arguments en ligne de commande est le moyen de fournir des paramètres à un exécutable à partir de la ligne de commande. La procédure diffère si le projet est initialisé avec l'outil CMake.

// Visual Studio (Définir des arguments en ligne)

...
# Ouvrir la configuration du lanceur
Déboguer > Paramètres de débogage et de lancement pour [nom-projet]
...
# Cela ouvre le lanceur
launch.vs.json
...

// launch.vs.json (Définir des arguments en ligne)

...
{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CMakeLists.txt",
      ...,
      "args": ["un", "deux", "trois", "quatre"]
    }
  ]
}
...

L'élément de démarrage correspond à l'élément à exécuter. Lorsque l'élément de démarrage est défini sur le document actif, L'exécution du projet ne fonctionnera pas. Dans ce cas, il va falloir modifier l'élément de démarrage sur l'exécutable du projet.

// Visual Studio (Sélectionner un élément de démarrage)

...
# Sélectionner un élément de démarrage
Sélectionner un élément de démarrage > [nom-projet] (/chemin/executable)
...

Un fichier d'en-tête précompilé est un gestionnaire de fichiers d'en-tête stables. Il permet de rassembler tous les fichiers d'en-tête stables dans un seul fichier précompilé afin d'accélérer le processus de compilation du projet. Il est recommandé d'inclure tous les fichiers d'en-tête des librairies standards dans le fichier d'en-tête précompilé. 

// Visual Studio (Créer un fichier d'entête précompilé)

...
# Ouvrir les propriétés du projet
[nom-projet] > Clic droit > Propriétés
# Créer le fichier d'entête précompilé
Propriétés de configuration > C/C++ > En-têtes précompilés
En-tête précompilé > Création (/Yc)
Fichier d'en-tête précompilé > rdv_pch.h
Fichier d'en-tête précompilé de sortie > $(IntDir)$(TargetName).pch
OK > OK
...

// Notes (Configurer un fichier d'entête précompilé)

...
# Cela génère le fichier (.pch) > x64\Debug\rdvcpp.pch
...

Le terminal Visual Studio permet de compiler et d'exécuter un projet C++ en ligne de commande. Il est initialisé par défaut pour pointer les fichiers d'en-tête et les fichiers binaires des librairies standards C++.

Le terminal Visual Studio permet de compiler et d'exécuter un projet C++ en ligne de commande. Il est initialisé par défaut pour pointer les fichiers d'en-tête et les fichiers binaires des librairies standards C++. 

// Windows (Ouvrir le terminal Visual Studio)

...
Bouton Windows > Rechercher > x64 Native Tools Command Prompt for VS 2022
...

La commande CL est le compilateur de projet C++ fournit par l'éditeur Microsoft Visual Studio. L'affichage de l'aide sur la commande CL permet d'en savoir plus sur le rôle de chaque option supportée par le compilateur. 

// Terminal (Afficher l'aide sur le compilateur CL)

cl /?
...
# Appuyer sur la touche (Entrée) pour continuer afficher le menu d'aide
...
# Appuyer sur la touche (Ctrl + C) pour quitter le menu d'aide
...

La commande CL est le compilateur de projet C++ fournit par l'éditeur Microsoft Visual Studio. Il permet de traduire le code C++ en langage machine. 

// main.cpp (Programme principal)

...
#include <iostream>

int main(int argc, char **argv)
{
    std::cout << "Bonjour tout le monde" << std::endl;
    return 0 ;
}
...

// Terminal (Compiler le projet sans le fichier exécutable)

...
# Compiler le projet sans le fichier exécutable
cl /EHsc main.cpp
...
# Cela génère le fichier objet (main.obj)
# et le fichier exécutable (main.exe)
...

// Terminal (Exécuter le projet)

...
main.exe
...

// Terminal (Compiler le projet avec le fichier exécutable)

...
# Compiler le projet avec le fichier exécutable
cl /EHsc /Fe:rdvcpp main.cpp
...
# Cela génère le fichier objet (main.obj)
# et le fichier exécutable (rdvcpp.exe)
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

La commande CL est le compilateur de projet C++ fournit par l'éditeur Microsoft Visual Studio. L'affichage de l'aide sur la commande CL permet d'en savoir plus sur le rôle de chaque option supportée par le compilateur. 

// Notes (Comprendre les options de compilation)

...
/c
Compiler uniquement, ne pas lier.
...
/D<symbole>
Définit la constante ou la macro <symbole>.
...
/EHsc
Active la gestion des exceptions C++ mais indique que les exceptions des
fonctions externes "C" (généralement les fonctions du système d'exploitation) ne sont pas gérées.
...
/Fe:<fichier>
Indique le nom du fichier exécutable vers lequel établir le lien.
...
/Fo:<fichier>
Indique le nom du fichier objet vers lequel compiler.
...
/I <dossier>
Indique le nom d'un dossier à utiliser pour rechercher les fichiers d'inclusion.
...
/link<options-du-lien>
Transmettez les <options-du-lien> au lien. Cela doit apparaître après le
nom du fichier source et tous les commutateurs destinés au compilateur.
...
/Tp <fichier>
Compile <fichier> en tant que fichier C++, même s'il n'a pas .cpp ou
.cxx comme extension de fichier.
...
/U<symbole>
Supprime la macro ou la constante <symbole> précédemment définie.
...
/Zi
Active les informations de débogage.
...
/Zs
Syntaxe uniquement, ne compile pas et ne lie pas.
...

Un projet C++ se termine en général avec un code d'erreur. Le code d'erreur 0 indique que le programme s'est déroulé sans erreur. Un code d'erreur différent de 0 indique un problème lors de l'exécution du programme. Le code d'erreur peut être exploité dans un script Batch (.bat) pour orienter le déroulé du script.

// main.cpp (Programme principal)

...
#include <iostream>

int main(int argc, char **argv)
{
    std::cout << "Bonjour tout le monde" << std::endl;
    return 99;
}
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

// Terminal (Afficher le code d'erreur)

...
echo %errorlevel% 
...

Le préprocesseur intervient avant la compilation d'un projet C++. Il localise les fichiers d'en-tête et les insère dans les fichiers source. Il localise aussi les constantes de préprocesseur et les remplace dans les fichiers sources.

// main.cpp (Programme principal)

...
#include <iostream>

int main(int argc, char **argv)
{
    std::cout << "NUMBER : " << NUMBER << std::endl;
    return 0;
}
...

// Terminal (Compiler le projet avec une constante de préprocesseur)

...
cl /EHsc /Fe:rdvcpp /DNUMBER=4 main.cpp
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

Un symbole de préprocesseur est utilisé par le préprocesseur pour déterminer les portions de codes à exécuter en fonction des options de compilation.

// main.cpp (Programme principal)

...
#include <iostream>

#ifdef DEBUG_ON
#define MESSAGE(ARGC, ARGV)                                              \
    do                                                                   \
    {                                                                    \
        std::cout << "argc : " << ARGC << std::endl;                     \
        for (int i = 0; i < ARGC; i++)                                   \
        {                                                                \
            std::cout << "argv[" << i << "] : " << ARGV[i] << std::endl; \
        }                                                                \
    } while (false)
#else
#define MESSAGE
#endif

int main(int argc, char **argv)
{
    MESSAGE(argc, argv);
    return 0;
}
...

// Terminal (Compiler le projet sans symbole)

...
cl /EHsc /Fe:rdvcpp main.cpp
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe un deux trois quatre
...

// Terminal (Compiler le projet avec un symbole)

...
cl /EHsc /Fe:rdvcpp /DDEBUG_ON main.cpp
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe un deux trois quatre
...

Un fichier d'en-tête précompilé est un gestionnaire de fichiers d'en-tête stables. Il permet de rassembler tous les fichiers d'en-tête stables dans un seul fichier précompilé afin d'accélérer le processus de compilation du projet. Il est recommandé d'inclure tous les fichiers d'en-tête des librairies standards dans le fichier d'en-tête précompilé.

// main.cpp (Programme principal)

...
#include "rdv_pch.h"

int main(int argc, char **argv)
{
    std::cout << "Bonjour tout le monde" << std::endl;
    return 0;
}
...

// rdv_pch.h (Gestion du fichier en-tête précompilé)

...
#pragma once

#include <iostream>
#include <string>
#include <ctime>
...

// rdv_pch.cpp (Gestion du fichier en-tête précompilé)

...
#include "rdv_pch.h"
...

// Notes (Générer le fichier en-tête précompilé)

...
# Cela génère le fichier (.obj) > rdv_pch.obj
# Cela génère le fichier (.pch) > rdv_pch.pch
...

// Terminal (Compiler le projet avec l'en-tête précompilé)

...
cl /EHsc /Fe:rdvcpp main.cpp /Yurdv_pch.h /Fprdv_pch.pch /linkrdv_pch.obj
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...