Les bases du C++

Les spécificités de C++

Le langage C++ a adopté un certain nombre de nouvelles spécificités qu’il faut connaître avant de se lancer dans la P.O.O. proprement dite.

Les commentaires

Les commentaires d’un code source peuvent désormais être indiqués de deux façons différentes :

/* Ceci est un commentaire typique venant du C */
int nEntier; // Et ceci est la seconde possibilité

Ces nouveaux commentaires sont utilisables uniquement dans le cas où tout le reste de la ligne est un commentaire.

Déclarations

En C, vous avez été habitué à déclarer les variables en début de bloc, c’est-à-dire en début de fonction ou de procédure. En C++, il est possible de déclarer une variable à tout moment dans le code.

/* Code C */
int FaitQqch( int a, int b)
{
     int nRetour;
     int i;
     int fVar;
     fVar = a + b;
     for( i=0; i<20; i++ )
          fVar = fVar + i;
     nRetour = fVar - a*b;
     return nRetour;
}
// Code C++ 
int FaitQqch( int a, int b)
{
     int fVar = a + b;
     for( int i=0; i<20; i++ )
          fVar = fVar + i;
     int nRetour = fVar - a*b;
     return nRetour;
}

Cet exemple est bien entendu dénué de tout intérêt, mais il montre la liberté offerte par le C++ en ce qui concerne les déclarations et les initialisations des variables.

Référence

Le langage C++ introduit une nouvelle notion fondamentale : les références. C’est une notion qui peut sembler difficile à assimiler au départ, notamment pour des personnes qui ne sont pas encore habituées à utiliser des pointeurs en C.

La notion de référence est directement liée au passage de paramètres à des fonctions en C. Nous savons que lorsque nous voulons transmettre à une fonction la valeur d’une variable ou au contraire la donnée réelle (en fait l’adresse), nous n’utilisons pas les mêmes méthodes.

Par exemple, soit les fonctions suivantes :

int FaitQqch( int a, int b)
{
     int nRet;
     if( a==0 )
          a=10;
     nRet = a + b;
     return nRet;
}
int FaitQqch2( int * a, int * b)
{
     int nRet;
     if( *a==0 )
          *a=10;
     nRet = *a + *b;
     return nRet;
}

Nous voyons tout de suite que dans le cas d’un appel comme celui-ci :

...
int a, b, c, d;
a = 0;
b = 5;
c = FaitQqch(a,b);
d = FaitQqch2(&a,&b);
...

c et d auront la même valeur, par contre, ce qui est intéressant, c’est qu’à la sortie de FaitQqchcode>, la valeur restera inchangée, alors que pour FaitQqch2code>, a vaudra désormais 10 ! Ceci est dû au passage par adresse, et non par valeur.

Tout cela, vous devez le savoir. En revanche, vous allez apprendre une nouvelle technique qui est une sorte de mélange des deux précédentes : les références.

Voici ce que devient notre fonction, FaitQqch3 :

int FaitQqch3(int &a, int &b)
{
     int nRet;
     if( a==0 )
          a=10;
     nRet = a + b;
     return nRet;
}

Le "&" (esperluette en français dans le texte) signifie que l’on passe par référence. La ligne de déclaration de la fonction est en fait la seule différence avec une transmission par valeur, d’un point de vue code. C’est-à-dire que l’utilisation des variables dans la fonction s’opère sans "*" et l’appel à la fonction sans "&". C’est ce qui fait la puissance des références : c’est transparent pour l’implémentation, mais cela possède la puissance des pointeurs.

Nous nous habituerons à leur utilisation au fur et à mesure.

Opérateurs new et delete

En plus des "anciens" malloc et free du C, C++ possède un nouveau jeu d’opérateurs d’allocation/désallocation de mémoire : new et delete.

Ils ont été créés principalement pour la gestion dynamique des objets, mais on peut les utiliser également pour des variables simples.

Voici une comparaison d’utilisation :

...
/* pour un simple pointeur (en C) */
int * pInt;
pInt = (int*)malloc(1*sizeof(int));
free(pInt);
...
/* pour un tableau (en C) */
pInt = (int*)malloc(100*sizeof(int));
free(pInt);
...
...
// pour un simple pointeur (en C++)
int * pInt;
pInt = new int;
delete pInt;
...
// pour un tableau (en C++)
pInt = new int[100];
delete []pInt;
...
// Tableau de classes (en C++)
pToto = new MyClass[50];
delete []MyClass;

Vous remarquerez donc tout de suite les différences, qui sont évidentes. Insistons simplement sur la désallocation à l’aide de l’opérateur delete, qui change suivant que le pointeur est simple, ou bien qu’il correspond à un tableau lorsqu’il est composé d’objets[2].

Les entrées/sorties en C++

Le langage C++ dispose de nouvelles routines d’entrées/sorties qui sont plus simples à utiliser. Elles sont définies dans la librairie iostream, qu’il est donc nécessaire d’inclure.

Note : nous verrons par la suite certains détails concernant cette librairie qui a évoluée depuis sa création. Notamment, pour certains compilateurs, il sera indispensable de remplacer l’inclusion donnée dans l’exemple ci-dessous (2.2.1), par la suivante :

#include <iostream>
using namespace std;

Pour l’heure, nous ne donnerons pas d’explication supplémentaire.

De plus, et si vous êtes sous Microsoft Windows, il vous sera peut-être utile d’ajouter à la fin la ligne suivante, afin de vous permettre de voir le résultat affiché avant que votre fenêtre de commande ne se referme :

     system("pause");

La sortie standard "cout"

// include indispensable pour cout 
#include <iostream.h>
void main()
{
     cout << "Hello World !";
     cout << "Hello World !\n";
     cout << "Hello World !" << endl;
     int n = 5;
     cout << "La valeur est " << n << endl;
     float f = 3.14f;
     char *ch = "Coucou";
     cout << ch << " float = " << f << endl;
}

Note : il est possible que votre compilateur nécessite une valeur de retour pour la fonction main. Dans ce cas, changez juste la ligne par :

int main()

et rajoutez à la fin :

     return 0;

Ce programme renvoie en sortie :

Hello World !Hello World !
Hello World !
La valeur est 5
Coucou float = 3.14

Cette nouvelle sortie standard est donc très intuitive à employer du fait qu’il est inutile de lui préciser le format de la valeur que l’on souhaite afficher.

Le "endl" est en fait disponible pour éviter d’éventuels "\n", en fin de ligne (sachant qu’il est bien sûr toujours possible d’utiliser ce caractère d’échappement...).

L’entrée standard "cin"

// include indispensable pour cout et cin 
#include <iostream.h>
void main()
{
     int n;
     cout << "Entrez un entier : ";
     cin >> n;
     cout << "Vous avez entré : " << n << endl;
     char ch[81];
     float f;
     cout << "Entrez un entier, une chaine, puis un float :";
     cin >> n >> ch >> f;
     cout << "Vous avez entré : " << n << ch << f << endl;
}

Cet exemple illustre brièvement comment fonctionne "cin". Bien entendu, aucun contrôle de type n’est effectué, c’est donc à l’utilisateur qu’il advient de faire attention.