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.

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.

L'affichage d'un message à l'écran est l'un des moyens d'imprimer les données manipulées par un projet C++ à l'écran.

// main.cpp (Programme principal)

...
#include <iostream>

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

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

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.

// main.cpp (Programme principal)

...
#include <iostream>

int main(int argc, char **argv)
{
    std::cout << "argc : " << argc << std::endl;
    for (int i = 0; i < argc; i++)
    {
        std::cout << "argv[" << i << "] : " << argv[i] << std::endl;
    }
    return 0;
}
...

// Terminal (Exécuter le projet)

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

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>

#define NUMBER 4

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

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

Une macro de préprocesseur est utilisée par le préprocesseur pour définir une fonction de préprocesseur avec des paramètres. Le pattern do while est utilisé pour transformer la macro en un seul bloc d'instructions.

// main.cpp (Programme principal)

...
#include <iostream>

#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)

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

// Terminal (Exécuter le projet)

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

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;
}
...

// Notes (Configurer le symbole de préprocesseur)

...
[outil-developpement] > Configurer > DEBUG_ON
...

// Terminal (Exécuter le projet)

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

La directive (#pragma once) est utilisée par le préprocesseur pour éviter les inclusions multiples d'un même fichier.

// main.cpp (Programme principal)

...
#include <iostream>
#include "rdv_defines.h"

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

// rdv_defines.h (Gestion des définitions)

...
#pragma once
#define NUMBER 4
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

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>
...

// Notes (Configurer le fichier en-tête précompilé)

...
[outil-developpement] > Configurer > rdv_pch.h
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

Une fonction est un concept de la programmation procédurale. Elle permet de rassembler dans un bloc un ensemble d'instructions réutilisable. L'instruction (static) est utilisée ici pour limiter la portée de la fonction (Hello_Run) au fichier (main.cpp).

// main.cpp (Programme principal)

...
#include <iostream>

static void Hello_Run();

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

static void Hello_Run()
{
    std::cout << "Bonjour tout le monde." << std::endl;
}
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

Un module est un concept de la programmation modulaire et réutilisable. Il permet de rassembler dans un fichier séparé un ensemble des fonctionnalités réutilisable.

// main.cpp (Programme principal)

...
#include "rdv_hello.h"

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

// rdv_hello.h (Gestion du module)

...
#pragma once

void Hello_Run();
...

// rdv_hello.cpp (Gestion du module)

...
#include "rdv_hello.h"
#include <iostream>

void Hello_Run()
{
    std::cout << "Bonjour tout le monde." << std::endl;
}
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

Une classe est un concept de la programmation orientée objet. Elle permet d'encapsuler dans une structure un ensemble de propriétés et de fonctionnalités décrivant un objet. Par défaut, l'accès aux membres d'une classe est privé. Alors que, l'accès par défaut aux membres d'une structure ou d'une union est public.

// main.cpp (Programme principal)

...
#include "cHello.h"

int main(int argc, char **argv)
{
    cHello oHello;
    oHello.run();
    return 0;
}
...

// cHello.h (Gestion de la classe)

...
#pragma once

class cHello
{
public:
    cHello();
    ~cHello();
    void run();
};
...

// cHello.cpp (Gestion de la classe)

...
#include "cHello.h"
#include <iostream>

cHello::cHello()
{
}

cHello::~cHello()
{
}

void cHello::run()
{
    std::cout << "Bonjour tout le monde." << std::endl;
}
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...

Une classe possède un constructeur appelé automatiquement à chaque création d'une nouvelle instance de la classe, des méthodes qui agissent sur les propriétés de la classe et un destructeur appelé à chaque destruction de la classe ou chaque fois qu'un objet de la classe sort de la portée du bloc où il a été déclaré.

// main.cpp (Programme principal)

...
#include "cClass.h"

int main(int argc, char **argv)
{
    cClass oClass;
    oClass.run();
    return 0;
}
...

// cClass.h (Gestion de la classe)

...
#pragma once

class cClass
{
public:
    cClass();
    ~cClass();
    void run();
};
...

// cClass.cpp (Gestion de la classe)

...
#include "cClass.h"
#include <iostream>

cClass::cClass()
{
    std::cout << "Constructeur : cClass::cClass()" << std::endl;
}

cClass::~cClass()
{
    std::cout << "Destructeur : cClass::~cClass()" << std::endl;
}

void cClass::run()
{
    std::cout << "Methode : cClass::run()" << std::endl;
}
...

// Terminal (Exécuter le projet)

...
rdvcpp.exe
...