C++

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
C++
Logo.

Apparu en 1983[1] (dernière révision en 2011 et prochaines révisions prévues pour 2014 et 2017)
Auteur Bjarne Stroustrup
Paradigme générique, orienté objet, procédural
Typage statique, unsafe, nominatif
Normes ISO/CEI 14882:1998
ISO/CEI 14882:2003
ISO/CEI 14882:2011
Influencé par C, Simula, Ada 83, Algol 68, CLU, ML
A influencé Ada 95, C#, PHP, D, JavaScript, Java, X++
Implémentations GNU Compiler Collection, Microsoft Visual C++, Borland C++ Builder, XCode Tools

Le C++ est un langage de programmation permettant la programmation sous de multiples paradigmes comme la programmation procédurale, la programmation orientée objet et la programmation générique. Le langage C++ n'appartient à personne et par conséquent n'importe qui peut l'utiliser sans besoin d'une autorisation ou obligation de payer pour avoir le droit d'utilisation.

C++ est l'un des langages de programmation les plus populaires, avec une grande variété de plateformes matérielles et de systèmes d'exploitation.

Histoire[modifier | modifier le code]

Bjarne Stroustrup, l'inventeur du C++

Bjarne Stroustrup a développé C++ au cours des années 1980, alors qu'il travaillait dans le laboratoire de recherche Bell d'AT&T. Il s'agissait en l'occurrence d'améliorer le langage C. Il l'avait d'ailleurs nommé C with classes (« C avec des classes »). Les premières améliorations se concrétisèrent donc par la prise en charge des classes, ainsi que par de nombreuses autres fonctionnalités comme les fonctions virtuelles, la surcharge des opérateurs, l'héritage (simple ou multiple), les « templates », la gestion des exceptions, etc.

Le langage C++ est normalisé par l'ISO. Sa première normalisation date de 1998 (ISO/CEI 14882:1998). Le standard a ensuite été amendé par l'erratum technique de 2003 ISO/CEI 14882:2003. Le standard actuel a été ratifié et publié par ISO en septembre 2011 sous le nom de ISO/IEC 14882:2011. (aussi appelé C++11)[2]. Les prochains standards du langage devraient être publiés en 2014 (mise à jour mineure) et en 2017[3].

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 du C. Il existe de nombreuses bibliothèques C++ en plus de la bibliothèque standard de C++ (C++ Standard Library) qui est incluse dans la norme. Par ailleurs, C++ permet l'utilisation de l'ensemble des bibliothèques C existantes.

Fonctionnalités introduites par C++[modifier | modifier le code]

On peut considérer que C++ « est du C » avec un ajout de fonctionnalités. Cependant, certains programmes syntaxiquement corrects en C ne le sont pas en C++.

Les fonctionnalités ajoutées sont :

  • 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 ;
  • le mot clé const pour définir des constantes (repris 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 (Espace de noms) et l'opérateur de résolution :: ;
  • 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 fonctions lambda (C++11);

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

Histoire du C++[modifier | modifier le code]

Stroustrup a commencé à travailler sur C avec classes en 1979. L'idée de créer un nouveau langage vient de l'expérience en programmation de Stroustrup pour sa thèse de doctorat. 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.

Comme Stroustrup développait C avec classes, il écrivit CFront, un compilateur qui générait du code source C à partir de code source C avec classes. La première commercialisation se fit en octobre 1985.

En 1983, le nom du langage passa de C avec 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 modèles, les exceptions, les espaces de noms, les nouvelles conversions et le type booléen.

Comme le langage C++ évoluait, la bibliothèque standard évoluait de concert. La première addition à la bibliothèque standard de 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 additions les plus importantes, 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 le rapport de problèmes et publia une version corrigée du standard C++ en 2003.

Personne ne possède le langage C++. Il est libre de droit. Le document de standardisation n'est quant à lui pas disponible gratuitement.

La bibliothèque standard (C++ standard library)[modifier | modifier le code]

La bibliothèque standard du C++ est en grande partie un sur-ensemble des fonctions disponibles dans la bibliothèque standard du C. Elle englobe la Standard Template Library (STL) qui met à la disposition du programmeur des outils puissants comme les collections (conteneurs) et les 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 du 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 se fait par l'intermédiaire de la directive #include (suivie du nom du fichier d'en-tête), et certaines d'entre elles (cmath, thread, ...) nécessitent d'être liées explicitement.

La programmation orientée objet en C++[modifier | modifier le code]

Exemple de hiérarchie de classes type stream

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

L'encapsulation en C++[modifier | modifier le code]

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 méthodes agissant sur ces données. Ceci permet de cacher les détails de la mise en œuvre de la classe.

« Hello, world »[modifier | modifier le code]

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

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

Une importante notion de C++ sont les espaces de noms (namespaces). Dans un espace de noms sont définis des noms de fonctions et de variables. Ce mécanisme permet de résoudre les ambiguïtés lorsque plusieurs variables provenant de différents composants sont homonymes. Pour recourir à une fonction d'un espace de nom, l'opérateur de résolution de portée « :: » est utilisé.

std::cout

Ce code source fait appel à la variable globale cout définie dans l'espace de nom standard (std).

La directive using[modifier | modifier le code]

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;

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 !" << endl;
}

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;
    cout << "Hello, new world !" // std::cout est disponible sans utilisation de std::
         << std::endl;           // mais pas std::endl
}
 
void foo() {
    std::cout << "Hello, new world !" // std::cout n'est plus disponible sans utilisation de std::
         << std::endl;
}

using peut aussi être utilisé dans les classes. Si une classe B hérite d'une classe A, elle peut passer des attributs protected en public et il est possible de démasquer une fonction de A qui le serait par une fonction de même nom de B :

class A {
  protected:
  void f();
 
  public:
  void g();
};
 
class B: public A {
  public:
  using A::f;
};
 
class C: public A {
  public:
  void g(int); // masque A::g(void)
};
 
class D: public A {
  public:
  void g(int); // masque A::g(void)
  using A::g;  // rend disponible A::g(void)
};
 
//quelque part dans le code
B b;
b.f(); // cet appel est possible
A a;
a.f(); // cet appel est impossible (membre de classe non accessible)
D d;
d.g(); // cet appel est possible (appel A::g(void))
C c;
c.g(); // cet appel est impossible (A::g(void) masqué par C::g(int))

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

namespace po = boost::program_options;
// il est à présent possible décrire po::option au lieu de boost::program_options::option

Déclaration et définition de classe[modifier | modifier le code]

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 pour différencier C et C++) alors que la définition de la classe se fera dans un fichier source (d'extension également variable, en général .C, .cc, .cpp ou .cxx).

Déclaration de classe[modifier | modifier le code]

Exemple de la déclaration de la classe MessageInternet comportant des attributs privés et des méthodes publiques dont le constructeur 'MessageInternet' :

// messageinternet.hpp
#include <string>
 
class MessageInternet
{
private:
   const std::string m_sujet, m_expediteur, m_destinataire; //attributs : toujours privés
 
public:
   MessageInternet(
      const std::string& sujet,
      const std::string& expediteur,
      const std::string& destinataire
   ); //constructeur
   const std::string& get_sujet() const; //méthode publique
   const std::string& get_expediteur() const; //méthode publique
   const std::string& get_destinataire() const; //méthode publique
};

Implémentation (définition) de classe[modifier | modifier le code]

Dans le fichier source, le nom d'une méthode définie par une classe doit nécessairement être précédé du nom de la classe suivi immédiatement des caractères "::".

Par exemple, voici l'implémentation (définition) de la classe déclarée précédemment :

//messageinternet.cpp
#include "messageinternet.hpp"
 
//constructeur
MessageInternet::MessageInternet(
    const std::string& sujet,
    const std::string& expediteur,
    const std::string& destinataire
)
:   m_sujet(sujet)
,   m_expediteur(expediteur)
,   m_destinataire(destinataire)
{
}
 
MessageInternet::~MessageInternet()
{
    //destructeur : libérer ici les ressources acquises. Dans notre cas, il n'y a rien à faire.
}
 
const std::string& MessageInternet::get_sujet() const
{
    return m_sujet;
}
 
const std::string& MessageInternet::get_expediteur() const
{
    return m_expediteur;
}
 
const std::string& MessageInternet::get_destinataire() const
{
    return m_destinataire;
}

Templates[modifier | modifier le code]

À quoi servent les templates ?[modifier | modifier le code]

Les templates permettent d'écrire 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 templates 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 la valeur de ces paramètres.

Paramètres des templates[modifier | modifier le code]

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

  • Types simples : class, struct, types élémentaires comme int, float, etc.
  • Tableaux de taille constante, dont la taille, déduite par le compilateur, peut être utilisée dans l'instanciation du template.
  • Constantes scalaires, c'est-à-dire de type dérivant des entiers (int, long, bool), mais pas double ou float (car leur représentation binaire ne fait pas partie de la norme du langage C++).
  • Templates : La définition d'un template peut être passée à un template, ce qui permet notamment de s'appuyer sur la définition abstraite, par exemple, d'un conteneur.
  • Pointeurs ou références, à condition que leur valeur soit définie à l'édition de liens.
  • Fonction membre, dont la signature et la classe doivent être aussi passées en paramètres.
  • Membre d'une classe, dont le type et la classe doivent être aussi passés en paramètres du template.

Pourquoi utiliser des templates ?[modifier | modifier le code]

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 de int ou un tableau de double sont 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.

Avantages à utiliser des templates[modifier | modifier le code]

  • écritures uniques pour les fonctions et les classes.
  • moins d'erreurs dues à la réécriture.
  • performances améliorées grâce à la spécialisation en fonction des types de données.

Exemple de templates[modifier | modifier le code]

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 classes string, istream, ostream et iostream sont toutes des instanciations de type char.

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

// La fonction template max peut être appelée avec tout type copiable
// et comparable avec l'opérateur <.
template <typename T>
T max(T a, T b)
{
    return a < b ? b : a;
}
 
# include <string>
int main()  // fonction main
{
    int i = max(3, 5);
    char c = max('e', 'b');
    std::string s = max(std::string("hello"), std::string("world"));
    float f = max<float>(1, 2.2f);
    return 0;
}

Dans la ligne float f = max<float>(1, 2.2f), on doit explicitement donner le type float pour le type paramétré T car le compilateur ne déduit pas le type de T lorsqu'on passe en même temps un int (1) et un float (2.2f).

Spécialisation des templates[modifier | modifier le code]

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

  • De choisir un type de calcul selon qu'un type est un entier, un nombre flottant, une chaîne de caractères, etc. Spécialisons l'exemple précédent pour le cas des pointeurs de chaines de caractères :
template <> const char* max(const char* a, const char* b)
{
    return (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 fonction factorielle:
template <size_t N>
struct CalcCompileTime
{
    const static size_t Fact = N * CalcCompileTime<N - 1>::Fact ;
};
 
template < >
struct CalcCompileTime <0>
{
    const static size_t Fact = 1 ;
};

SFINAE[modifier | modifier le code]

Le mécanisme décrit par l'abréviation SFINAE (Substitution Failure Is Not An Error) permet de surcharger un template par plusieurs classes, même si certaines spécialisations, par exemple, ne peuvent pas être utilisées pour tous les paramètres de templates. Le compilateur, lors de la substitution, ignore alors les instantiations inapplicables, au lieu d'émettre une erreur de compilation.

Le polymorphisme et les méthodes virtuelles en C++[modifier | modifier le code]

Le polymorphisme est mis en œuvre à l'aide du mécanisme des méthodes virtuelles en C++. Lorsqu'une méthode virtuelle est appelée, l'implémentation de la méthode 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. Un mot clé est alors introduit : virtual. Ce mot clé est placé devant la déclaration de la méthode.

Le mot clé virtual, placé devant le prototype de la fonction, indique au compilateur que la fonction 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 de même signature (même nom, paramètres compatibles - voir la notion de covariance). Ainsi l'appel de cette fonction sur un objet dont on ignore le type, mais accédé en tant qu'objet de la classe de base, pourra donner lieu à l'appel de la fonction définie dans la classe dérivée.

Il est généralement conseillé d'utiliser le mot clé virtual devant la déclaration du destructeur de la classe de base, afin que celui des sous-classes soit appelé également lorsque le programme utilise un pointeur d'instance de la classe de base au lieu d'un pointeur d'instance de la classe dérivée si et seulement si la classe de base peut être utilisée pour manipuler des classes dérivées.

Ce type de polymorphisme est dit dynamique. Le mécanisme de la surcharge est un polymorphisme 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, la logique peut être 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 méthodes issues du mécanisme des méthodes virtuelles induit souvent une table cachée de résolution des appels. Cette table cachée des méthodes augmente le temps nécessaire à l'appel de méthode à 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.

Bibliographie[modifier | modifier le code]

Ouvrages en langue anglaise[modifier | modifier le code]

  • Deitel P., Deitel H., C++ How to program, 20 Hall, 2011 (8th edition), (ISBN 978-0-132-66236-9), 1104 pages
  • Dawson M., Beginning C++ Through Game Programming, Course Technology PTR, 2010 (3rd edition), (ISBN 978-1-435-45742-3), 432 pages. Ouvrage pour débutants dont la pédagogie prend acte du fait que le C++ fait tourner la plupart des jeux vidéo actuels.
  • Marc Gregoire, Nicolas A. Solter, Scott J. Kleper, Professional C++, John Wiley, October 2011, (ISBN 978-0470932445), 1104 pages. Cet ouvrage couvre la norme C++11.
  • Nicolaï Josuttis, The C++ Standard Library, A Tutorial and Reference, Addison-Wesley, 2011, Seconde Édition Révisée, (ISBN 978-0-321-62321-8), 1099 pages. Cet ouvrage couvre la norme C++11.
  • Koenig A., Moo B., Accelerated C++ - Practical Programming by Example, Addison-Wesley, 2000 (1st edition), (ISBN 978-0-201-70353-5), 352 pages
  • Stanley B. Lippman, Josée Lajoie, Barbara E. Moo, C++ Primer, août 2012, (5th edition), (ISBN 978-0-321-71411-4). Cet ouvrage couvre la norme C++11.
  • Lischner R., C++ in a nutshell, O'Reilly Media, 2003 (1st edition), (ISBN 978-0-596-00298-5), 704 pages. L'auteur a aussi produit un petit manuel de référence sur la STL, toujours aux éditions O'Reilly.
  • Meyers S., Effective C++ - 55 Specific Ways to Improve Your Programs and Designs, Addison-Wesley Professional, 2005 (3rd edition), (ISBN 978-0-321-33487-9), 320 pages. Mêmes principes que les ouvrages de Sutter, et même public visé.
  • Oualline S., Practical C++ programming, O'Reilly Media, 2003 (2nd edition), (ISBN 978-0-596-00419-4), 600 pages
  • Lafore R., Object-oriented programming in C++, Sams, 2001 (4th edition), (ISBN 978-0-672-32308-9), 1040 pages
  • Prata S., C++ Primer Plus (Developer's Library), Addison-Wesley Professional, 2011 (6th édition), (ISBN 978-0-321-77640-2), 1200 pages. Cette édition couvre les nouveautés apportées par le standard C++11.
  • Stroustrup B., Programming: Principles and Practice using C++, Addison-Wesley 2009, (ISBN 978-0321543721)
  • Stroustrup B., The C++ Programming Language, Addison-Wesley Professional, 2013 (4th edition), (ISBN 978-0-321-56384-2), 1368 pages
  • Stroustrup B., The Design and Evolution of C++, Addison-Wesley professional, 1994 (1st edition), (ISBN 978-0-201-54330-8), 480 pages
  • Sutter H., Exceptional C++, Addison-Wesley Professional, 1999, (ISBN 978-0-201-61562-3), 240 pages. Publié aux éditions Eyrolles en 2000 sous le titre Mieux 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) et Exceptional C++ style (Addison-Wesley - 2004). Tous ces ouvrages concernent à priori des développeurs confirmés maîtrisant bien le langage C++.
  • David Vandevoorde, Nicolaï Josuttis, C++ Templates: the Complete Guide, Addison-Weslay, 2002, (ISBN 978-0-201-73484-3)
  • Vandevoorde D., C++ Solutions: Companion to the C++ Programming Language, Addison-Wesley, 1998 (3rd edition), (ISBN 978-0201309652), 292 pages. Contient la correction de nombre des exercices de l'ouvrage de Stroustrup, Le langage C++.

Ouvrages en langue française[modifier | modifier le code]

  • Chappelier J-C., Seydoux F., C++ par la pratique - Recueil d'exercices corrigés et aide-mémoire, PPUR, 2005 (2e édition), (ISBN 978-2-880-74732-9), 412 pages
  • Deitel P., Deitel H., Comment programmer en C++, Éditions Reynald Goulet, 2004, (ISBN 978-2-893-77290-5), 1178 pages. La dernière traduction disponible de l'ouvrage des Deitel père et fils ; correspond à la troisième édition en langue anglaise.
  • Delannoy C., Programmer en langage C++, Éditions Eyrolles, 2011 (8e édition), (ISBN 978-2-212-12976-2), 822 pages
  • Delannoy C., Exercices en langage C++, Éditions Eyrolles, 2007 (3e édition), (ISBN 978-2-212-12201-5), 336 pages
  • Geron A., Tawbi F., Pour mieux développer avec C++, Éditions Dunod - 01 Informatique, 2003, (ISBN 978-2-100-07348-1)
  • Guidet A., Programmation Objet en langage C++, Ellipses Marketing, 2008, (ISBN 978-2-729-83693-1), 364 pages
  • Hubbard J., C++, Éditions Dunod - Collection Mini Schaum's, 2002, (ISBN 978-2-100-06510-3), 192 pages. Pour débutants pressés.
  • Liberty J., Jones B., Le langage C++, CampusPress, 2005, (ISBN 978-2-744-01928-9), 870 pages
  • Stephens R., Diggins C., Turkanis J., Cogswell J., C++ en action, O'Reilly éditions, 2006, (ISBN 978-2-841-77407-4), 555 pages. Traduction de l'ouvrage en langue anglaise C++ Cookbook - Solutions and Examples for C++ Programmers paru aux États-Unis chez O'Reilly en 2005.
  • Stroustrup B., Programmation - Principes et pratique avec C++, Pearson, (ISBN 978-2744074424), 2010. Traduction de Programming : Principles and Parameters Using C++ (cf.supra).
  • Stroustrup B., Le langage C++, Pearson Education, 2003, (ISBN 978-2-7440-7003-7), 1100 pages. Traduction de The C++ Programming Language: Special Edition (cf. supra).
  • Sutter H., Alexandrescu A., Standards de programmation en C++, Pearson Education, 2005, (ISBN 978-2-744-07144-7), 226 pages. Traduction de l'ouvrage en langue anglaise C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (Addison-Wesley - 2004).
  • Guidet A., Programmation objet en C++, édition Ellipses, 2008, (ISBN 2729836934)

Construction[modifier | modifier le code]

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

Environnements de développement[modifier | modifier le code]

Compilateurs C++[modifier | modifier le code]

Bibliothèques C++[modifier | modifier le code]

Notes et références[modifier | modifier le code]

  1. (en) Bjarne Stroustrup, Bjarne Stroustrup's FAQ : FAQ de Bjarne Stroustrup, research.att.com,‎ Modified February 2, 2012. (lire en ligne) ]
  2. ISO/IEC 14882:2011 : Technologies de l'information -- Langages de programmation -- C++, ISO,‎ 2011-09-01 (résumé)
  3. Next C++ standard to arrive in 2017
  4. The C++ Programming Language, Third Edition, chap. 1.1.1, page 5
  5. Plugin CDT pour Eclipse

Voir aussi[modifier | modifier le code]

Sur les autres projets Wikimedia :

Article connexe[modifier | modifier le code]

Liens externes[modifier | modifier le code]