C++

C++
Code en C++ pour afficherHello, World!
Date de première version	1985
Paradigme	générique,orienté objet,procédural
Auteur	Bjarne Stroustrup
Dernière version	C++20 (décembre2020)
Typage	statique,unsafe,nominatif
Normes	ISO/CEI 14882:1998 ISO/CEI 14882:2003 ISO/CEI 14882:2011 ISO/CEI 14882:2014 ISO/CEI 14882:2017 ISO/IEC 14882:2020
Influencé par	C,Simula,Ada 83,Algol 68,CLU,ML
A influencé	Ada 95,C#,PHP,D,JavaScript,Java,X++,Rust
Implémentations	GNU Compiler Collection,Microsoft Visual C++,Borland C++ Builder,XCode Tools
Site web	isocpp.org
Extension de fichier	cc, cpp, cxx, c, c++, h, hpp, hh, hxx et h++

C++est unlangage de programmationcompilépermettant la programmation sous de multiplesparadigmes,dont laprogrammation procédurale,laprogrammation orientée objetet laprogrammation générique.Ses bonnesperformances,et sa compatibilité avec le langageCen font un des langages de programmation les plus utilisés dans les applications où la performance est critique.

Créé initialement parBjarne Stroustrupdans les années 1980, le langage C++ est aujourd'huinormalisépar l'ISO.Sa première normalisation date de1998(ISO/CEI 14882:1998), ensuite amendée par l'erratum technique de2003(ISO/CEI 14882:2003). Une importante mise à jour a été ratifiée et publiée par l'ISO enseptembre 2011sous le nom de ISO/IEC 14882:2011, ouC++11.Depuis, des mises à jour sont publiées régulièrement: en2014(ISO/CEI 14882:2014, ouC++14), en2017(ISO/CEI 14882:2017, ouC++17) puis en2020(ISO/IEC 14882:2020, ouC++20).

Dénomination

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

Histoire

Bjarne Stroustrup,l'inventeur du C++.

Bjarne Stroustrupcommence le développement deC with Classes(C avecclasses) en1979.Il travaille alors dans leslaboratoires Belloù il est notamment collègue de l'inventeur du CDennis 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 lelangage C.Stroustrup trouvait queSimulaavait 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émentationdu compilateurSimula), tandis queBCPLétait rapide mais de tropbas niveauet non adapté au développement de gros logiciels. Quand Stroustrup commença à travailler auxlaboratoires Bell,on lui demanda d'analyser lenoyauUNIXen vue de faire ducalcul distribué.Se rappelant sa thèse, Stroustrup commença à améliorer le langageCavec des fonctionnalités similaires à celle deSimula.C fut choisi parce qu'il est rapide,portableet 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 (avecencapsulation des données), de classe dérivée, de vérification des types renforcés (typage fort), d'«inlining», et deparamètrepar défaut.

Alors que Stroustrup développaitC with classes,il écrivit CFront, un compilateur qui générait du code source C à partir de code sourceC with classes.La première commercialisation se fit enoctobre 1985.En1983le nom « C++ » est inventé, et en1984le nom du langage passa deC with classesà celui de « C++ ». Parmi les nouvelles fonctionnalités qui furent ajoutées au langage, il y avait lesfonctions virtuelles,lasurcharge des opérateurset desfonctions,lesréférences,lesconstantes,le contrôle dutypageamélioré et les commentaires en fin de ligne. En1985fut publiée la première édition deThe C++ Programming Language,apportant ainsi une référence importante au langage qui n'avait pas encore de standard officiel. En1989,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. En1990,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 queprintfetscanf.Ensuite, parmi les ajouts les plus importants, il y avait laStandard Template Library.Après des années de travail, un comité réunissant l'ANSIet l'ISOstandardisa C++ en1998(ISO/CEI 14882:1998), l'année où le comité de standardisation se réunissait àSophia Antipolisdans 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 pos sắc de le langage C++. Il est libre de droits;cependant, le document de standardisation n'est quant à lui pas disponible gratuitement.

Fonctionnalités introduites

On pouvait considérer que C++ « était 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'identificateurscorrespondant à des mots-clefs en C++. Il est également à noter que l'architecture d'un programme C++ moderne (C++11) est differente de celle d'un programme en C.

Parmi les fonctionnalités ajoutées figurent:

• le typage des « prototypes » de fonctions (repris dans ANSI C89);
• Lasurcharge des fonctions;
• les déclarations reconnues comme instructions (repris dans C99);
• les opérateursnewetdeletepour lagestion d'allocation mémoire;
• le type de donnéesbool(booléen);
• lesréférences&;
• les variables et les fonctions membresconst(repris partiellement par C à la fin desannées 1980);
• les fonctionsinline(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::;
• lesclasses,ainsi que tout ce qui y est lié: l'héritage,les fonctions membres, les fonctions membres virtuelles, lesconstructeurset ledestructeur;
• lasurcharge des opérateurs;
• lestemplates;
• lagestion d'exceptions;
• l'identification de type pendant l'exécution (RTTI:run-time type information);
• lecommentairesur une ligne introduit par//(existant dansBCPL,repris dans C99);
• les références de rvalue&&(C++11);
• la déduction de type à la compilation viaauto(C++11);
• les expressions constantesconstexpr(C++11);
• lesfonctions lambda(C++11, étendu dans tous les standards publiés depuis);
• les bouclesforbasées sur une plage (C++11, étendu en C++20);
• les modules viaimport,exportetmodule(C++20);
• les contraintes et concepts viaconceptetrequires(C++20);
• les fonctions immédiatesconsteval(C++20);
• lescoroutines(C++20);

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

Bibliothèque standard

Labibliothèque standard du C++englobe laStandard 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 parAlexander Stepanovqui travaillait pourHewlett-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'êtreliéesexplicitement. Depuis C++20 le mot cléimportpeut servir à des fins similaires.

Programmation orientée objet

Exemple de hiérarchie de classes type stream.

Le langage C++ utilise les concepts de laprogrammation orientée objetet permet entre autres:

• la création declasses;
  • l'encapsulation;
  • des relations entre lesclasses:
    • lacomposition 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éritagesimple etmultiple(héritage dans un diagramme de classes);
• lepolymorphisme;
• l'abstraction;
• lagénéricité;
• laméta-programmation.

Encapsulation

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

«Hello, world»

Voici l'exemple deHello worlddonné dansThe C++ Programming Language, Third EditiondeBjarne Stroustrup:

#include<iostream>

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

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

Avec l'ajout des modules dans le langage et de la fonction print dans la librairie standard, l'exemple Hello World peut depuis C++23 être écrit:

importstd;

intmain()
{
std::println("Hello, World!");
}

Espace de noms

En C++, le mot clefnamespacepermet de définir et de nommer desespaces de noms(namespaces), notion déjà présente enlangage C;en effet, le corps d'uneroutine,d'unestructure de contrôle de flux d'exécution,d'unestructure de donnéesou d'une section de code (délimitée par les accolades{et}) constitue un espace de noms. En C++, le corps d'une classe, à l'instar du corps d'une structure de données, constitue aussi un espace de noms.

Dans différents espaces de noms, on peut ainsi définir des entités (routines, variables, etc.) ayant le même identificateur. L'ambiguïté est résolue en utilisant le nom de l'espace de nom devant l'opérateur de portée (::) pour indiquer l'espace de noms dans lequel on veut accéder. Notez que l'espace de noms global du programme n'a pas de nom. Pour accéder à une entité globale, cachée par une entité locale par exemple, on utilise l'opérateur de portée précédé d'aucun nom.

Directive « using »

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

usingnamespacenom_du_namespace;
// ou
usingnom_d_un_symbole;
// ou
usingenumnom_d_un_enum_class;// C++20

Ainsi, pour utiliser la variablecoutdéfinie dans lenamespacestandard sans utiliser l'opérateur de résolution de portée, il est possible d'écrireusing namespace std;ouusing 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>
usingnamespacestd;

intmain()
{
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>

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

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

Le mot-cléusingpeut 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 membresprotectedde A enpublicdans 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.
classA
{
protected:
voidf()
{
std::cout<<"A::f()\n";
}

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

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

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

// Déclaration de la classe D héritant de A.
classD:publicA
{
public:
voidg(intVal)// masque A::g()
{
std::cout<<"D::g(int)";
}
usingA::g;// démasque A::g()
};

intmain()
{
Aa;
Bb;
Cc;
Dd;

// 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:

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

Déclaration et définition de classe

Il est d'usage de séparerprototype(déclaration) etimplé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).

Déclaration de classe

Exemple de la déclaration d'une classe comportant desattributsprivés et desfonctions membrespubliques:

// messageinternet.hpp
#include<string_view>

classMessageInternet
{
private:// Ici, private: est optionnel car il est par défaut.
std::string_viewm_sujet;
std::string_viewm_expediteur;
std::string_viewm_destinataire;// attributs

public:
// constructeur
MessageInternet(
std::string_viewsujet,
std::string_viewexpediteur,
std::string_viewdestinataire);
// fonctions membres:
autosujet();
autoexpediteur();
autodestinataire();
};

Définition de classe

Le nom d'une fonction membre déclarée par une classe doit nécessairement être précédé du nom de la classe suivi de l'opérateur de résolution de portée::.

Exemple de définition des fonctions membres d'une classe (celle déclarée précédemment):

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

MessageInternet::MessageInternet(
std::string_viewsujet,
std::string_viewexpediteur,
std::string_viewdestinataire)
:m_sujet(sujet),
m_expediteur(expediteur),
m_destinataire(destinataire)
{}

autoMessageInternet::sujet(){returnm_sujet;}
autoMessageInternet::expediteur(){returnm_expediteur;}
autoMessageInternet::destinataire(){returnm_destinataire;}

Modèles

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 unefamillede fonctions ou de classes qui ne diffèrent que par le type de leurs constituants.

Paramètres des modèles

Les paramètres peuvent être de différentes sortes:

• types simples, tels que les classes ou les types élémentaires (int,double,etc.);
• tableaux de taille constante, dont la taille, déduite par le compilateur, peut être utilisée dans l'instanciation dumodèle;
• constantes scalaires, c'est-à-dire de type entier (int,char,bool), mais pas flottant (float,double) car leur représentation binaire ne fait pas partie de la norme du langage (jusqu'en C++20 où ils sont autorisés);
• templates, dont la définition doit être passée en paramètre, ce qui permet notamment de s'appuyer sur la définition abstraite, par exemple, d'une collection;
• pointeurs ou références, à condition que leur valeur soit définie à l'édition de liens;
• fonction membre d'une classe, dont la signature et la classe doivent être aussi passées en paramètres;
• attribut d'une classe, dont le type et la classe doivent être aussi passés en paramètres.

Utilité des modèles

En programmation, il faut parfois écrire de nombreuses versions d'une même fonction ou classe suivant les types de données manipulées. Par exemple, un tableau deintou un tableau dedoublesont très semblables, et les fonctions de tri ou de recherche dans ces tableaux sont identiques, la seule différence étant le type des données manipulées. En résumé, l'utilisation des templates permet de « paramétrer » le type des données manipulées.

Les avantages des modèles sont:

• des écritures uniques pour les fonctions et les classes;
• moins d'erreurs dues à la réécriture;

Exemple de modèles

Dans la bibliothèque standard C++, on trouve de nombreux templates. On citera à titre d'exemple, les entrées/sorties, les chaînes de caractères ou les conteneurs. Les classesstring,istream,ostreametiostreamsont toutes des instanciations de typechar.

Les fonctions de recherche et de tri sont aussi des templates écrits et utilisables avec de nombreux types.

#include<string>

template<typenameT>
Tmax(Ta,Tb)// Une fonction similaire est aussi définie dans le header <algorithm>
{
returna<b?b:a;
}

intmain()
{
inti=max(3,5);
charch=max('e','b');
usingnamespacestd::string_literals;
std::stringstr=max("hello"s,"world"s);
floatfp=max<float>(1,2.2f);// type paramétré donné explicitement
// (obligatoire avec ces paramètres de types différents)
}

Dans la lignefloat fp = max<float>(1, 2.2f);,on doit explicitement donner le typefloatpour le type paramétréTcar le compilateur ne déduit pas le type deTlorsqu'on passe en même temps unint(1) et unfloat(2.2f).

Spécialisation des templates

Un template donné peut avoir plusieurs instanciations possibles selon les types donnés en paramètres. Si un seul paramètre est spécialisé, on parle despécialisation partielle.Ceci permet par exemple:

• de choisir un type de calcul selon qu'un type est un entier, un flottant, une chaîne de caractères, etc. Spécialisons l'exemple précédent pour le cas des pointeurs de chaînes de caractères:

#include<cstring>

template<>
constchar*max(constchar*a,constchar*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.
returnstd::strcmp(a,b)>0?a:b;
}

• d'effectuer au moment de la compilation des calculs arithmétiques, si et seulement si tous les arguments sont connus à ce moment. Un exemple classique est le calcul de la fonctionfactorielle:

template<std::size_tN>
structFactorielle
{
staticconstexprstd::size_tvalue=N*Factorielle<N-1>::value;
};

template<>
structFactorielle<0>
{
staticconstexprstd::size_tvalue=1;
};

À partir de C++14 pour arriver aux mêmes fins nous pourrions aussi utiliser les variables templates:

template<std::size_tN>
constexprautofactorielle=N*factorielle<N-1>;

template<>
constexprautofactorielle<0>=1;

Ainsi nous pouvons écrirefactorielle<8>;à la place deFactorielle<8>::value;.

SFINAE

Le mécanisme décrit par l'abréviation SFINAE (Substitution Failure Is Not an Error) permet de surcharger un template par plusieurs classes (ou fonctions), même si certaines spécialisations, par exemple, ne peuvent pas être utilisées pour tous les paramètres de templates. Le nom décrit précisément le fonctionnement du mécanisme, littéralement l’acronyme de « Un échec de substitution n'est pas une erreur », le compilateur, lors de la substitution, ignore alors lesinstanciationsinapplicables, au lieu d'émettre une erreur de compilation. Par exemple:

#include<iostream>

classA
{
public:
intfoo()
{
return3;
}
};

classB
{
public:
intbar()
{
return5;
}
};

classC:publicA,publicB{};

template<typenameT>
autof(constT&f)->decltype(f.foo())
{
returnf.foo();
}

template<typenameT>
autof(constT&f)->decltype(f.bar())
{
returnf.bar();
}

intmain()
{
Aa{};
Bb{};

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
}

Ici f est définie deux fois, le type de retour est conditionné par le type donné en paramètre, il est du type du retour de f.foo() dans le premier cas et de celui de f.bar() dans le deuxième cas. Ainsi, si on appelle f avec un objet de la classe A, seule la première fonction fonctionne puisque la classe A n'a pas de fonction membre bar() et donc la substitution est possible avec cette première version mais pas pour la deuxième. Ainsi, f(a) appelle la première version de f, f(b) appelle la deuxième avec le même raisonnement, mais cette fois pour la fonction membre bar().

Si lors d'un développement à venir, un développeur venait à écrire une nouvelle classe ayant une fonction membre publique foo ou bien (ou exclusif) bar, il pourrait également utiliser f avec.

Polymorphisme et fonctions membres virtuelles

Lepolymorphismed'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évirtualdevant 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évirtualindique 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évirtualdevant 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 lasurcharge de fonctionqui est un polymorphismead hocest 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 desoptimisationsrendant 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'uneindirectionsupplémentaire.

Le choix entre liaison dynamique et surcharge (polymorphisme dynamique et statique) est typiquement un problème decalculabilité 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. Dansgccpar exemple, l'option-fdevirtualizelors de la compilation permet cette optimisation, s'il est possible de faire une telle résolution.

Outils de développement

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 deMakefileportable);
• Bazel.

Environnements de développement

• Anjuta DevStudio;
• C++ Builder;
• CLion(en);
• Code::Blocks(open-source);
• Dev-C++et son extensionRADWxDev-C++;
• Eclipseavec le plugin CDT(open-source);
• Emacs(libre);
• KDevelop;
• NetBeans(open-source);
• QtCreator(open-source);
• Sun Studio;
• Vim;
• Microsoft Visual C++(a été intégré au framework Visual Studio);
• Xcode.

Compilateurs

• GCC pourGNU Compiler Collection(libre,multilangageetmultiplateforme:UNIX,Windows, DOS, etc.);
• Clang;
• Microsoft Visual C++(Windows);
• Borland C++ Builder(Windows);
• Intel C++ Compiler(Windows,Linux,MacOS);
• Open64(en)compilateuropensourced'AMD (Linux);
• Digital Mars C/C++ compiler (Windows);
• Open Watcom;

Bibliothèques

• Boost;
• Qt;
• Gtkmm;
• wxWidgets;
• SFML;
• OpenCV;
• SDLmm,surcouche C++ à laSDL;
• LLVM.
• etc.

Annexes

Bibliographie

Ouvrages en langue anglaise

• [Deitel et Deitel 2011](en)P. Deitel et H. Deitel,C++: How to Program,20 Hall,2011,8^eéd.,1104p.(ISBN978-0-13-266236-9).
• [Dawson 2010](en)M. Dawson,Beginning C++ Through Game Programming,Course Technology PTR,2010,3^eéd.,432p.(ISBN978-1-4354-5742-3).
  Ouvrage pour débutants dont la pédagogie prend acte du fait que le C++ fait tourner la plupart des jeux vidéo en 2010.
• [Gregoire, Solter et Kleper 2011](en)Marc Gregoire, Nicolas A. Solter et Scott J. Kleper,Professional C++,John Wiley,octobre 2011,1104p.(ISBN978-0-470-93244-5,présentation en ligne).
  Cet ouvrage couvre la norme C++11.
• [Josuttis 2011](en)Nicolaï Josuttis,The C++ Standard Library, A Tutorial and Reference,Addison-Wesley,2011,2^eéd.,1099p.(ISBN978-0-321-62321-8,présentation en ligne).
  Cet ouvrage couvre la norme C++11.
• [Koenig et Moo 2000](en)A. Koenig et B. Moo,Accelerated C++: Practical Programming by Example,Addison-Wesley,2000,1^reéd.,352p.(ISBN978-0-201-70353-5).
• [Lippman, Lajoie et Moo 2012](en)Stanley B. Lippman, Josée Lajoie et Barbara E. Moo,C++ Primer: 5th Edition,août 2012,5^eéd.,1399p.(ISBN978-0-321-71411-4).
  Cet ouvrage couvre la norme C++11.
• [Lischner 2003](en)R. Lischner,C++ in a nutshell,O'Reilly Media,2003,1^reéd.,704p.(ISBN978-0-596-00298-5).
  L'auteur a aussi produit un petit manuel de référence sur laSTL,toujours aux éditions O'Reilly.
• [Meyers 2005](en)S. Meyers,Effective C++: 55 Specific Ways to Improve Your Programs and Designs,Addison-Wesley Professional,2005,3^eéd.,320p.(ISBN978-0-321-33487-9,présentation en ligne).
  Mêmes principes que les ouvrages de Sutter, et même public visé.
• [Oualline 2003](en)S. Oualline,Practical C++ programming,O'Reilly Media,2003,2^eéd.,600p.(ISBN978-0-596-00419-4,présentation en ligne).
• [Lafore 2001](en)R. Lafore,Object-oriented programming in C++,Sams,2001,4^eéd.,1040p.(ISBN978-0-672-32308-9).
• [Prata 2011](en)S. Prata,C++ Primer Plus (Developer's Library),Addison-Wesley Professional,2011,6^eéd.,1200p.(ISBN978-0-321-77640-2,présentation en ligne).
  Cette édition couvre les nouveautés apportées par le standard C++11.
• [Stroustrup 2009](en)Bjarne Stroustrup,Programming: Principles and Practice using C++,Addison-Wesley,2009,1236p.(ISBN978-0-321-54372-1).
• [Stroustrup 2013](en)Bjarne Stroustrup,The C++ Programming Language: 4th Edition,Addison-Wesley Professional,2013,4^eéd.,1368p.(ISBN978-0-321-56384-2).
• [Stroustrup 1994](en)Bjarne Stroustrup,The Design and Evolution of C++,Addison-Wesley professional,1994,1^reéd.,480p.(ISBN978-0-201-54330-8).
• [Sutter 1999](en)H. Sutter,Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions,Addison-Wesley Professional,1999,240p.(ISBN978-0-201-61562-3,présentation en ligne).
  Publié aux éditions Eyrolles en 2000 sous le titreMieux programmer en C++ - 47 problèmes pratiques résolus.Herb Sutter, spécialiste reconnu du C++, a produit deux suites à ce premier ouvrage, toujours basées sur des études de cas, à savoir:More exceptional C++(Addison-Wesley - 2001) etExceptional C++ style(Addison-Wesley - 2004). Tous ces ouvrages concernent à priori des développeurs confirmés maîtrisant bien le langage C++.
• [Vandevoorde et Josuttis 2002](en)David Vandevoorde et Nicolaï Josuttis,C++ Templates: the Complete Guide,Addison-Weslay,2002,528p.(ISBN978-0-201-73484-3).
• [Vandevoorde 1998](en)David Vandevoorde,C++ Solutions: Companion to the C++ Programming Language,Addison-Wesley,1998,3^eéd.,292p.(ISBN978-0-201-30965-2).
  Contient la correction de nombre des exercices de l'ouvrage de Stroustrup,Le langage C++.

Ouvrages en langue française

• [Benharrats et Vittupier 2021]Mehdi Benharrat et Benoît Vittupier,Le guide du C++ moderne: de débutant à développeur,D-Booker,2021,1^reéd.,708p.(ISBN978-2-8227-0881-4,présentation en ligne).
• [Chappelier et Seydoux 2005]J-C. Chappelier et F. Seydoux,C++ par la pratique: Recueil d'exercices corrigés et aide-mémoire,PPUR,2005,2^eéd.,412p.(ISBN978-2-88074-732-9,présentation en ligne).
• [Deitel et Deitel 2004]P. Deitel et H. Deitel,Comment programmer en C++,Reynald Goulet,2004,1178p.(ISBN978-2-89377-290-5).
  La dernière traduction disponible de l'ouvrage des Deitel père et fils; correspond à la troisième édition en langue anglaise.
• [Delannoy 2001]ClaudeDelannoy,Programmer en langage C++,Paris, Eyrolles,2011,8^eéd.,822p.(ISBN978-2-212-12976-2,présentation en ligne).
• [Delannoy 2007]ClaudeDelannoy,Exercices en langage C++,Paris, Eyrolles,2007,3^eéd.,336p.(ISBN978-2-212-12201-5,présentation en ligne).
• [Géron et Tawbi 2003]AurélienGéronet Fatmé Tawbi (préf.Gilles Clavel),Pour mieux développer avec C++: Design patterns, STL, RTTI et smart pointers,Paris, Dunod,2003,188p.(ISBN978-2-10-007348-1).
• [Guidet 2008]AlexandreGuidet,Programmation objet en langage C++,Paris, Ellipses,coll.« Cours et exercices. »,2008,364p.(ISBN978-2-7298-3693-1,OCLC221607125,BNF41206426).
• [Hubbard 2002]J. R.Hubbard(trad.Virginie Maréchal),C++[« Schaum's easy outline of programming with C++ »], Paris, EdiScience,coll.« Mini Schaum's »,2002,192p.(ISBN978-2-10-006510-3).
  Pour débutants pressés.
• [Liberty et Jones 2005]JesseLibertyet Bradley Jones (trad.Nathalie Le Guillou de Penanros),Le langage C++[« Teach yourself C++ in 21 days »], Paris, CampusPress,2005,859p.(ISBN978-2-7440-1928-9).
• [Stephens, Diggins, Turkaniset al.2006]D. RyanStephens,Christopher Diggins, Jonathan Turkanis et J. Cogswell (trad.Yves Baily & Dalil Djidel),C++ en action[« C++ Cookbook - Solutions and Examples for C++ Programmers »], Paris, O'Reilly,2006,555p.(ISBN978-2-84177-407-4,OCLC717532188,BNF40170870).
• [Stroustrup 2012]Bjarne Stroustrup(trad.Marie-Cécile Baland, Emmanuelle Burr, Christine Eberhardt),Programmation: principes et pratique avec C++: Avec plus de 1000 exercices.[« Programming: principles and practice using C++ »], Paris, Pearson education,2012,944p.(ISBN978-2-7440-7718-0).
• [Stroustrup 2003]Bjarne Stroustrup(trad.Christine Eberhardt),Le langage C++[« The C++ programming language »], Paris, Pearson education,2003,1098p.(ISBN978-2-7440-7003-7et2-744-07003-3).
• [Sutter et Alexandrescu 2005]HerbSutteret Andrei Alexandrescu,Standards de programmation C[« C++ Coding Standards: 101 Rules, Guidelines, and Best Practices »], Paris, Pearson Education France,coll.« C++ »,2005,243p.(ISBN978-2-7440-7144-7et2-744-07144-7).

Articles connexes

• Langage C

Liens externes

• (en)Le Comité du Standard C++
• (fr)Documentation du C++(wiki sous double licenceCC-BY-SAetGFDL)
• (en)Documentation du C++(le même wiki mais en anglais et plus complet)
• (en)Documentation du C++(contenu non libre, édité parThe C++ ressources network)