Chapitre 1

Rappel du langage C++

1
 Plan du cours
●
Introduction
●
Identificateurs et mots clés
●
Variables et constantes
●
Opérateurs et entrée/sortie
●
Fonctions
●
Contrôle de flux
●
Types de données
●
Pointeurs et références
●
Le préprocesseur
●
Compilation et exécution

2
 C++ Caractéristiques générales
●
Inventé par Bjarne Stroustrup vers 1983
●
C’est une évolution orientée objets du langage C de Kernighan et
Ritchie.
●
Il a été normalisé par l’ANSI et l’ISO
●
Compatible avec le langage C
●
Présente plusieurs paradigmes de programmation:
– programmation procédurale :comme le langage C
– programmation structurée : Reprend les struct du langage C
– Programmation orientée-objet : il implémente la notion de classe,
d'encapsulation, d'héritage d'abstraction, de polymorphisme dynamique
– Programmation générique ou méta-programmation : il introduit les
templates ou modèles générique

3
C++ Un langage toujours d’actualité

Systèmes embarqués Systèmes mobiles

4
 Mots clés
●
alignas alignof and and_eq asm auto bitand
bitor bool break case catch char char16_t
char32_t class compl const constexpr const_cast
continue decltype default delete do double
dynamic_cast else enum explicit export extern
false float for friend goto if inline int long
mutable namespace new noexcept not not_eq nullptr
operator or or_eq private protected public
register reinterpret_cast return short signed
sizeof static static_assert static_cast struct
switch template this thread_local throw true try
typedef typeid typename union unsigned using
virtual void volatile wchar_t while xor xor_eq

5
 Types prédéfinis
Type Taille Intervalle de valeurs Précision
bool 1 octet false ou true -
char 1 octet -128 à 127 -
unsigned char 1 octet 0 à 255 -
short 2 octets -32768 à 32767 -
unsigned short 2 octets 0 à 65535 -
int 4 octets −2147483648 à 2147483647 -
Unsigned int 4 octets 0 à 4294967295 -
long 4 octets −2147483648 à 2147483647
unsigned long 4 octets 0 à 4294967295
float 4 octets +/ − 3.4 ∗ 10 10−38 à 3.4 ∗ 10 1038 6 chiffres
double 8 octets +/ − 1.7 ∗ 10 10−308 à 1.7 ∗ 10 10308 15 chiffres
Long double 10 octets +/ − 1.2 ∗ 10 10−4932 à 1.2 ∗ 10 104932 18 chiffres

6
 Hello world!
#include <iostream>
using namespace std;

int main()
{
cout << "Hello, World!";
return 0;
}

7
 Déclaration de variables
●
La syntaxe de déclaration d’une variable en C++ est la suivante:
Type variable;
Type var1, var2, var3;
●
Les noms de variables doivent commencer par une lettre ou par _
●
Les accents sont interdits.
●
La casse (majuscule ou minuscule) est prise en compte (var1 est
différent de Var1).
●
Exemples:
int i,j,k;
float Valeur;
●
On peut déclarer une variable avec affectation d’une valeur
(initialisation):
type var1 = 0; 8
 Affectation
●
L’opération d’affectation peut se faire entre des variables ou des opérandes de même type
int a,b;
a=4;
b=a; // la valeur de a est copiee dans b: b vaut 4

●
ou entre des variables de types différents (dans ce cas, attention aux pertes lors de la
conversion):
float a=3.1415;
char b;
double c;
b = a;// b vaut 3, un warning est généré à la compilation
c = a;//c vaut 3,1415 , pas de warning car la précision du
●
//type double dépasse cette du type float

9
 Bases et systèmes de numération
●
Le système décimal est celui utilisé par défaut et ne nécessite aucun symbole
particulier:
int d = 1978;
●
Le système hexadécimal est représenté en précédant le nombre par 0x
int h = 0x7BA; //ou 0x7ba
●
Le système octal est représenté en commençant par le symbole zéro : 0
int o = 03672;
●
Le système binaire est représenté en commençant par les symboles "zéro b" : 0b
int b = 0b11110111010;
●
Depuis le C++14, il est possible d’ajouter des apostrophes comme séparateur de
nombre. Ainsi
int b = 0b111’1011’1010; est plus facile à lire.

10
 Opérateurs
●
Un opérateur unaire est un opérateur ne possédant qu’un seul opérande.
● &a; // & est un opérateur unaire. Renvoie l’adresse mémoire de a
●
Un opérateur binaire possède deux opérandes
a = 1; // = est un opérateur binaire
a=a%2 ; // % est un opérateur binaire comme + - * /  %
●
L’opérateur de condition ? Est un opérateur ternaire
(condition) ? instruction si vrai : instruction si faux ;
int max(int a,int
b)
{
retrun (a<b)?
a:b ;
}
●
Le traitement des opérandes se fait selon la priorité des opérateurs:
int a=5+3*2 ;// a=11
int b= 3 * 4 / ( 2 * 3); // b
= 2 11
int c = 3 * 4 / 2 * 3; // c =
18
Priorité opérateur Assoc. exemple
18 :: Priorité des opérateurs
-
17 ++ -- () [] . -> gauche i++
16 (type) sizeof & * ~ ! + - ++ -- new droite &x *x ++x
delete
15 .* ->* gauche
14 * / % gauche a%b a*b
13 + - gauche a+b a-b
12 >> << gauche a>>2
11 > >= < <= gauche x>0
10 == != gauche x==y
9 & gauche x=1&3 ;//1
8 ^ (ou exclusif) gauche x=1^3;//2
7 | (ou) gauche x=1|3;//3
6 && gauche (a>1)&&(b>0)
5 || gauche (a>1)||(b>0)
4 ?: droite x>0?1:0
3 = += -= *= /= <<= >>= &= ^= gauche a&=0xFF
|=
2 throw droite 12
1 , gauche int a,b,c ;
 Flux de sortie pour l’affichage: cout
●
cout désigne le flux de sortie standard qui est dirigé par défaut sur l’écran.
Il va permettre d’afficher ce que l’on veut à l’écran.
[std::]cout << données<<données << données;
●
Voici des exemples d’utilisation de flux de sortie:
cout << "Hello world";
cout << "Hello " << "world";
cout << "Hello world" << endl;
cout << "La longueur est de : " << longueur << "
mètres \n";

// Affichage en bases différentes

cout << dec << 16 << endl; // base décimale
cout << hex << 16 << endl; // base hexadécimale
cout << oct << 16 << endl; // base octale
cout << 24; // la dernière base utilisée reste
active !!!
double pi = 3.141592654;
cout << setprecision (3) << pi << endl;
cout << setprecision (9) << pi << endl; 13
 Flux d’entrée clavier: cin
●
cin est le flux d’entrée standard (le clavier).
[std::]cin >> variable;
cin >> var1 >> var2; // pas recommandé
●
Voici un exemple d’utilisation de flux d’entrée:

#include <iostream>
using namespace std;
int main()
{
int age;
cout << "Entrer votre age ";
cin >> age;
cout << "Vous avez " << age << "
ans" << endl;
return 0;
}

14
 Structures conditionnelles
●
A part l’opérateur ?: on peut utiliser la structure if:
if (condition)
{
instructions si la condition est vraie
}

●
Ou bien la structure if else :
if (condition)
{
//instructions si la condition est vraie
}
else
{
//instructions si la condition est fausse
}

15
 switch case
●
Si le nombre de choix est grand, il est
préférable d’utiliser la structure switch/case
switch( choix )
{
case ’o’:
case ’O’:
cout << "Vous êtes d’accord";
break;
case ’n’:
case ’N’:
cout << "Vous n’êtes pas d’accord";
break;
default:
cout << "Réponse incorrecte";
}

16
 Structures itératives
●
La boucle for est privilégiée quand on connaît
les valeurs initiale et finale et le pas
d’incrémentation (tableaux)
int Taille=3, titi=1, toto;
for ( int i=0; i < Taille; i++ )
cout << i << endl; // Afficher la valeur de i
//--------------------------------
for ( int i=0, int j=0; i < Taille; i++, j=2*i,
toto=titi )
{
titi = i + j;
cout << i << endl; // Afficher la valeur de i a
l’ecran
cout << toto << endl; // Afficher la valeur de toto a
l’ecran
}
for( ; ; ) // boucle infinie
17
cout << "afficher sans fin" << endl;
 while et do ... while
while ( condition )
{
// Instructions répétées tant que la condition est vraie
}

do
{
// Instructions répétées tant que la condition est
vraie
}
while (condition) ; //ne pas oublier le ;
18
 Les pointeurs
●
En langage C et C++, chaque variable est stockée à une (et unique) adresse physique.
●
Une variable permet de symboliser une valeur contenue en mémoire
(par exemple double y=3.14;).
●
Un pointeur est une variable contenant une adresse mémoire, principalement celle
d’une autre variable.
●
Un pointeur est typé: il pointe vers des variables d’un certain type et permet de
manipuler correctement ces variables.
●
Avant d’être utilisé, un pointeur doit obligatoirement être initialisé à l’adresse d’une
variable ou d’un espace mémoire.
●
Il est possible d’obtenir l’adresse d’une variable via l’opérateur &

int a;
cout << &a; // affichage de l’adresse de a

19
 Utilité des pointeurs
●
Ils permettent de manipuler de façon simple des données pouvant être
importantes
●
Au lieu de passer à une fonction un élément de grande taille, on pourra
lui fournir un pointeur vers cet élément. On gagne ainsi en mémoire et
en vitesse d’exécution,
●
Ils permettent de manipuler les tableaux (un tableau est en fait un
pointeur sur un espace mémoire réservé),
●
En C++ (programmation orientée objet) les pointeurs permettent aussi
de réaliser des liens entre objets
●
Un pointeur est une variable qui doit être définie, précisant le type de
variable pointée, de la manière suivante:
type * Nom_du_pointeur;

20
 Références
●
Nouveauté du C++ par rapport au C.
●
Le C++ référence permet de faire référence à des variables.
●
La déclaration d’une référence se fait simplement en intercalant le caractère &, entre
le type de la variable et son nom:
type & Nom_de_la_variable = valeur;
●
Il existe deux contraintes à l’utilisation des références :
– une référence doit obligatoirement être initialisée lors de sa déclaration,
– une référence ne peut pas être dé-référencée d’une variable à une autre.
●
Les références permettent d’alléger la syntaxe par rapport aux pointeurs :

int A = 2;
int &refA = A; //initialisation obligatoire a la
déclaration!
refA++; // maintenant A=3
int B = 5;
refA = B; // signifie A = 5 !!!!
refA++; // on a : A = 6, B = 5, et refA = 6
21
 Les tableaux
●
Un tableau est une variable composée de données de même type, stockées de manière contiguë en
mémoire (les unes à la suite des autres).
●
Les éléments du tableau peuvent être :
– Des données de type simple : int, char, float, long, double...;
– Des pointeurs, des tableaux, des structures et des classes
●
En C/C++, les éléments d’un tableau sont indicés à partir de 0.
A = tableau[i]; // lecture du ième élément
●
tableau[i] = A; // écriture du ième élément
●
Connaître la taille d’un tableau est primordial pour savoir jusqu’à où il est possible de lire ou écrire en
mémoire. Si un tableau contient N éléments, le dernier élément est accessible par tableau[N-1].
●
Le nombre d’éléments d’un tableau (sa taille) est capital car conditionne directement l’utilisation de la
mémoire.
●
Il existe deux familles de tableaux différencier par la manière de gérer l’utilisation (ou l’allocation)
mémoire:
– les tableaux alloués statiquement où la taille réservée en mémoire est connue (fixée et constante) à la compilation,
– les tableaux alloués dynamiquement qui permettent d’allouer et de libérer l’espace lors de l’ exécution.

22
 Exemples d’utilisation de tableaux
float notes[10];
int premier[] = {4,5,6}; //tableau de 3
éléments
int Nb = 4;
int *Array = NULL;
Array = new int[Nb]; // Allocation mémoire
delete[] Array; // libération de la mémoire
●
type volume[L][C][P] //tableau à 3 dimensions

23
 Les fonctions
●
Une fonction est un sous-programme qui exécute des instructions par simple appel à cette
fonction.
●
Les fonctions permettent d’exécuter le même code dans plusieurs parties du programme
●
Permet de simplifier le code et d’obtenir une taille de code minimale.
●
Il est possible de passer des variables aux fonctions. Une fonction peut aussi retourner une
valeur
●
Une fonction peut faire appel à une autre fonction ou à elle-même (récursivité)
●
Une fonction doit être déclarée avant d’être utilisée.
type_retour NomFonction( type Arg1, type Arg2,... );
●
La définition d’une fonction se fait selon la syntaxe suivante:
type_retour NomFonction( type Arg1, type Arg2,... )
{// liste d’instructions
}
●
Si la fonction ne renvoie aucune valeur, alors type_retour est void;
●
Pour exécuter une fonction, on lui fait appel via son nom suivi des arguments entre parenthèses
NomFonction1( Arg1, Arg2,... );
24
 Passage de paramètres par valeur
●
Les arguments passés à la fonction sont copiés dans de
nouvelles variables propres à la fonction.
●
Les modifications des valeurs des arguments ne sont pas
conservées après la fin d’exécution de la fonction
●
Ce type de passage de paramètre par valeur est aussi appelé
passage par copie
void Affichage(int a) int main()
{ {
cout<<"Valeur = int nb1=2, nb2=3, nb3=4;
"<<a<<endl; int somme;
} Affichage( nb1 );
Affichage( nb2 );
int Somme(int a, int b) Affichage( Somme(nb1,nb2
{ ) );
int c = a + b; somme = Somme( nb2,
return c; nb3); 25
} return 0;
}
Passage de paramètres par variable
●
Utilisé quand on veut que la valeur d’un paramètre change dans la
fonction
●
La variable passée en argument est l’adresse de la variable à changer
●
Appelé également passage par référence

void calculSomme(int a, int b, int *s)

{
*s=a+b ;
}
//lors de l’appel

int va=5 ;
int vb=6 ;
int vs ;
calculSomme(va,vb,&vs) ;

26
 Directives du préprocesseur
●
Les directives du préprocesseur ne sont pas
des instructions du langage.
●
Elles permettent des adaptations du code ou de
la compréhension du code par le compilateur.
●
Ces directives commencent par le symbole #

#if #elif #else #endif

#define #undef #ifndef #ifdef

#line #pragma #error #includ

e
27
 Lecture/Écriture dans les fichiers
●
C++ utilise des flux pour gérer les entrées/sorties
contrairement au langage C
●
La manipulation des flux se fait en modes
– Le mode texte : L’enregistrement des données dans le
format texte (ASCII, UTF8, …)
– Le mode binaire : Enregistrement sous le format utilisé en
mémoire (illisible dans un éditeur de texte).
●
L’utilisation de structure de données ou de classe pour
l’enregistrement de données organisées est fortement
conseillée pour le mode binaire.

28
Exemple manipulation des fichiers
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char *argv[])
{
fstream fileT;
fileT.open ("test.txt", fstream::in | fstream::out
fstream::trunc);
if( fileT.fail() )
{
cout << "Text File cannot be opened/created !" << endl;
return -1; // fin avec un retour d’erreur
}
fileT << "Hello_SansEspace" << " " << 3.141592654 << " " <<
2.718281 <<endl;
fileT << 6.022141 << " " << 1.380650 << endl;
29
Exemple de manipulation de fichiers
fileT.clear(); // mise a 0 des flags
fileT.seekg(0, fstream::beg);
string stT;
double piT, eT, aT, bT;
fileT >> stT >> piT >> eT >> aT >> bT; // lecture
cout << stT << endl;
cout << "PI : "<< piT << " E : " << eT << endl;
cout << "Avogadro : " << aT << " Boltzmann : " << bT << endl;
fileT.close(); // close file
return 0;
}

30
 Compilation
●
La compilation est la transformation du code source en fichier objet binaire
(fichier.o)
●
Il manque à ce fichier les appels aux librairies externes (cin, cout, etc.)
●
L’édition des liens crée l’ exécutable et fait appel aux fonctions des autres librairies
●
Compilation statique : le code binaire des fonctions est copié dans l’exécutable
●
Compilation dynamique : Les librairies (dll) sont chargées lors de l’exécution et
leur code est partagé entre les programmes
●
Les étapes de compilation dépendent de l’IDE et du système d’exploitation utilisé
par le développeur
●
Quelques exemples d’éditeurs C++ :
– Windows : Visual studio, codeBlocks, Borland C++, etc.
– Linux : Le compilateur gcc, kdevelop, sublimeText, eclipse

31