C++

En langage C, ++ est l'opérateur d'incrémentation, c'est-à-dire l'augmentation de la valeur d'une variable de 1. C'est pourquoi C++ porte ce nom : cela signifie que C++ est un niveau au-dessus de C.

Bjarne Stroustrup, l'inventeur du C++.

Bjarne Stroustrup commence le développement de C with Classes (C avec classes) en 1979[7]. Il travaille alors dans les laboratoires Bell où il est notamment collègue de l'inventeur du C Dennis Ritchie. L'idée de créer un nouveau langage venait de l'expérience en programmation de Stroustrup pour sa thèse de doctorat. Il s'agissait en l'occurrence d'améliorer le langage C. Stroustrup trouvait que Simula avait des fonctionnalités très utiles pour le développement de gros programmes mais qu'il était trop lent pour être utilisé en pratique (cela était dû à un problème d'implémentation du compilateur Simula), tandis que BCPL était rapide mais de trop bas niveau et non adapté au développement de gros logiciels. Quand Stroustrup commença à travailler aux laboratoires Bell, on lui demanda d'analyser le noyau UNIX en vue de faire du calcul distribué. Se rappelant sa thèse, Stroustrup commença à améliorer le langage C avec des fonctionnalités similaires à celle de Simula. C fut choisi parce qu'il est rapide, portable et d'usage général. En outre, il était une bonne base pour le principe original et fondateur de C++ : « vous ne payez pas pour ce que vous n'utilisez pas ». Dès le départ, le langage ajoutait à C la notion de classe (avec encapsulation des données), de classe dérivée, de vérification des types renforcés (typage fort), d'« inlining », et d'argument par défaut.

Alors que Stroustrup développait C with classes, il écrivit CFront, un compilateur qui générait du code source C à partir de code source C with classes. La première commercialisation se fit en octobre 1985. En 1983 le nom « C++ » est inventé, et en 1984 le nom du langage passa de C with classes à celui de « C++ ». Parmi les nouvelles fonctionnalités qui furent ajoutées au langage, il y avait les fonctions virtuelles, la surcharge des opérateurs et des fonctions, les références, les constantes, le contrôle du typage amélioré et les commentaires en fin de ligne. En 1985 fut publiée la première édition de The C++ Programming Language, apportant ainsi une référence importante au langage qui n'avait pas encore de standard officiel. En 1989, c'est la sortie de la version 2.0 de C++. Parmi les nouvelles fonctionnalités, il y avait l'héritage multiple, les classes abstraites, les fonctions membres statiques, les fonctions membres constantes, et les membres protégés. En 1990, The Annotated C++ Reference Manual (« ARM ») fut publié apportant les bases du futur standard. Les ajouts de fonctionnalités tardifs qu'il comportait couvraient les templates, les exceptions, les espaces de noms, les nouvelles conversions et le type booléen.

Pendant l'évolution du langage C++, la bibliothèque standard évoluait de concert. Le premier ajout à la bibliothèque standard du C++ concernait les flux d'entrées/sorties qui apportaient les fonctionnalités nécessaires au remplacement des fonctions C traditionnelles telles que printf et scanf. Ensuite, parmi les ajouts les plus importants, il y avait la Standard Template Library. Après des années de travail, un comité réunissant l'ANSI et l'ISO standardisa C++ en 1998 (ISO/CEI 14882:1998), l'année où le comité de standardisation se réunissait à Sophia Antipolis dans le sud de la France. Pendant quelques années après la sortie officielle du standard, le comité traita des problèmes remontés par les utilisateurs, et publia en 2003 une version corrigée du standard C++.

Personne ne possède le langage C++. Il est libre de droits[8] ; cependant, le document de standardisation n'est quant à lui pas disponible gratuitement.

On peut considérer que C++ « est du C » avec un ajout de fonctionnalités. Cependant, plusieurs programmes syntaxiquement corrects en C ne le sont pas en C++, à commencer bien sûr par ceux qui font usage d'identificateurs correspondant à des mots-clefs en C++.

Parmi les fonctionnalités ajoutées figurent :

• le typage des « prototypes » de fonctions (repris dans ANSI C89) ;
• La surcharge des fonctions ;
• les déclarations reconnues comme instructions (repris dans C99) ;
• les opérateurs new et delete pour la gestion d'allocation mémoire ;
• le type de données bool (booléen) ;
• les références & [9];
• les variables et les fonctions membres const (repris partiellement par C à la fin des années 1980) ;
• les fonctions inline (repris dans C99) ;
• les paramètres par défaut dans les fonctions ;
• les référentiels lexicaux (espaces de noms) et l'opérateur de résolution de portée :: ;
• les classes, ainsi que tout ce qui y est lié : l'héritage, les fonctions membres, les fonctions membres virtuelles, les constructeurs et le destructeur ;
• la surcharge des opérateurs ;
• les templates ;
• la gestion d'exceptions ;
• l'identification de type pendant l'exécution (RTTI : run-time type information) ;
• le commentaire sur une ligne introduit par // (existant dans BCPL, repris dans C99) ;
• les références de rvalue && (C++11) ;
• la déduction de type à la compilation via auto (C++11) ;
• les expressions constantes constexpr (C++11)[10];
• les fonctions lambda (C++11, étendu dans tous les standards publiés depuis) ;
• les boucles for basées sur une plage (C++11, étendu en C++20) ;
• les modules via import, export et module (C++20) ;
• les contraintes et concepts via concept et requires (C++20) ;
• les fonctions immédiates consteval (C++20) ;
• les coroutines (C++20) ;

La compilation d'un programme en C++ effectue également un contrôle plus minutieux du typage.

La bibliothèque standard du C++ englobe la Standard Template Library (STL) qui met à la disposition du programmeur des outils puissants comme des collections (conteneurs) et des itérateurs.

À l'origine, la STL était une bibliothèque développée par Alexander Stepanov qui travaillait pour Hewlett-Packard. Dans la norme, celle-ci n'est pas appelée STL, car elle est considérée comme faisant partie de la bibliothèque standard de C++. Toutefois, beaucoup de personnes l'appellent encore de cette manière pour distinguer d'une part, les fonctions d'entrées/sorties comprises dans cette bibliothèque et, d'autre part, celles fournies par la bibliothèque C.

Comme en C, l'utilisation d'une bibliothèque peut se faire par l'intermédiaire de la directive #include (suivie du nom du fichier d'en-tête), et certaines d'entre elles (cmath, thread, etc.) nécessitent d'être liées explicitement. Depuis C++20 le mot clé import peut servir à des fins similaires.

Exemple de hiérarchie de classes type stream.

Le langage C++ utilise les concepts de la programmation orientée objet et permet entre autres :

• la création de classes ;
  • l'encapsulation ;
  • des relations entre les classes :
    • la composition de classes (composition dans un diagramme de classes),
    • l'association de classes (en) (association dans un diagramme de classes),
    • l'agrégation de classes (agrégation dans un diagramme de classes),
    • la dépendance (dépendance dans un diagramme de classes),
    • l'héritage simple et multiple (héritage dans un diagramme de classes) ;
• le polymorphisme ;
• l'abstraction ;
• la généricité ;
• la méta-programmation.

L'encapsulation permet de faire abstraction du fonctionnement interne (c'est-à-dire, la mise en œuvre) d'une classe et ainsi de ne se préoccuper que des services rendus par celle-ci. C++ met en œuvre l'encapsulation en permettant de déclarer les membres d'une classe avec le mot réservé public, private ou protected. Ainsi, lorsqu'un membre est déclaré :

• public, il sera accessible depuis n'importe quelle fonction ;
• private, il sera uniquement accessible d'une part, depuis les fonctions qui sont membres de la classe et, d'autre part, depuis les fonctions autorisées explicitement par la classe (par l'intermédiaire du mot réservé friend) ;
• protected, il aura les mêmes restrictions que s'il était déclaré private, mais il sera en revanche accessible par les classes filles.

C++ n'impose pas l'encapsulation des membres dans leurs classes. On pourrait donc déclarer tous les membres publics, mais en perdant une partie des bénéfices apportés par la programmation orientée objet. Il est de bon usage de déclarer toutes les données privées, ou au moins protégées, et de rendre publiques les fonctions membres agissant sur ces données. Ceci permet de cacher les détails de la mise en œuvre de la classe.

Voici l'exemple de Hello world donné dans The C++ Programming Language, Third Edition[11] de Bjarne Stroustrup :

#include<iostream>

int main()
{
    std::cout << "Hello, new world!\n";
}

Dans l'exemple ci-dessus, le code source std::cout << "Hello, new world!\n" envoie la chaîne de caractères "Hello, new world!\n" à l'objet global cout, défini dans l'espace de noms standard std, grâce à l'opérateur << de cout.

Il est possible de spécifier un espace de noms précis à utiliser afin d'éviter d'avoir à recourir à l'opérateur de résolution de portée. Pour cela, le mot-clé using est utilisé avec cette syntaxe :

using namespace nom_du_namespace;
// ou
using nom_d_un_symbole;
// ou
using enum nom_d_un_enum_class; // C++20

Ainsi, pour utiliser la variable cout définie dans le namespace standard sans utiliser l'opérateur de résolution de portée, il est possible d'écrire using namespace std; ou using std::cout;. Cela est valable pour tous les espaces de noms. Cette instruction se place en général avant le début du code source proprement dit :

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello, new world!\n";
}

Il est aussi possible, et conseillé, d'importer un symbole particulier, ou de placer cette instruction dans une fonction afin de limiter la portée :

#include <iostream>

int main()
{
    using std::cout;
    // std::cout est disponible sans utilisation de std::
    cout << "Hello, new world!" << std::endl; // mais pas std::endl (endline)
}

void foo()
{
    // std::cout n'est plus disponible sans utilisation de std::
    std::cout << "Hello, new world!" << std::endl;
}

Le mot-clé using peut aussi être utilisé dans les classes. Si une classe B hérite d'une classe A, elle peut grâce à ce mot-clé passer des membres protected de A en public dans B, ou encore démasquer une fonction membre de A qui le serait par une fonction membre de B de même nom :

#include <iostream> 

// Déclaration de la classe de base A.
class A
{
protected:
    void f()
    {
        std::cout << "A::f()\n";
    }

public:
    void g()
    {
        std::cout << "A::g()\n";
    }
};

// Déclaration de la classe B héritant de A.
class B : public A
{
public:
    using A::f; // rend public A::f()
};

// Déclaration de la classe C héritant de A.
class C: public A
{
public:
    void g(int Val) // masque A::g()
    {
        std::cout << "C::g(int)\n";
    }
};

// Déclaration de la classe D héritant de A.
class D: public A
{
public:
    void g(int Val) // masque A::g()
    {
        std::cout << "D::g(int)";
    }
    using A::g;      // démasque A::g()
};

int main()
{
    A a;
    B b;
    C c;
    D d;

    // a.f();  // impossible car f est protégé dans A
    a.g();

    b.f();  // possible car A::f est publique dans B.

    // c.g();  // impossible car A::g() est masquée par C::g(int) dans C
    c.g(6); // possible car C::g(int Val) est masquée par C::g(int) dans C

    d.g();  // possible car A::g() est démasquée dans D
    d.g(5); // possible car D::g() est démasquée dans D
}

Le programme ci-dessus affiche :

A::g()
A::f()
C::g(int)
A::g()
D::g(int)

Il est aussi possible de définir un nouveau nom pour un namespace :

namespace fs = std::filesystem;
// on peut alors écrire fs::path au lieu de std::filesystem::path

Il est d'usage de séparer prototype (déclaration) et implémentation (définition) de classe dans deux fichiers : la déclaration se fait dans un fichier d'en-tête (dont l'extension varie selon les préférences des développeurs : sans extension dans le standard, .h comme en C, .hh ou .hpp ou .hxx pour différencier le code source C++ du C) alors que la définition se fait dans un fichier source (d'extension également variable : .c comme en C, .cc ou .cpp ou .cxx pour différencier C++ du C).

// messageinternet.hpp
#include <string_view>

class MessageInternet
{
private: // Ici, private: est optionnel car il est par défaut.
    std::string_view m_sujet;
    std::string_view m_expediteur;
    std::string_view m_destinataire; // attributs
    
public:
    // constructeur
    MessageInternet(
        std::string_view sujet,
        std::string_view expediteur,
        std::string_view destinataire);
    // fonctions membres :
    auto sujet();
    auto expediteur();
    auto destinataire();
};

// messageinternet.cpp
#include "messageinternet.hpp"

MessageInternet::MessageInternet(
    std::string_view sujet,
    std::string_view expediteur,
    std::string_view destinataire)
        : m_sujet(sujet),
          m_expediteur(expediteur),
          m_destinataire(destinataire)
    {}

auto MessageInternet::sujet() { return m_sujet; }
auto MessageInternet::expediteur() { return m_expediteur; }
auto MessageInternet::destinataire() { return m_destinataire; }

Les Modèles (ou templates) permettent d'écrire des variables, des fonctions et des classes en paramétrant le type de certains de leurs constituants (type des paramètres ou type de retour pour une fonction, type des éléments pour une classe collection par exemple). Les modèles permettent d'écrire du code générique, c'est-à-dire qui peut servir pour une famille de fonctions ou de classes qui ne diffèrent que par le type de leurs constituants.

#include <string>

template<typename T>
T max(T a, T b) // Une fonction similaire est aussi définie dans le header <algorithm>
{
    return a < b ? b : a;
}

int main()
{
    int i = max(3, 5);
    char ch = max('e', 'b');
    using namespace std::string_literals;
    std::string str = max("hello"s, "world"s);
    float fp = max<float>(1, 2.2f); // type paramétré donné explicitement
                                  // (obligatoire avec ces paramètres de types différents)
}

#include <cstring>

template<>
const char* max(const char* a, const char* b)
{
    // Normalement, le résultat d'une comparaison directe
    // entre deux chaînes de caractères est un comportement non défini;
    // utiliser std::strcmp le rend défini.
    return std::strcmp(a, b) > 0 ? a : b;
}

template<std::size_t N>
struct Factorielle
{
    static constexpr std::size_t value = N * Factorielle<N - 1>::value;
};

template<>
struct Factorielle<0>
{
    static constexpr std::size_t value = 1;
};

template<std::size_t N>
constexpr auto factorielle = N * factorielle<N - 1>;

template<>
constexpr auto factorielle<0> = 1;

#include <iostream>

class A 
{
public:
    int foo()
    {
        return 3;
    }
};

class B
{
public:
    int bar()
    {
        return 5;
    }
};

class C : public A, public B {};

template <typename T>
auto f(const T& f) -> decltype(f.foo())
{
    return f.foo();
}

template <typename T>
auto f(const T& f) -> decltype(f.bar())
{
    return f.bar();
}

int main()
{
    A a{};
    B b{};
    
    std::cout << f(a) << '\n'; // affiche 3 en appellant a.foo()
    std::cout << f(b) << '\n'; // affiche 5 en appellant b.bar()
    // std::cout << f(C{}) << '\n'; // ne compile pas, en effet, C a les deux
                                    // fonctions membres, ainsi la déduction est
                                    // ambigue
    // std::cout << f(5) << '\n'; // ne compile pas, en effet, int n'a aucune des
                                 // deux fonctions membre
}

Le polymorphisme d'inclusion est mis en œuvre à l'aide du mécanisme des fonctions membres virtuelles en C++. Une fonction membre est rendue virtuelle par le placement du mot-clé virtual devant la déclaration de la fonction membre dans la classe. Lorsqu'une fonction membre virtuelle est appelée, l'implémentation de la fonction membre exécutée est choisie en fonction du type réel de l'objet. L'appel n'est donc résolu qu'à l'exécution, le type de l'objet ne pouvant pas a priori être connu à la compilation.

Le mot-clé virtual indique au compilateur que la fonction membre déclarée virtuelle est susceptible d'être redéfinie dans une classe dérivée. Il suffit alors de dériver une classe et de définir une nouvelle fonction membre de même signature (même nom, paramètres compatibles — voir la notion de covariance). Ainsi l'appel de cette fonction membre sur un objet accédé en tant qu'objet de la classe de base mais appartenant en réalité à la classe dérivée donnera lieu à l'appel de la fonction membre définie dans la classe dérivée.

En particulier, il est obligatoire d'utiliser le mot-clé virtual devant la déclaration du destructeur de la classe de base lorsque le programme souhaite pouvoir détruire un objet via un pointeur d'instance de la classe de base au lieu d'un pointeur d'instance de la classe dérivée.

Ce type de polymorphisme (le polymorphisme d'inclusion) est dit dynamique. Le mécanisme de la surcharge de fonction qui est un polymorphisme ad hoc est de type statique. Dans les deux cas il faut appliquer une logique (par exemple : le nombre et le type des paramètres) pour résoudre l'appel. Dans le cas de la surcharge de fonction, la logique est entièrement calculée à la compilation. Ce calcul permet des optimisations rendant le polymorphisme statique plus rapide que sa version dynamique. La liaison dynamique de fonctions membres issues du mécanisme des fonctions membres virtuelles induit souvent une table cachée de résolution des appels, la table virtuelle. Cette table virtuelle augmente le temps nécessaire à l'appel de fonction membre à l'exécution par l'ajout d'une indirection supplémentaire.

Le choix entre liaison dynamique et surcharge (polymorphisme dynamique et statique) est typiquement un problème de calculabilité des appels, ayant souvent pour conséquence finale un choix entre expressivité et performance.

Malgré ce dynamisme, il est à noter que le compilateur est capable de « dévirtualiser » les appels de fonctions membres qui peuvent être résolus au moment de la compilation. Dans gcc par exemple, l'option -fdevirtualize lors de la compilation permet cette optimisation, s'il est possible de faire une telle résolution[13].

Un programme C++ peut être produit avec des outils qui automatisent le processus de construction. Les plus utilisés sont :

• make ;
• Ant (génération portable en XML) ;
• SCons (génération portable en Python) ;
• CMake (génération de Makefile portable).