CHAPITRE 2:

NOTIONS DE BASE DU C++

On décrit un certain nombre de règles générales intervenant dans l’implémentation de

programmes en C++.
Nous exposerons plus précisément les notions importantes du C++, à savoir :
• les identificateurs et les différents types de données,
• les mots-clés,
• les opérateurs,
• les instructions de contrôle,
• les fonctions,
• les structures,
• les tableaux,
• les pointeurs,
• les références, 1

• l'allocation dynamique,
• les fichiers. 1
 1. LES IDENTIFICATEURS

Ils servent à désigner les différentes données manipulées par le programme, telles les
variables et les fonctions,
Ils sont formés d’une suite de caractères choisis parmi les lettres et/ou les chiffres, le
premier d’entre eux étant nécessairement une lettre.
• Seul le caractère souligné _ est considéré comme une lettre. Il peut donc même
apparaître au début d’un identificateur. Voici quelques identificateurs corrects :
lg_lig , valeur_5 , _total , _89
• Les majuscules et les minuscules sont autorisées, mais ne sont pas équivalentes. Ainsi,
en C++, les identificateurs ligne et Ligne désignent deux objets différents.
• Les noms réservés (if, switch, case, try, ...) ne peuvent être utilisés
identificateurs. 2
2
• Pas de restriction sur la longueur des identificateurs.
2. LES TYPES DE DONNÉES Le tableau suivant résume la taille des types de données en C/C++ :
Type Longueur Domaine de valeurs

bool 1 bit true ou bien false

unsigned char 8 bits (1 octet) 0 à 255

char 8 bits (1 octet) -128 à 127

enum 16 bits (2 octets) -32 768 à 32 767

unsigned int 16 à 32 bits (2 à 4 octets) 0 à 65 535

short 16 bits (2 octets) -32 768 à 32 767

int 16 à 32 bits (2 à 4 octets) -2 147 483 648 à 2 147 483 647

unsigned long 32 bits (4 octets) 0 à 4 294 967 295

long 32 bits (4 octets) -2 147 483 648 à 2 147 483 647

float 32 bits (4 octets) 3.4 * (10^-38) à 3.4 * (10^+38)

double 64 bits (8 octets) 1.7 * (10^-308) à 1.7 * (10^+308)

3
long double 80 bits (12 octets) 3.4 * (10^-4932) à 1.1 * (10^+4932)
3. MOTS-CLÉS  Un ensemble de mots réservés :

asm auto bool break case

catch char class const const_cast
continue default delete do double
dynamic_cast else enum explicit export
extern false float for friend
goto if inline int long
mutable namespace new operator private
protected public register reinterpret_cast return
short signed sizeof static static_cast
struct switch template this throw
true try typedef typeid typename
union unsigned using virtual void
volatile wchar_t while

4
4. LES OPÉRATEURS 

Opérateurs Fonction

+ - * / % addition, soustraction, multiplication, division, modulo

= += -= *= /= %= affectation, affectation d’addition, affectation de soustraction, …
== != < > <= >= égal à, différent de, inférieur, supérieur, inférieur ou égal, …
++i --i i++ i-- incrémente/décrémente la valeur de i; exécute (affecte) la valeur de i
puis incrémente/décrémente sa valeur.

& | ^ && || ET, OU, OU exclusif (bit à bit) ; ET, OU logique Court-Circuit
<< >> décalage à gauche et à droite
?  : conditionnel ou ternaire
() [] -> . ->*  .* référence et de sélection
5
5
Evaluation des expressions
Priorité des opérateurs :
• x[y] x++ x--
• ++x --x !x -x
• x*y x/y x%y
• x+y x-y
• x >> y x << y
• x < y x > y x >= y x <= y
• x == y x != y
• x && y
• x || y
• x = y x op= y
• x ? y : z

Evaluation des expressions booléennes

• Dans e1 && e2, la sous-expression e2 n’est évaluée que si e1 a été évaluée à ’true’.
if (i >=0 && T[i] > 20)
6
• Dans e1 || e2, la sous-expression e2 n’est évaluée que si e1 a été évaluée à ’false’.
if (i<0 || T[i] > 20)
Évaluation des expressions arithmétiques
Si une (sous-)expression mélange plusieurs types, c’est le type le plus large qui est utilisé.
int i=3,j=2,m ;
double r=3.4 ;
m = (i/j)*r ;
• D’abord l’expression (i/j) est évaluée: / désigne ici la division entière, cela donne donc 1.
• Pour évaluer le produit 1*r, il faut convertir 1 en double (1.0) et faire le produit sur les
doubles, cela donne 3.4
• Pour l’affectation, comme m est entier, 3.4 est converti en int. Finalement on a m = 3!!

• Pour éviter les erreurs, on procède d’une autre manière : il est possible de convertir
explicitement des données d’un certain type en un autre en utilisant un cast.
Ex: int i=3,j=2,m ;
double r=3.4 ;
m = ((double)i/j)*r ; //(double): cast sur la valeur de i convertit en double
Cela donne m = 5.

• L’évaluation d’une expression arithmétique ne se fait pas toujours de gauche à droite

7
!
Ex: (i/j)*(r/3)
5. ENTRÉE/SORTIE STANDARD  
Pour utiliser les entrées/sorties, il faut ajouter : # include <iostream>
Afficher à l’écran :
Syntaxe : cout < < expr1 < < . . . < < exprn ;
Cette instruction affiche expr1 puis expr2. . .
Afficher un saut de ligne se fait au moyen de cout << endl.
Ex: int i = 45 ;
cout << "la valeur de i est " << i << endl ;
 cout (ou std::cout) désigne le “flot de sortie” standard.
 < < est un opérateur binaire, indique la direction au “flot de sortie’’.
Lire au clavier :
Syntaxe : cin > > var1 > > . . . > > varn ;
Cette instruction lit (au clavier) des valeurs et les affecte à var1puis var2 . . .
 cin est le flot d’entrée standard, et >> est un opérateur similaire à <<.
Les caractères tapés au clavier sont enregistrés dans un buffer dans lequel les cin viennent
stocker des valeurs.
Ex: int i; 8

cin >> i;
N.B: Les espaces, les tabulations et les fins de lignes sont des séparateurs.
6. LES INSTRUCTIONS DE CONTRÔLES 
1. Les instructions conditionnelles
o L’instruction if
Forme : if(<expression entière>)
<instruction1>
else
<instruction2>
Mécanisme : l’<expression entière> est évaluée.
– si sa valeur est différente de 0 (VRAIE), l’<instruction1> est effectuée,
– si sa valeur est nulle (FAUX), l’<instruction2> est effectuée.
Toute expression entière différente de 0 (resp. égale à 0) est considérée comme vraie (resp. fausse).
o L’instruction switch Cette instruction permet un branchement conditionnel multiple.
Forme : switch (<expression>){
case <valeur1> : <instructions>
case <valeur2> : <instructions>
...
case <valeurn> : <instructions>
default : <instructions>
}

Remarque 1: La partie default : <instructions> est facultative. 9

Remarque 2: L’instruction switch est en général utilisée en conjonction avec l’instruction break; qui
permet de sortir immédiatement du switch.
2. Boucles
o L’instruction while
Forme : while (<expression entière>)
<instruction>
Mécanisme : l’<expression entière> est d’abord évaluée. Tant qu’elle est vraie (ie différente de 0),
l’<instruction> est effectuée.
Schématiquement :

On remarque que le test est effectué avant la boucle.

o L’instruction do
Forme : do
<instruction>
while (<expression entière>);
Mécanisme : l’<instruction> est effectuée, puis l’<expression entière> est évaluée. Tant qu’elle est vraie
(!= 0), l’<instruction> est effectuée. 10

Remarque : On remarque que le test est effectué après la boucle.

Schématiquement :

L’instruction for
Forme : for (<expression1>; <expression2>; <expression3>)
<instruction>
Le mécanisme est équivalent à :
<expression1>; // initialisation de la boucle
while (<expression2>) // test de continuation de la boucle
{
<instruction>
<expression3>; // évaluée `a la fin de chaque boucle
}
Remarque 1: Une boucle infinie peut se programmer ainsi :
for (;;)
<instruction>
Remarque 2: Dans une boucle, on peut utiliser les instructions
11
break; pour abandonner immédiatement la boucle et passer à la suite,
continue; pour abandonner l’itération en cours et passer à la suivante.
7. FONCTION
Définition: type nom( liste des paramètres) { corps de la fonction}
• type est le type du résultat de la fonction.
(void si elle ne renvoie rien)
• La liste des paramètres (paramètres formels): type1 p1, ..., typen pn
• Le corps décrit le bloc d’instructions à effectuer par la fonction.
Le corps utilise ses propres variables locales, les éventuelles variables globales et les paramètres formels.
• Si une fonction renvoie un résultat, il doit y avoir (au moins) une instruction return expr ;
Ex : int max(int a, int b)
{
int res=b ;
if (a>b) res = a ;
return res ;
}

Utilisation d’une fonction:

Elle se fait grâce à l’appel de la fonction.
Cet appel est une expression de la forme : <nom>(<liste d’expressions>)
Mécanisme de l’appel :
– chaque expression de la <liste d’expressions> est évaluée,
– les valeurs ainsi obtenues sont transmises dans l’ordre aux paramètres formels,
– le corps de la fonction est ensuite exécuté, 12

– la valeur renvoyée par la fonction donne le résultat de l’appel.

Exemple:
#include <iostream>
using namespace std;
int x, y; // déclaration de variables globales
int plus(int, int); //le prototype de la fonction plus
void mess_erreur(); //le prototype de la fonction mess_erreur
int main(){ // fonction principale
int r;
x=5; y=25;
r=plus(x, y); //appel de la fonction plus avec arguments
return 0;
}
int plus(int a, int b){ // définition de la fonction plus
mess_erreur(); //appel d’une fonction sans arguments
return(a+b);
}
void mess_erreur(void){
cout<<"Vous n’avez fait aucune erreur \n";
return; 13

}
8. TABLEAUX
Déclaration de tableau à 1 dimension (1 indice) : type nom[taille]; définit un tableau d’éléments type type et de
taille taille (indices de 0 à taille − 1).
L’élément d’indice i est désigné par nom[i].
Ex: int Tab[10]; //déclaration d’un tableau de 10 entiers; Tab désigne l’adresse de premier élément du tableau &Tab[0].
int tab[5] = { 10, 20, 5, 0, 3 }; //déclaration d’un tableau de 5 entiers avec initialisation.
Déclaration de tableau à deux indices: type nom[ligne][colonne]; Un tableau à deux indices est similaire à
une matrice. L’élément d’indice (i, j) est désigné par nom[i][j].
Ex: int Tab[4][5]; //déclaration d’un tableau de 4 lignes dont chacune ayant 5 éléments entiers;
int tab [3] [4] = { { 1, 2 } , { 3, 4, 5 } } ; //déclaration d’un tableau d’entiers avec initialisation de 3 lignes/4 colonnes;
Remarque: Tout comme un élément d’un tableau à 1 indice, Tab[i][j] se manipule comme n’importe quelle variable.
#include <iostream>
using namespace std;
int main(){ const int N = 4, M = 2;
int s[N], T[N][M];
for(int i=0 ; i<N ; i++){ s[i] = 0;
for(int j=0 ; j<M ; j++){ cout<<"T[" << i <<"][" <<j<<"]= "; cin >> T[i][j];
s[i] += T[i][j];
}
}
cout <<"\nLe vecteur somme est: \n ";
14
for(int i=0 ; i<N ; i++) cout<<" s[" <<i<< "]="<<s[i]<<endl;
return 0;
}
9. CHAINES DE CARACTÈRES
Une chaîne de caractères est un tableau de caractères . Son initialisation se fait de plusieurs manières:
char p1[8]=’B’,’o’,’n’,’j’,’o’,’u’,’r’ ;
char p2[9]="Bonjour!" ; // initialisation par une chaîne littérale
char p3[ ]="Bonjour" ; // p3 aura alors 8 éléments
Le compilateur rajoute toujours un caractère NULL à la fin d’une chaîne de caractères. Il faut donc que le tableau ait
au moins un élément de plus que la chaîne littérale.
Ex:
#include <iostream>
#include <cstring>
using namespace std;
int main(){ char ch1[20],ch2[20];
cout<<"Saisissez ch1: "; cin >> ch1;
cout<<"\nSaisissez ch2: "; cin >> ch2;
if(strcmp(ch1,ch2) == 0){
cout << "La chaine ch1(ou ch2) inverse est: ";
for(int i=strlen(ch1);i>=0;i--) cout << ch1[i]<< " ";
cout << endl;
}
else cout << "Chaines ch1 et ch2 differentes"; 15

return 0;
}
 10. LES STRUCTURES
La structure permet de rassembler des valeurs de type différent. Ex: Adresse d’une maison, est définit par le numéro
(int) et le nom de la rue (char).
1. Déclaration: On déclare une structure ainsi : struct adresse { int numero ;
char rue[50] ; } ;
Cela défini un type de structure, chaque élément déclaré à l’intérieur de la structure est appelé champ. Une fois défini,
nous pouvons déclarer des variables du type correspondant:
adresse oncle, tente ;
1. Manipulation: Chaque champ d’une structure peut être manipulé comme n’importe quelle variable du type
correspondant.
tente.numero=19;
strcpy(tente.rue,"avenue Pasteur");
#include<iostream>
using namespace std;
struct adresse {int numero ; char rue[50]; } ;
struct coord_fonct{char nom[20]; char prenom[20]; struct adresse domicile;}; //déclaration d’un type structure adresse ’domicile’.
int main(){ coord_fonct fonct[3]; // declaration d’un tableau de 3 élements de type coord_fonct
for(int i=0;i<3;i++){
cout<<"\nfonct["<<i<<"].nom= "; cin>> fonct[i].nom;
cout<<"\nfonct["<<i<<"].prenom= "; cin>> fonct[i].prenom;
cout<<"\nfonct["<<i<<"].domicile.numero= " ; cin>> fonct[i].domicile.numero;
cout<<"\nfonct["<<i<<"].domicile.rue= "; cin>> fonct[i].domicile.rue;
} 16
return 0;
}