Le langage C++

Différentes étapes sont nécessaires pour passer d’un code source en C écrit par le programmeur à un programme exécutable sur l’ordinateur.

Dans le cas de programmes utilisant des bibliothèques externes (les .so sous GNU/Linux ou les .dll sous Windows) une dernière étape de chargement des bibliothèques semblable à l'édition des liens s’effectue lors de l’exécution du programme.

Les compilateurs et les interfaces graphiques de développement (IDE) cachent généralement ces étapes à l’usager mais les connaître s’avère souvent utile.

Les programmes C travaillent sur des données possédant chacunes un type particulier : entiers, flottants, adresses, structures, … Les valeurs entières sont les char, les short, les int et les long. Celles-ci sont signées : elles peuvent prendre des valeurs négatives. Les char occupent par exemple un octet et peuvent prendre des valeurs de -128 à 127. Si on n’utilise pas les valeurs négatives on peut utiliser des types signés qui vont déplacer les limites d’un type donné. Par exemple un unsigned char pourra prendre une valeur entre 0 et 255. La déclaration d’une variable d’un type donné, c’est à dire la réservation d’un emplacement mémoire d’une taille suffisante pour stocker les données, se fait comme indiqué dans le code suivant :

Les emplacements mémoires réservés sont alors accessibles par les noms spécifiés : a, b ou ma_variable.

Deux types flottants, float pour la simple précision et double pour la précision double, permettent de manipuler des nombres à virgule fixe.

Pour affecter une valeur à une variable on utilise l’opérateur =. Ce qui va d’ailleurs nous pousser à utiliser l’opérateur == pour tester des égalités. Les opérateurs arithmétiques classiques tels que * pour le produit ou / pour la division sont accessibles et des parenthèses permettent de spécifier des priorités.

L’unité logique de calcul d’un programme en C est la fonction. Chaque fonction effectue un certain calcul sur des données, les arguments ou paramètres, et renvoie éventuellement un résultat. Les données des programmes, par exemple les arguments d’une fonction, possèdent toutes un type.

Le code suivant présente un simple programme C compilable avec deux fonctions : la fonction carre() qui prend un entier de type int et retourne son carré ; la fonction main() obligatoire pour un programme exécutable qui correspond au point d’entrée du programme, i.e. la première fonction appelée.

La fonction main prend en entrée les arguments passés au programme et retourne un entier de valeur zéro si l’exécution s’est déroulée normalement, un code d’erreur sinon.

Une fonction retourne une valeur à la fonction appellante en utilisant l’instruction return. Toutes les instructions après un return sont ignorées.

Pour contrôler le flux d’exécution d’un programme diverses instructions existent. Nous commençons par présenter l’exécution conditionnelle avec if qui exécute une partie du code si une condition est vérifiée. On peut utiliser l’instruction else pour effectuer une autre opération si la condition du if n’est pas vérifiée.

Tout comme pour les fonctions les instructions à exécuter conditionellement sont délimités par des accolades : { et }. Un ensemble d’instructions entre accolades est appelé un bloc d’instructions. Ils peuvent être imbriqués les uns dans les autres si cela est nécessaire. Notez que dans notre cas nous n’avons qu’une seule instruction dans chaque bloc. Le cours de affiche_parite() peut être réécrit de la façon suivante :

L’instruction de boucle while va exécuter une instruction ou un bloc d’instruction tant qu’une condition est vérifiée.

Peu utilisée dans les débuts de l’informatique car la mémoire était très limitée et les compilateur ne l’optimisaient pas correctement, la récursivité est une manière élégante de résoudre les problèmes. Tout code récursif peut être cependant transformé en non récursif en utilisant des boucles. Un exemple très simple est le calcul de la factorielle. On sait que 0! = 1 et n! = n × (n - 1)!.

Les structures permettent de créer des types personalisés à partir de types prédéfinis. Elles sont en fait des agreggats d’autre types de base ou d’autre structures. Chaque nouveau type de structure possède un nom ainsi que des champs qui en sont les éléments et qui sont eux-même nommés.

Le code précédent définit un nouveau type pour représenter les nombres complexes qui sont donc constitué d’une partie réelle et d’une partie imaginaire. Pour accéder à l’un des champs d’une structure on utilise l’opérateur point ..

Il peut arriver que l’on souhaite donner un nom plus explicite à un type, pour ce faire on utilise l’opérateur typedef qui va lui associer un alias.

C’est tout de même un opérateur à utiliser avec parcimonie et surtout pas dans les deux premiers cas. Le dernier alias permet de ne pas avoir à indiquer toujours struct en C, c’est cependant automatique en C+\+ où l’on peut déclarer struct Complexe et utiliser juste Complexe.

Les typedefs sont par exemple utilisés pour définir des types dont on garantit le nombre de bits, en particulier dans stdint.h. Parmis les types qui y sont définit on trouve uint32_t qui représente les entiers non signés sur 32 bits, int8_t qui représente les entiers signés sur 8 bits, etc. En effet le C ne définit pas avec précision la taille en bits des types et elle change en fonction des architectures.

Les ordinateurs actuels possèdent une mémoire vive, appelée la RAM (Random access memory) utilisée par les programmes pour stocker le code et les données. Ainsi lorsque l’on écrit int a; pour déclarer un entier signé nommé a on réserve en fait un emplacement de la mémoire d’une taille suffisante pour y stocker un int. La mémoire peut être vue comme une bande de cases dans lesquelles on peut accèder et modifier des nombres. Pour accéder à une case mémoire il suffit de connaître son adresse, une sorte d’index.

Le bout de code précédent commence par déclarer deux variables nommées a et ptr et respectivement de type int et int*. On suppose qu’une variable de type int prend 4 octets et qu’une variable de type int* qui est un pointeur sur un int prend aussi 4 octets. Ces deux première lignes alloue donc deux blocs de 4 octets chacun. On suppose que la case-mémoire de a est à l’adresse 0x420010 et que celle de ptr est à l’adresse 0x420014.

L’instruction a = 123; place la valeur 123 dans la case-mémoire réservé pour a par le compilateur dans la pile de la fonction (puisque c’est une variable locale). L’expression &a va récupérer non pas la valeur contenue dans la case mémoire de a, soit 123, mais l’adresse de cette case-mémoire, soit 0x420010. Cette adresse, qui est aussi une valeur numérique, est placée dans la case mémoire réservée pour ptr.

Maintenant que l’on dispose de l’adresse de a dans la case-mémoire de ptr on peut modifier de façon indirecte. L’opérateur unaire *, à ne pas confondre avec l’opérateur binaire \* pour la multiplication, permet de lire et de modifier une variable dont on connaître l’adresse. Par exemple en utilisant le code suivant, on mettre à jour la valeur contenue dans la case mémoire à l’adresse 0x420010 par 398.

Si l’on avait connu l’adresse 0x420010 définie par le compilateur on aurait même pu directement écrire :

La façon standard de gérer des tableaux en C consiste à utiliser des zones contigues de mémoire et à dénoter le tableau comme étant l’adresse du premier élément. Les chaînes de caractères sont un exemple de tels tableaux : les caractères sont stockés dans des cases consécutives avec un caractère \0 nul qui termine la chaîne et elle est utilisée en donnant l’adresse du premier caractère.

Une syntaxe alternative à *(tabl + pos) consiste à utiliser tabl[pos] qui est plus proche des autres langages de programmation.

Il existe différents types d’allocation de mémoire en fonction de la déclaration des variables dans le code :

L’allocation par malloc() va donc permettre d’allouer un espace mémoire dont la taille ne sera connu qu'à l’exécution. Par exemple lorsque vous définissiez une chaîne de caractère par char* str = "Hello World!"; vous réserviez un espace mémoire suffisamment grand pour contenir les 13 caractères dont le caractère \0 qui termine la chaîne. Si vous voulez rajouter un caractère à la chaîne par la suite, vous ne pouvez pas, car l’espace mémoire situé après peut contenir des données importantes (voire être innacessible).

Le C++ arrive avec de nouvelles bibliothèques en particulier celles d’entrées/sorties qui utilisent les nouveaux opérateurs.

Dans l’exemple ci-dessus on inclut l’en-tête iostream qui contient les définitions de base pour les entrées sorties. On indique ensuite d’accéder aux fonctions de l’espace de nommage (ou namespace) std sans avoir besoin de le spécifier explicitement. La fonction main, point d’entrée du programme, va ensuite utiliser l’opérateur << de cout pour y envoyer une chaîne de caractère puis une fin de ligne via end. Nous reviendrons sur ces différents points par la suite.

Sachez qu’il est possible d’envoyer d’autres données sur la sortie standard via l’opérateur << de cout. Pour lire depuis l’entrée standard utilisez l’opérateur >> sur cin.

En plus des commentaires multi-lignes délimités par /* et */ du C89, le C+\+ possède également des commentaires monoligne débutant par // et continuant jusqu’en fin de ligne comme en C99.

Vous avez déjà pu constater que nous utilisions l’instruction using namespace std;. Celle-ci permet d’accéder aux fonction de l'espace de noms std de la bibliothèque standard sans avoir besoin de le spécifier. De façon explicite on aurait put écrire :

Notez que dans ce cas chaque utilisation d’une fonction ou d’un objet de l’espace de noms_ std doit être préfixé de std:: où l’opérateur :: est l’opérateur de résolution de portée.

Ainsi on peut définir plusieurs fonctions de même nom mais dans des espaces de noms différents. Cela est en particulier très utile pour les bibliothèques qui seront évidemment utilisées par d’autres personnes. Là où en C on devait écrire par exemple malib_mafonction(), dans une bibliothèque C+\+ on écrira malib::mafonction(). En utilisant un using namespace malib; on pourra alors supprimmer tous les malib:: et utiliser par exemple mafonction() directement. Évidemment si deux espaces de noms possèdent des fonctions de même nom il faudra utiliser l’opérateur de résolution de portée pour éviter des conflits. En C lorsque deux fonctions avaient des fonctions de même nom elles étaient simplement incompatibles.

Tout comme en C, les fonctions doivent être déclarées, ne serait-ce que par leur prototype, avant d'être utilisée. On peut cependant intégrer des arguments par défaut dans les prototypes de façon à simplifier les appels. Les arguments par défaut sont très utile pour régler certains paramètres qui sont le plus souvent utilisés ou que l’on n’oblige pas à calculer.

Les références permettent d’utiliser de façon automatique des pointeurs, soit des références vers un autre emplacement mémoire. Lors de la déclaration d’une référence on lui affecte un objet du même type vers lequel elle pointe. La référence agit alors comme un alias de cet objet (et non pas comme une copie).

Le passage par référence allège non seulement l’utilisation des références qui s’utilisent comme une variable classique, sans avoir besoin d’utiliser l’indirection en préfixant par *, mais aussi l’appel des fonctions qui en utilise puisque le compilateur se charge de tout, plus besoin de passer l’adresse avec &.

Lorsque vous souhaitiez allouer de la mémoire sur le tas en C vous pouviez utiliser les fonctions malloc() et calloc(). Les données du tas restant accessibles jusqu'à ce qu’elles soient libérées par un free(). Le C+\+ rajoute les opérateurs new et delete qui seront très utile pour la manipulation des objets comme nous le verrons au chapitre suivant.

Les opérateurs new[] et delete[] sont utilisés pour allouer et libérer des tableaux.

En C vous pouviez définir vos propres types à l’aide de structures. Pour les manipuler vous deviez créer des fonctions auxquelles vous passiez votre structure en argument.

What is new in C+\+ is that you can really associate the complex_add_to() function to the Complex structure. The function is then called a method of the Complex structure.

Comme vous pouvez le constater la syntaxe est similaire. Cependant la fonction d’addition est désormais attaché à la structure Complex, on n’a alors pas besoin de préfixer son nom de complex_ comme on le faisait en C puisque ce nom de fonction ne sera utilisé que pour les Complex. L’appel ne peut être ambigu puisque l’on utilise structure.methode() et que methode ne sera recherché que parmis les méthodes de la structure structure.

Une méthode de structure se voit automatiquement doté d’un objet this qui représente la structure sur laquelle ma méthode est invoqué. Dans notre cas this sera un pointeur sur l’objet a de la fonction main() puisqu’on a utilisé a.add_to(). Plus besoin de passer explicitement cet objet.

Sachez que l’on sépare le plus souvent le code source en fichiers .h pour les en-têtes et en fichiers .cc ou .cpp pour l’implémentation. On déclare alors simplement les prototypes dans l’en-tête comme en C.

On utilise alors l’opérateur de résolution de portée dans l’implémentation. Notez que l’on n’est pas obligé d’utiliser le mot clé struct pour référencer un type structure à l’utilisation.

En effet on a l’habitude de séparer les déclaration de fonction ou de méthode de leur implémentation, comme en C. Ceci permettant de fournir à un utilisateur de notre bibliothèque uniquement les en-têtes qui contiennent les déclaration, avec le code déjà compilé pour l’implémentation. Cette programmation modulaire permet aussi de modifier simplement une implémentation, voire de la remplacer totalement par une autre, sans rien changer au reste du code.

Les structures issues du C ne sont qu’un cas particuliers de classes que l’on retrouve dans d’autres langages qui permettent la programmation orientée objet tel que le Python, le Java ou le C#. En particulier les structures sont des classes dont tous les champs, real et imaginary dans notre exemple précédent, sont accessibles.

Une classe définit un type non simplement à partir de ses données mais à partir de méthodes qui peuvent être appelées. On pourrait par exemple définir une classe boîte aux lettres de la façon suivante :

La boîte aux lettres est alors principalement définie à partir de ce qu’elle permet de faire et non à partir de ce qu’elle contient réellement. Les mot-clés public: et private: permettent de définir si les champs ou méthodes qui suivent sont accessibles depuis l’extérieur ou non. Dans ce cas seules les méthodes sont accessibles, les champs m_nombre_lettres et m_lettres étant uniquement utilisé à l’intérieur de la boîte aux lettres.

Dans la section précédente nous avons présente les méthodes comme un raccourcis pour l'écriture de fonctions associées à une structure. Le mot-clé this permettant d’accéder à l’objet surlequel la méthode est invoquée. Dans l’exemple ci-dessus, nous utilisons directement m_nombre_lettres et m_lettres sans utiliser this→m_nombre_lettres. En effet, au sein d’une méthode, le compilateur va rechercher les symboles d’abord dans les variables locales au bloc, puis dans les arguments de la méthode, puis dans les champs (ou membres) de la classe de la méthode, et enfin dans les objets globaux. On peut donc accéder directement aux champs de la classe.

Si n’importe quelle autre fonction pouvait accéder au champ m_nombre_lettres qui contient le nombre de lettre dans la boîte aux lettres, alors il pourrait y avoir des erreurs et des incohérences, comme un nombre négatif comme valeur qui pourrait faire crasher la méthode posteLettre().

Comme les structures et les types de base en C, les instances de classe doivent être créées. Il vous suffit évidemment de déclarer un objet comme une structure, par exemple au sein d’une fonction, pour qu’une place en mémoire lui soit réservée.

Par contre, à cause de l’accessibilité des champs de l’objet b instance de la classe BoiteAuxLettres, on ne peut pas écrire b.m_lettres. En effet m_lettres est une donnée privée, donc seulement accessible à l’intérieur de la classe BoiteAuxLettres, soit à l’intérieur de ses méthodes.

Pour pallier aux problèmes d’accessibilité à l’initialisation, et parce qu’il est beaucoup plus logique que la classe BoiteAuxLettres soit elle-même responsable de l’initilisation de ses instances, il existe des constructeurs. Ces méthodes spéciales sont invoquées lorsqu’un objet est créé et servent entre autres à sont initialisation.

Les constructeurs sont des méthodes qui ne retourne rien, donc on ne spécifie même pas void, et qui porte le nom de leur classe.

Notez qu’il est possible de passer des paramètre au constructeur. Par exemple si vous souhaitez donner un nom à vos boîte aux lettres, vous pouvez utiliser std::string, la classe standard de C++ dédiée à la manipulation de chaîne de caractères.

On a remplacé le constructeur sans argument par un constructeur avec argument. Il n’est alors plus possible d’utiliser le constructeur sans argument et on devra obligatoirement utiliser une déclaration du type BoiteAuxLettres b("Boite A"); et non BoiteAuxLettres b;. Vous pouvez néanmoins laisser les deux constructeurs un avec argument et l’autre sans, ou utiliser un argument par défaut comme vu au chapitre précédent.

Vous pouvez aussi déclarer des métodes qui seront invoquées lorsque un objet sera détruit. Dans notre cas, m_lettres est un bloc mémoire alloué sur le tas avec realloc(). Il reste donc disponible tant qu’il n’est pas libéré explicitement avec free() dont l’oubli peut provoquer des fuites de mémoire. Le constructeur dont le nom correspond à celui de la classe préfixé d’un tilde ~ est là pour ça.

Au chapitre précédent nous avons vu les opérateurs new et delete qui permettaient respectivement d’allouer de la mémoire sur le tas et de la libérer comme le faisaient les fonctions malloc() et free() en C bien que l’on n’ait pas à spécifier la taille. Il est possible de faire de même avec les classes.

Alors que les champs des classes sont différents pour chaque instance, tout comme pour les structures en C, il est possible de créer des variables partagées par toutes les instances d’une classe. Il s’agit donc de variables appartenant à une classe, on les nomme des membres statiques.

Les variables statiques sont déclarées comme telles en préfixant leur déclaration du mot-clé static. De plus on doit lui affecter un espace mémoire ce qu’on fait dans l’implémentation dans un fichier .cc (ou .cpp) dans lequel on peut initialiser la variable. Dans l’exemple précédent, c’est parce qu’on a déclaré nombre_boites comme public que l’on peut y accéder depuis l’extérieur avec BoiteAuxLettres::nombre_boites.

L’héritage permet de créer des types génériques ou spécialisés formant une hiérarchie. Dans notre cas on peut vouloir rajouter une classe BoiteAuxLettresEtColis qui soit exactement comme BoiteAuxLettres tout en offrant la possibilité de poster de colis. De même on pourrait vouloir créer une BoiteAIdee qui permet de poster des idées sous forme de lettre. Cette dernière classe est donc assez semblable à BoiteAuxLettres et les deux peuvent être des spécialisation d’une classe Boite.

Ce que l’on écrira en C de la façon suivante:

On indique donc qu’une class hérite d’une autre classe en rajoutant :public ClasseParente après son nom. Le mot-clé public étant là pour indiquer que les champs public de ClasseParente le seront aussi dans la classe fille.

Pour que les champs privée d’une classe parente soit accessible dans une classe fille, remplacez l’utilisation de private: par protected:. Ainsi le champ m_nombre_lettres sera accessible dans BoiteAuxLettresEtColis mais pas à l’extérieur des classes de la hiérarche.

Supposiez que vous vouliez écrire une fonction pour faire la moyenne de plusieurs nombres. Vous pourriez procéder ainsi :

On se contente ici d’utiliser deux nombre pour en donner la moyenne. Cette section s’applique néanmoins à une fonction moyenne() définie de la façon suivante :

Le problème est que cela ne marcherait pas avec des nombres flottants. Vous pouvez espérer vous en sortir en créant une fonction double moyenne(double, double) ainsi qu’en opérant à des conversions pour retrouver des nombres entiers si besoin est :

Une autre stratégie serait d’utiliser l’héritage auquel cas vous pourrez créer une classe Nombre qui redéfinirait les opérations nécessaires pour avoir par exemple:

À condition de gérer les blocs de mémoire alloué et de redéfinir les operateurs operator+() et operator/(int) pour chaque combinaison de nombre, ce qui peut vite devenir un travail de titan. Une telle solution ne marcherait de plus que pour des instances de la classe Nombre et de ses classes enfants.

Mais cela ne fonctionnerait évidemment alors pas avec des nombres complexes. Le C++ vous offre un méchanisme beaucoup plus puissant pour exprimer ce type de généricité, les templates.

Il est ainsi directement possible d’utiliser moyenne() pour n’importe quel type d’objet pour lequel l’opération \+ est définie. Pour créer vos propre templates, définissez vos fonctions comme telle en rajoutant template <typename T> où T est un nom que vous choississez et que vous utiliserez pour référencer le type générique dans la déclaration et le corps de la fonction. C’est le compilateur qui est chargé de créer les fonctions moyenne(int, int) ainsi que moyenne(double, double) sur le modèle donné par le patron.

Vous pouvez aussi utiliser plusieurs types dans un template.

Ce dernier exemple fait en sorte que la moyenne de deux entiers puisse être un flottant (2.5 dans notre cas). On voit aussi que dans ce cas les types correspondant à T et U ont du être explicitement spécifiés à l’aide de <int, double>. L’ambiguïté étant qu’on aurait pu vouloir avoir moyenne<int, int>(a, b) soit un type de retour int qui serait convertit en double pour être mis dans c.

De même qu’il existe des patrons de fonctions on peut aussi créer des patrons de classes. Ainsi la BoiteAuLettre du chapitre précédent aurait pu être remplacée par un template de classe générique, template <typename T> class Boite, que l’on aurait instancié avec Boite<Lettre> ou Boite<Idee>.

À titre d’exemple nous allons définir une très simple classe Tableau qui représentera des tableaux de taille fixe d’objets de type générique.

La bibliothèque STL, Standard template library, fournit avec toute plateforme de développement C contient différentes classes patrons dont std::vector<T>++ qui représente un tableau de taille dynamique.

Jusqu'à présent nous n’avons qu’effleuré l’usage de bibliothèques, que ce soit la libc, bibliothèque standard du C qui définit entre autres les fonctions de stdio.h, ou bien la STL, bibliothèque standard du C+\+ avec les fonctions de flux de iostream ou std::vector.

Les compilateurs C+\+ viennent ainsi avec la STL, pour Standard template library, qui définit en particulier :

Les fonctions et objets de la STL sont définis dans des en-têtes sans extension, on utilise ainsi #include <iostream> et non #include <iostream.h>. Tout est placé dans l’espace des noms std.

Nous avons déjà vu l’utilisation basique des flots d’entrée/sortie en C+\+ avec std::cout et std::cin. En plus de ces deux flots prédéfinis et déjà ouverts lors de l’exécution, le flux std::cerr permet d'écrire sur la sortie d’erreur, dédiée comme son nom l’indique aux messages d’erreur. Les opérateurs >> et << permettent respectivement de récupérer des données sur un flux d’entrée ou d’en envoyer sur un flux de sortie.