C++

Le C++ est un langage de programmation donnant la possibilité la programmation sous de multiples paradigmes comme la programmation procédurale, la programmation orientée objet et la programmation générique.



Catégories :

Langage de programmation - Langage orienté objet - Norme ISO - C++

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

Le C++ est un langage de programmation donnant la possibilité la programmation sous de multiples paradigmes comme la programmation procédurale, la programmation orientée objet et la programmation générique. C++ est aujourd'hui le 3e langage le plus utilisé au monde[1] (le 1er si on le regroupe avec le C). Le langage C++ n'appartient à personne et donc tout le monde peut l'utiliser sans payer de droits.

Histoire

Bjarne Stroustrup, l'inventeur de C++

Bjarne Stroustrup a développé C++ au cours des années 1980, tandis qu'il travaillait dans le laboratoire de recherche Bell d'AT&T. Il s'agissait en l'occurrence de perfectionner le langage C. Il l'avait d'ailleurs appelé C with classesC avec des classes»). Les premières améliorations se concrétisèrent par conséquent par la prise en charge des classes, mais aussi 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), sa dernière de 2003 (ISO/CEI 14882 :2003). La normalisation de 1998 standardise la base du langage (Core Language) mais aussi la bibliothèque standard du C++ (C++ Standard Library).

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 veut dire que C++ est un niveau au-dessus du C. Il existe de nombreuses bibliothèques C++ en plus de celle qui est incluse dans la norme. D'autre part, C++ permet l'utilisation de la totalité des bibliothèques C existantes.

Fonctionnalités introduites par C++

On considère généralement que C++ «est du C» avec un ajout de fonctionnalités. Une remarque importante est à faire toutefois : certains programmes syntaxiquement corrects en C ne le sont pas en C++.

Les fonctionnalités ajoutées sont :

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

Histoire du C++

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 particulièrement 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), alors que BCPL était rapide mais de trop bas niveau et non adapté au développement de gros logiciels. Lorsque 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 à perfectionner le langage C avec des fonctionnalités identiques à 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 perfectionné 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 toujours 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 apportait les fonctionnalités nécessaires au remplacement des fonctions C respectant les traditions telles que printf et scanf. Par la suite, parmi les additions principales, 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)

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.

Au départ, 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 nommée STL, car elle est reconnue comme faisant partie de la bibliothèque standard du C++. Cependant, énormément de personnes l'appellent toujours 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 apportées 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).

La programmation orientée objet en C++

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

L'encapsulation en C++

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

C++ n'impose pas l'encapsulation des membres dans leurs classes. On pourrait par conséquent déclarer l'ensemble des 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 l'ensemble des données privées, ou au moins protégées, et de rendre publiques les méthodes agissant sur ces données. Ceci sert à cacher les détails de l'implémentation de la classe.

«Hello, world»

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

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

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 sert à résoudre les ambiguïtés quand 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). Il est envisageable de spécifier un espace de nom 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;

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 envisageable d'écrire :

using namespace std;

Cela est valable pour l'ensemble des espaces de noms. Cette instruction se place généralement avant le début du code source proprement dit :

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello, new world!" << endl;
    return 0;
}

Déclaration de classe

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

 class MessageInternet
 {
  private:
   string m_sSujet;
   string m_sExpediteur;
   string m_sDestinataire;
  public:
   MessageInternet (string sujet, string expediteur, string destinataire);
   string GetSujet () const;
   string GetExpediteur () const;
   string GetDestinataire () const;
 };

À quoi servent les templates ?

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 changent que par la valeur de ces paramètres.

Paramètres des templates

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, est parfois utilisée dans l'instantiation du template.
  • Constantes scalaires, autrement dit de type dérivant des entiers (int, long, bool), mais ni 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 surtout 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és 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 ?

En programmation, il faut quelquefois écrire de nombreuses versions d'une même fonction ou classe suivant les types de données manipulées.

A titre d'exemple, un tableau de int ou un tableau de double sont particulièrement identiques, et les fonctions de tri ou de recherche dans ces tableaux sont semblables au type près.

En résumé, l'utilisation des templates sert à «paramétrer» le type des données manipulées.

Avantages à utiliser des templates

  • écritures uniques pour les fonctions et les classes.
  • moins d'erreurs dues à la réécriture
  • Performances perfectionnées grâce a la spécialisation suivant les types de données.

Exemple de templates

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 rédigés 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.2);
    return 0;
}

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

Spécialisation des templates

Un template donné peut avoir plusieurs instantiations envisageables 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 uniquement si l'ensemble des arguments sont connus à ce moment. Un exemple classique est le calcul de la fonction factorielle :
template< size_t N >
struct CalcCompileTime
{
    static size_t Fact = N * CalcCompileTime< N - 1 > ;
};
 
template<0>
struct CalcCompileTime<0>
{
    static size_t Fact = 1 ;
};

Le polymorphisme et les méthodes virtuelles en C++

Le polymorphisme est mis en œuvre à l'aide du mécanisme des méthodes virtuelles en C++. Quand une méthode virtuelle est nommée, l'implémentation de la méthode exécutée est choisie selon le type réel de l'objet. L'appel n'est par conséquent 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 positionné devant la déclaration de la méthode.

Le mot clé virtual, positionné 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é comme objet de la classe de base, pourra donner lieu à l'appel de la fonction définie dans la classe dérivée.

Il est le plus souvent conseillé d'utiliser le mot clé virtual devant la déclaration du destructeur de la classe de base, pour que celui des sous-classes soit nommé aussi quand 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 uniquement si la classe de base est parfois utilisée pour manipuler des classes dérivées.

Il convient de ne pas confondre ce mécanisme avec celui de surcharge. Dans le cas de la surcharge, le choix de la fonction à appeler s'effectue sur le nombre et le type des paramètres : l'appel est par conséquent résolu dès la compilation.

Bibliographie

Construction

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

  • MakeFile (Unix, Linux), Make (Windows)
  • Ant (génération portable en XML)
  • SCons (génération portable en Python).
  • Cmake génération de MakeFile portable

Environnements de développement

Il existe de nombreux environnements de développement (certains sont libres) comme :

L'environnement de développement propriétaire le plus commun est certainement Visual C++ de Microsoft. Il est payant mais une version limitée gratuite existe sous le nom Express Edition[3].

La société Borland propose aussi l'environnement C++ Builder, inspiré de Delphi.

Compilateurs C++

Liens externes

Notes et références

Recherche sur Google Images :



"... classes et fonctions templates ..."

L'image ci-contre est extraite du site blog.developpez.com

Il est possible que cette image soit réduite par rapport à l'originale. Elle est peut-être protégée par des droits d'auteur.

Voir l'image en taille réelle (532 x 407 - 23 ko - png)

Refaire la recherche sur Google Images

Recherche sur Amazone (livres) :




Ce texte est issu de l'encyclopédie Wikipedia. Vous pouvez consulter sa version originale dans cette encyclopédie à l'adresse http://fr.wikipedia.org/wiki/C%2B%2B.
Voir la liste des contributeurs.
La version présentée ici à été extraite depuis cette source le 17/03/2009.
Ce texte est disponible sous les termes de la licence de documentation libre GNU (GFDL).
La liste des définitions proposées en tête de page est une sélection parmi les résultats obtenus à l'aide de la commande "define:" de Google.
Cette page fait partie du projet Wikibis.
Accueil Recherche Aller au contenuDébut page
ContactContact ImprimerImprimer liens d'évitement et raccourcis clavierAccessibilité
Aller au menu