CPP Cours2

Le langage C++ et la programmation orientée
objets - séance 2 -
Prof. Mustapha Ameur
ENSA Marrakech
4 novembre 2020
Les structures de contrôles (suite)
Les boucles
Il existe deux types de boucles :
La boucle for permet de réunir la déclaration, la condition et
l’incrémentation.
for ( int i = 0; i < 10; i ++)
{ // bloc a repeter
}
La boucle while :
int i = 0; // Autre version

while ( i < 10) do {
{ // bloc a repeter /* bloc a repeter */
i ++; } while ( expression )
}
Prof. Mustapha Ameur C++ & POO

Instructions de branchement inconditionnel :
Pour contrôler finement le flux d’exécution dans les boucles, on
dispose des instructions suivantes :
break permet de sortir de la boucle à n’importe quel moment
(souvent une condition validée dans la boucle par un if) :
for ( i =0; i < 10; i ++){
if ( i ==5 ){
break ; // quitter la boucle
}
cout < < " i ␣ = " <<i < < endl ;
}
cout < < " je ␣ quitte " ;
Résultat de l’exécution :
i=0 ;i=1 ;i=2 ;i=3 ;i=4 ; je quitte

Instructions de branchement inconditionnel (suite) :
continue va stopper prématurément le tour de boucle actuel
et passer directement au suivant :
for ( i =0; i < 5; i ++){
if ( i ==2 ){
continue ;
// passer a l ’ iteration suivante
}
// cette instruction est ignoree si i ==2
cout < < " i ␣ = " <<i < < " ; " ;
}
cout < < " je ␣ quitte " ;
Résultat de l’exécution :
i=0 ; i=1 ; i=3 ; i=4 ; je quitte

Pointeurs et tableaux
Pointeurs
Le C++, comme le C, permet grâce aux pointeurs de gérer et de
contrôler finement la mémoire utilisée par un programme. Les
pointeurs permettent l’accès direct aux zones mémoire occupées
par des variables en travaillant avec leurs adresses.
Un pointeur est un type de variable particulier qui
contient l’adresse d’une autre variable.
La taille d’un pointeur varie en fonction du nombre de bits du
système : 16, 32, ou pour les machines actuelles : 64 bits.

Pointeurs et tableaux (suite)
Pointeurs - utilisation
int main () {
/* On declare un pointeur sur une variable
de type float ( par exemple ) */
float * ptr ;
// On a declare une variable de type float

float f =5.2;
/* On affecte a ptr l ’ adresse memoire de f

grace a l ’ operateur & */
ptr = & f ; // on dira que ptr pointe sur f
cout < < ptr < < endl ; // affichera l ’ adresse de f

cout < <* ptr < < endl ; // affichera le contenu de f
return 0;}

Pointeurs - utilisation (suite)

L’exécution du code précédent donne :
ptr contient l’adresse en hexadécimale de la variable f.

*ptr contient la valeur pointée par ptr, grâce à l’opérateur de
déréférencement *.
On peut utiliser les pointeurs pour modifier le contenu des variables

pointées (avec *ptr dans l’exemple précédent ; si on écrit
*ptr=10.0, impliquera que f vaut maintenant 10.0).

Les tableaux
Un tableau en C++ est une collection de variables de même type.
La déclaration d’un tableau se fait en déclarant le type des valeurs
contenues dans le tableau, le nom ou l’identificateur du tableau et
sa taille.
# include < iostream >
using namespace std ;
main (){
int tab [10]; // tableau de 10 entiers
// une boucle pour l ’ initialisation
for ( int i = 0; i < 10; i ++) tab [ i ] = i ;
// une boucle pour afficher les elts du tableau
for ( int i = 0; i < 10; i ++)
cout < < " tab [ " <<i < < " ] " <<" : " << tab [ i ] < < endl ;
}

Les tableaux (suite)
On accédera aux élément d’un tableau par leurs indices.
Le premier élément d’un tableau à pour indice 0. le dernier a
pour indice (taille -1).
En C ANSI et en iso C++, la dimension d’un tableau (son
nombre d’éléments) ne peut être qu’une constante, ou une
expression constante. Certains compilateurs l’acceptent
néanmoins en tant qu’extension du langage.
const int N = 10;
int t [ N ];
// Est valide quelque soit le compilateur
int n = 20;
int t [ n ];
/* non valide systematiquement et
doit etre utilise avec precaution . */

Les tableaux (suite)
On peut initialiser un tableau à la déclaration grâce aux {} :
int tab [10] = {1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10};
/* declaration et initialisation d ’ un
tableau d ’ entiers de dimension 10. */
l’identificateur d’un tableau est considéré comme un pointeur

constant qui pointe sur le premier élément du tableau.
int tab [10] = {1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10};
/* la notation tab equivaut a \& tab [0]
i . e l ’ adresse du premier elt du tableau
et * tab vaut tab [0] */
On peut déclarer un pointeur sur un tableau de la façon

suivante : int *ptab ; ptab=tab ; cout«ptab[0] ; // affiche
1 ; c’est le même tableau que tab.

Arithmétique des Pointeurs
Incrémentation/décrémentation de pointeur :
L’incrémentation (ou la décrémentation) de pointeur exprime
le fait que l’on veuille atteindre l’élément pointé suivant (ou
précédent).
Le résultat est correct que si l’objet pointé est situé dans un
même tableau.
Ainsi avec la définition suivante : int *ptr ;
les instructions ptr++ ; ou ptr = ptr + 1 ; sont équivalentes.
Elles incrémentent la valeur du pointeur de la longueur du type
de l’objet pointé, permettant ainsi de désigner le début de
l’élément suivant.
Ces opérations sont impossibles avec des pointeurs sur un type
void.

Arithmétique des Pointeurs (suite)
Addition/soustraction de 2 pointeurs :
l’addition de 2 pointeurs n’a pas de sens et est donc sans
signification.
la soustraction de 2 pointeurs (de même type) situés dans un
même tableau, retourne le nombre d’éléments qui les séparent.
Exemple :
int tab [10] = {1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10};
int * pt1 =& tab [2] , * pt2 =& tab [6];
cout < < pt2 - pt1 ; // affiche : 4
Comparaison de pointeurs : Un pointeur ne pourra être comparé
qu’à un pointeur sur le même type (ou à la constante NULL). Le
résultat de la comparaison sera significatif et portable que si les
pointeurs pointent sur le même objet.

Arithmétique des Pointeurs (suite)

Exemple :
int tab [10] = {1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10};
int *P;
P = tab +9; // dernier element -> legal
P = tab +10; // dernier element + 1 -> legal
P = tab +11; // dernier element + 2 -> illegal
P = tab -1; // premier element - 1 -> illegal

Tableaux 2D
Un tableau 2d est un tableau de tableaux 1d
On peut dire que le nom d’un tableau 2d est l’adresse d’un
tableau 1d contenant les adresses de tableaux 1d.
c’est un Pointeurs de pointeurs.
Exemple :
Int tab [2][3]={{2 ,5 ,7} ,{4 ,6 ,9}};

// declaration d un pointeur de pointeurs
Int ** p ;
// initialisation du pointeur de pointeurs
p = tab ;

Allocation dynamique
Allocation de mémoire
ce qu’on a vu jusqu’à maintenant, c’est la création de tableaux
(1d ou 2d ou plus) statiques, i.e de dimensions fixées au
départ, que probablement on n’utilisera pas entièrement, par
exemple pour les chaînes de caractères.
afin d’économiser la mémoire, il sera utile de tailler la mémoire
selon le besoin.
en C la manipulation dynamique de la mémoire se fait avec les
fonctions malloc et free de la librairie( <stdlib.h>. En
C++, ces fonctions sont remplacées avantageusement par les
opérateurs unaire new et delete.

Allocation de mémoire
int * pi = new int ;

...;
delete pi ;
// Tableau 1 D
int n ;
cin > > n ;
int * tab = new int [ n ];
...;
delete [] tab ;

Allocation de mémoire (suite)
// tableau 2 D NxM
float ** T = new float *[ N ];
for ( int i = 0; i < N ; i ++)
T [ i ] = new float [ M ];
...;
for ( int i = 0; i < N ; i ++)
delete [] T [ i ];
delete [] T ;

CPP Cours2

Transféré par

Droits d'auteur :

Formats disponibles

CPP Cours2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CPP Cours2

Transféré par

Droits d'auteur :

Formats disponibles

Le langage C++ et la programmation orientée

Prof. Mustapha Ameur

int i = 0; // Autre version

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

// On a declare une variable de type float

/* On affecte a ptr l ’ adresse memoire de f

cout < < ptr < < endl ; // affichera l ’ adresse de f

Prof. Mustapha Ameur C++ & POO

Pointeurs - utilisation (suite)

ptr contient l’adresse en hexadécimale de la variable f.

On peut utiliser les pointeurs pour modifier le contenu des variables

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

l’identificateur d’un tableau est considéré comme un pointeur

On peut déclarer un pointeur sur un tableau de la façon

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

Arithmétique des Pointeurs (suite)

Prof. Mustapha Ameur C++ & POO

Int tab [2][3]={{2 ,5 ,7} ,{4 ,6 ,9}};

Prof. Mustapha Ameur C++ & POO

Prof. Mustapha Ameur C++ & POO

int * pi = new int ;

Prof. Mustapha Ameur C++ & POO

Allocation de mémoire (suite)

Prof. Mustapha Ameur C++ & POO

Vous aimerez peut-être aussi