Chap2: Les bases du C++

 Les directives de préprocesseur

 Les types de bases
 Rappel de notion et portée d’une variable
 Les espaces de noms
 Les opérateurs de C++
 Opérateur d'affection
 Opérateurs arithmétiques unaires
 Opérateurs arithmétiques binaires
 Opérateur de comparaison
 Opérateurs logiques
 Opérateur d‘incrémentation ou de décrémentation
 Opérateur de cast
 Opérateur conditionnel
 Les Exceptions
 Introduction
 Utilisation de la macro « assert »
 Inconvénient de la macro « assert »
 Mécanisme d’exception
 Structure de contrôle try ….. catch
 Notion de référence en C++ 1
 Lire et Ecrire dans un fichier en C++
 Les directives préprocesseur
Ce sont des instructions exécutées avant la compilation, Il s’agit
Principalement de l’inclusion et la compilation conditionnelle

 L’inclusion directive: #include

Elle permet d’inclure (insérer) un fichier texte dans le fichier source, en récopiant le
contenu de celui-ci comme si nous l’avons tapé,
#include<fichier> quand c’est un en-tête , stocké dans le dossier spécifique au compilateur
#include "fichier " quand le fichier se situe dans le même dossier que le fichier source
 La compilation conditionnelle directives: #if, #ifdef, #ifndef, #else, #elif, #endif
On peut remplacer #if <condition> par #ifdef <symbole> (vraie si le symbole est
Défini) ou #ifndef <symbole> (vraie si le symbole est non défini)
 Exemple d’utilisation de la compilation conditionnelle (protection contre les
inclusions multiples)
#ifndef CEFICHIER_H
#define CEFICHIER_H
//contenu du fichier
#endif 2
// fin du fichier
 Les types de base
Type de donnée Signification Taille (en Plage de valeurs acceptée
octets)
char Caractère 1 -128 à 127
unsigned char Caractère non signé 1 0 à 255
short int Entier court 2 -32 768 à 32 767
unsigned short int Entier court non signé 2 0 à 65 535
int Entier 4 (32 bits) -2 147 483 648 à 2 147 483 647
long int Entier long 4 -2 147 483 648 à 2 147 483 647
unsigned long int Entier long non signé 4 0 à 4 294 967 295
float Flottant (réel) 4 -3.4*10-38 à 3.4*1038
double Flottant double 8 -1.7*10-308 à 1.7*10308
long double Flottant double long 10 -3.4*10-4932 à 3.4*104932
Prend deux valeurs : 'true' et
bool Booléen 1
'false'
NB: Tous ces types sont également valables en langage C, en dehors du type booléen
Les plages sont données pour une architecture 32 bits
3
 Rappel de notion et portée d’une variable
 Dans un programme, nous avons en permanence besoin de variables, c’est-à-dire des
valeurs non constantes

 Une variable doit être déclarée avant d’être utilisée. Une variable n’existe pas dans tout le
programme, elle n’est en faite visible que dans le bloc d’instructions où elle est déclarée.

{
int nombre =0; //déclaration et initialisation
}
nombre = 3; //erreur nombre est hors portée

 On peut également déclarer une variable en dehors de tout bloc d’instructions, on parle
alors de variable globale: elle est visible dans tout le programme et sa durée de vie est
celle du programme

 Toute variable déclarée dans un bloc d’instructions (délimité par { }) est appelée variable
locale. Sa portée est limitée au bloc
La Portée : c’est la zone de code où la variable est visible

La durée de vie: c’est le temps pendant lequel la variable est présente en mémoire 4
 Les espaces de noms
 La notion d’espace de nom (namespace) est en apparue en C++ pour permettre
au programmeur de nommer ces variables, ces fonctions et ces classes sans se
soucier si les noms qu’il va leur attribuer existe dans d’autres bibliothèques qu’il
compte utiliser.

 Un espace de nom est un bloc de code (donc situé entre les accolades { et } qui
regroupe des variables, des fonctions et des classes. Un espace de nom est
nommé et la portée d’une variable est restreinte. Pour accéder à la variable, il
faut donc:
 Soit être dans le même espace de nom
 Soit utiliser l’opérateur de portée ::
 Exemple: Utilisation d’une variable déclarée dans un espace de nom
namespace test
{
int i;
// …..
i=3;
}
i=3; // erreur: hors de l’espace 5
test::i=3 // ok: utilisation de la portée ::
 Les espaces de noms
La directive using
 Un moyen d’utiliser le namespace est de l’utiliser avec la directive using
namespace. Avec la directive, nous n’avons plus à préciser devant chaque
variable le nom de l’espace de nom.
 Exemple: Utilisation d’une variable déclarée dans un espace de nom

#include <iostream>

cout << " absence de la directive using "; // erreur cout n’est pas reconnu

std::cout << " absence de la directive using " ; // ok

#include <iostream>
using namespace std;

cout << " présence de la directive using " ; // ok

6
 Les espaces de noms
On peut imbriquer un Un espace de nom est ouvert, c’est-
Espace de nom à-dire qu’on peut déclarer son
contenu plusieurs fois

namespace A namespace A
{ {
namespace B int i;
{ }
int i; int j=5; // n’est pas dans A
namespace C
{ namespace A
{
int j;
} int k; // ajoute à l’espace A
} }
}

A::B::i=3; A::i=j;
A::B::C::j=5 A::k=j;

7
 Les opérateurs de C++
Les opérateurs permettent d'écrire des expressions, logiques ou arithmétiques, soit
pour faire des calculs, soit pour prendre des décisions. Tous les opérateurs
renvoient une valeur
 Opérateur d'affection
C'est l'opérateur: =
Exemple: A = 3 // affecte la valeur 3 à A
 Opérateurs arithmétiques binaires
Ce sont les opérateurs: - + * / %
Exemple: A = B + C
 Opérateurs arithmétiques unaires
Ce sont les opérateurs: += -= *= /= %=
A += 4 // est un raccourci de A = A + 4
 Opérateurs de comparaison
Ce sont les opérateurs: == != < <= > >=
Ils renvoient 0 ou 1 (en C), false ou true (en C++). Ils sont utilisés dans les
8
boucles while, if, etc.
 Les opérateurs de C++
Les opérateurs permettent d'écrire des expressions, logiques ou arithmétiques, soit
pour faire des calculs, soit pour prendre des décisions. Tous les opérateurs
renvoient une valeur
 Opérateur d'affection
C'est l'opérateur: =
Exemple: A = 3 // affecte la valeur 3 à A
 Opérateurs arithmétiques binaires
Ce sont les opérateurs: - + * / %
Exemple: A = B + C
 Opérateurs arithmétiques unaires
Ce sont les opérateurs: += -= *= /= %=
A += 4 // est un raccourci de A = A + 4
 Opérateurs de comparaison
Ce sont les opérateurs: == != < <= > >=
Ils renvoient 0 ou 1 (en C), false ou true (en C++). Ils sont utilisés dans les
9
boucles while, if, etc.
 Les opérateurs de C++
 Opérateurs logiques
! && || (respectivement: NON, ET, OU)
Exemple: if ( A==3 && (B==4 || C==5) ) ...
 Opérateur d'incrémentation ou de décrémentation
Ce sont les opérateurs: ++ --
Exemple: i++ incrémente la variable i de 1 // équivalent à: i=i+1
j-- décrémente la variable j de 1 // équivalent à: j=j-1
Les opérateurs ++ et -- peuvent se placer avant ou après leur opérande,
mais la valeur de l'expression obtenue (si elle est utilisée) n'est alors pas la même.
Ainsi, si x=5, alors :
 y=x++; est équivalent à y=x; suivi de x++; donc y vaut 5 et x=6 à la fin de
l'exécution de l'instruction.
 y=++x; est équivalent à x++; suivi de y=x; donc y vaut 6 et x=6 à la fin de
l'exécution de l'instruction.
10
 Les opérateurs de C++
 Opérateur de cast
Il est possible de forcer la conversion d’une expression quelconque dans un type de
son choix, grâce à l’opérateur dit de « cast ».
 Exemple: Avec n et p sont des variables entières, l’expression : (double) n / p
aura comme valeur un double divisé par un entier.
 Opérateur conditionnel
Cet opérateur ternaire fournit comme résultat la valeur de son deuxième opérande
si la condition mentionnée en premier opérande est vraie et la valeur de son
troisième opérande dans le cas contraire.
 Exemple, avec cette affectation : maxi = a>b ? a : b ;
on obtiendra dans la variable maxi la valeur de a si la condition a>b est vraie, la
valeur de b dans le cas contraire.
 Avec : valeur = 2*n-1 ? a : b ;
on obtiendra dans la variable valeur, la valeur de a si l’expression 2*n-1 est non
nulle, la valeur de b dans le cas contraire.
11
NB: Tous ces opérateurs sont également valables en C
 Exercice 1
Quels résultats fournit le programme suivant :

#include <iostream>
using namespace std ;
int main ()
{
int i, j, n ;
i = 0 ; n = i++ ;
cout << "A : i = " << i << " n = " << n << "\n" ;
i = 10 ; n = ++ i ;
cout << "B : i = " << i << " n = " << n << "\n" ;
i = 20 ; j = 5 ; n = i++ * ++ j ;
cout << "C : i = " << i << " j = " << j << " n = " << n << "\n" ;
i = 15 ; n = i += 3 ;
cout << "D : i = " << i << " n = " << n << "\n" ;
i = 3 ; j = 5 ; n = i *= --j ;
cout << "E : i = " << i << " j = " << j << " n = " << n << "\n" ;
return 0;
12
}
 Exercice 2
Quels résultats fournit le programme suivant :

#include <iostream>
using namespace std ;
int main()
{
int n=5, p=10, q=5, r ;
r = n == (p = q) ;
cout << "A : n = " << n << " p = " << p << " q = " << q
<< " r = " << r << "\n" ;
n = p = q = 10 ;
n += p += q ;
cout << "B : n = " << n << " p = " << p << " q = " << q << "\n" ;
q = n < p ? n++ : p++ ;
cout << "C : n = " << n << " p = " << p << " q = " << q << "\n" ;
q = n > p ? n++ : p++ ;
cout << "D : n = " << n << " p = " << p << " q = " << q << "\n" ;
return 0;
13
}
 Exercice 3
Quels résultats fournit le programme suivant :
#include <iostream>
using namespace std ;
int main()
{
int n, p, q ;
n = 2 ; p = 5; /* cas 1 */
q = n++ >p || p++ != 3 ;
cout << "A : n = " << n << " p = " << p << " q = " << q << "\n" ;
n = 2 ; p = 5 ; /* cas 2 */
q = n++<p || p++ != 3 ;
cout << "B : n = " << n << " p = " << p << " q = " << q << "\n" ;
n = 2 ; p = 5 ; /* cas 3 */
q = ++n == 3 && ++p == 3 ;
cout << "C : n = " << n << " p = " << p << " q = " << q << "\n" ;
n = 2 ; p = 5 ; /* cas 4 */
q = ++n == 3 && ++p == 6 ;
cout << "D : n = " << n << " p = " << p << " q = " << q << "\n" ;
return 0; 14
}
 Les exceptions
Introduction
 Une exception représente un fonctionnement anormal d’une fonction ou d’ un
bloc d’instructions. Son apparition doit être exceptionnelle et liée à certaines
conditions
 Par exemple
#include <iostream>
using namespace std;

int main() {
int c, a=1,b=0;
c = a/b; // division par zéro!
cout << "c: " << c << endl;
return 0;
}
}

 On peut utiliser une macro assert pour gérer cette erreur à l’exécution
15
 Les exceptions
Utilisation de la macro « assert »
 La macro assert est une sorte d'instruction conditionnelle if, elle a pour prototype:

void assert ( i n t ) ;
}
 Pour pouvoir utiliser « assert », il faut inclure dans le programme le fichier «
cassert » (son équivalent en C est « assert . h »)
 L’exemple précédent devient

#include <iostream>
#inc lude <cassert>
using namespace std ;
int main( ) {
int c, a=1,b=0;
assert (b !=0) ;
c = a/b;
cout << "c : " << c << endl ;
return 0;
}
16
 Les exceptions
Inconvénient de la macro « assert »
 Elle ne permet pas une gestion appropriée de l’erreur, elle provoque un arrêt
brutal de l’exécution du programme et la suite du programme ne peut pas se
poursuivre
#include <iostream>
#include <cassert>
using namespace std ;
int main( ) {
int c, a=1,b=0;
assert (b !=0) ;
c = a/b;
cout << "c : " << c << endl ;

cout << "suite du programme! ";

return 0;
}

 Il faut donc avoir un mécanisme différent, permettant de traiter la situation

exceptionnelle sans quitter le programme systématiquement: Ce mécanisme est
17
connu sous le nom de traitement d’exception.
 Les exceptions
Mécanisme d’exception
•Nous allons présenter dans ce qui suit le mécanisme d'exception à partir d'un
exemple où le but est de faire une division entière dans le cas ou le dénominateur
n'est pas égal à zéro. Dans le cas contraire, un message d'erreur est affiché.

#include <iostream> On commence par construire un objet X de type

using namespace std ; quelconque qui représentera l'erreur: dans
int test_denominateur (int a, int b) { l'exemple X est du type string.
string x = "division par zero";
if (b==0) { throw x; }
On lance une exception sur cet objet grâce au
return a/b; // division entière.
mot-clé réservé, throw. Ici, cette exception est
}
lancée dans le cas où le dénominateur est nul.
int main() {
int c=0,a=1,b=0;
try { Cette exception (c-a-d la fnt qui déclenche l’exception)
c = test_denominateur(a,b); est alors enfermée dans un bloc try (qui signifie
cout << "result: " << c << endl; essayer), qui peut générer une erreur.
} Ici l’erreur est générée par la fonction,
catch (string) { test_denominateur, dans ce bloc try..
cout << " division par zéro!\n";
}
cout << "suite du programme! \n"; Un bloc catch essaie d'attraper l'objet X, représentant
return 0; l'erreur. Puisque X est du type string, nous avons18
} défini un catch de ce type-là.
 Les exceptions
Exercice
Ecrire un programme qui fournit la racine carrée d’un nombre réel en utilisant les
exceptions
Faire un test qui donne les racines carrées d’un tableau de réels

19
 Les exceptions
Structure de contrôle try … catch
 Quand une exception est détectée dans un bloc try, le contrôle de l'exécution est
donné au bloc catch. Un bloc try doit être suivi d'au moins un bloc catch
try {
}
catch (string) {
}
catch (int) {
}

 L’appel de catch est:

 catch(T): exception du type T.
 catch(T info): exception du type T, info est un objet du type T, utilisé pour extraire
des informations supplémentaires.
 T peut être un type prédéfini comme int, string etc.
 T peut aussi être une classe que le programmeur a défini

20
 Les exceptions
Structure de contrôle try … catch
 Exemple de catch avec une classe définie.
class exception_divzero { int main() {
string message; int c=0,a=1,b=0;
public: try {
exception_divzero():message("division par c = test_denominateur(a,b); // division
zéro!") {} par zéro!
string get_message() const { return cout << "résultat/division: " << c <<
message;} endl;
}; }
int test_denominateur (int a, int b) { catch (exception_divzero e) {
exception_divzero x; cout << "Exception a été capturée: "\
if (b==0) { << e.get_message() << endl;
throw x; }
} cout << "suite du programme! \n";
return a/b; // division entiere. return 0;
} }
 Les exceptions se lancent avec la directive throw. Attention ! on ne lance pas un type mais
un objet.
 On peut remplacer throw x par throw exception_divzero() ce qui revient à appeler le
constructeur « à la volée » comme une fonction qui renverrait un objet. 21
 Notion de référence en C++
 En C, la notation &x signifie « l’adresse de la variable x »
 En C++, cette notation possède deux significations:
- Il peut toujours s’agir de l’adresse de la variable x
- Il peut aussi s’agir de la référence à x
Seul le contexte du programme permet de déterminer s’il
s’agit de l’une ou l’autre des deux significations.

Exemple:
int x ; // une variable contenant un entier
int *p = &x ; // p vaut l’adresse de x, *p et x sont équivalents
x=7;
cout << *p; //affiche 7
L’opérateur * s’appelle l’opérateur de déréférencement et *p
désigne la valeur contenue dans l’emplacement mémoire dont
l’adresse est p.
22
 Notion de référence en C++
Exemple:
int n;
int &p = n; // p est une référence à n, p et n sont équivalents
n = 3;
cout<< p; // l’affichage donnera 3

 Noter que les opérateurs & et * sont inverses l’un de l’autre.

On a toujours : *(&x) = x et &(*p) = p

23
 Notion de référence en C++
Exercice:
Ecrire une fonction qui calcule, le plus grand élément, le plus petit élément et la
somme des éléments d’un tableau

24
 Lire et Ecrire dans un fichier en C++
On peut peut lire et écrire dans des fichiers sur disque en utilisant la
bibliothèque fstream
– ifstream : permet l’accès du flux en lecture seulement

ifstream f1("[Link]"); // ouverture en lecture du fichier

[Link]();

– ofstream : permet l’accès du flux en écriture seulement

ofstream f2("[Link]"); // ouverture en écriture du fichier

[Link]();

– fstream : permet l’accès du flux en lecture/écriture.

fstream f3("[Link]", ios::in | ios::out);// ouverture en lecture/écriture

[Link]();

25
 Lire et Ecrire dans un fichier en C++
Exemple:
utilisations de ifstream (Input File stream) et ofstream (Output File stream)
#include <iostream> for(int i=0; i < 2; i++)
#include <fstream> {
using namespace std; for(int j=0; j < 2; j++)
int main() {
{ fpw << tab[i][j] << " ";
int tab[2][2]; }
ifstream fpr ("[Link]"); fpw << endl;
ofstream fpw ("[Link]"); }
if(fpr==NULL || fpw==NULL ){ [Link]();
cout << "Erreur ouverture"; return 0;
return -1; }
}
for(int i=0; i < 2; i++) {
for(int j=0; j < 2; j++) {
fpr >> tab[i][j];
}
}
[Link](); 26