Université Cadi Ayyad

Ecole Supérieure de Technologie – Safi

Cours de Programmation Orientée Objet

(C++)

Pr. SAID EL ABDELLAOUI

Elabdellaoui.said@yahoo.fr

Cours 1

S. El Abdellaoui
Mohamed
El Nabil
Abdellaoui SaïdSaidi 2017 / 2018
 Introduction

Figure 1 : Les langages de programmation classés par „niveau‟.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 2
 Introduction

 Créé en 1980
 Langage évolué et structuré
 Possède les fonctionnalités de la programmation orienté objet (P.O.O)
 Caractéristique du langage C++

 Normalisé par la norme ANSI/ISO en 1998

 Structuré et modulaire

 Programme séparé en fichier

 Fichier séparé en fonctions

 Fonction séparée en blocs

 Portable (de nombreux environnement/compilateurs disponibles)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 3
 Structure d’un programme C++

 Les étapes permettant l‟édition, la mise au point, l‟exécution d'un programme C++

Fichier C++ Code objet

(*.cpp) (*.obj)
Fichier C++ Compilateur Code objet
(*.cpp)
Fichier C++ Code(*.obj)
objet
(*.cpp) (*.obj)

Programme
Bibliothèque Editeur de liens Exécutable
Bibliothèque (*.exe)

Figure 2 : C++ est un langage compilé.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 4
 Structure d’un programme C++
 Chaque fichier se présente comme une suite de fonction.
 Une fonction est imposée: la fonction main
 Fonction principale.
 Point d‟entrée du programme.

Fichier 1 Fichier n

Main Main

Fonction Fonction
Fonction Fonction

Figure 3 : Structure d‟un programme C++

Mohamed
El Nabil
Abdellaoui SaïdSaidi 5
 Structure d’un programme C++
 Exemple :
#include <iostream.h> Inclusion de la bibliothèque
using namespace std; standard (ANSI) du C++
int main () Déclaration pour les E/S
{ de
int annee_creation; fonctions
int NousSommesEn;
int difference; Déclaration des variables

annee_creation = 1968; Affectation des variables

NousSommesEn = 2014;

difference = NousSommesEn - annee_creation; Algorithme

(Relation entrées/sorties)
cout << "Le Departement INFORMATIQUE";
cout << "a ete cree depuis "<< annee_creation; Affichage à l‟écran
des résultats
cout << "Ce qui fait : " << difference << "ans !" ;
return 0;
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 6
 Syntaxe

 Chaque déclaration/instruction se termine par un point-virgule

 Différence entre le majuscule et le minuscule,
 Les commentaires:

\* Ceci est un commentaire sur plusieurs lignes

...
Fin du commentaire*/

// Ceci est un commentaire sur une ligne

 Vous devez commenter votre code ! ; cela aide les lecteurs a comprendre
le code.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 7
 Syntaxe : Saisie et affichage des données
 Entrées/sorties fournies à travers la librairie iostream :
 Saisir une variable au clavier: cin
 Afficher une variable ou une phrase à l‟écran: cout
 Exemple :

cout << ” saisir la variable x : ”;

cin >> x;
cout << endl;
cout << “la valeur de x est : ” << x << endl;

N‟oubliez
pas d‟inclure
la bibliothèque
iostream.h

Mohamed
El Nabil
Abdellaoui SaïdSaidi 8
 Les types élémentaires

Mohamed
El Nabil
Abdellaoui SaïdSaidi 9
 Les Variables (1/3)
 Définition d‟une valeur :

 Nom :

 Unique pour chaque variable

 Commence toujours par une lettre

 Différenciation minuscule-majuscule
 Type :

 Conditionne le format de la variable en mémoire

 Peut être soit un type standard ou un type utilisateur
 Valeur :

 Peut évoluer pendant l'exécution

 Initialisation grâce à l'opérateur d'affectation

Mohamed
El Nabil
Abdellaoui SaïdSaidi 10
 Les Variables (2/3)
 Déclaration locale ou globale:

 Variables globales :

 Définies hors de toutes fonctions

 Vues par toutes les fonctions du fichier source

 Persistante pendant toute la durée de vie du programme

 Variables locales:

 Déclarées à l‟intérieur d‟une fonction

 Détruites en sortie de fonction

Mohamed
El Nabil
Abdellaoui SaïdSaidi 11
 Les Variables (3/3)

#include <iostream.h>
using namespace std;
Déclaration de variable
const float PI = 3.14159; globale

int main ()
{
float rayon = 5.458; Déclaration de variables
float perimetre; locales

// calcul périmètre
perimetre = PI * 2* rayon;

cout << "perimetre p = " << p << endl;

return 0;
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 12
 Les opérateurs
 Affectation : =
 Opérateurs arithmétiques
 Addition: + Soustraction: -
 Multiplication: * Division: / (division entière dans le cas de int)
 Modulo: % (reste de la division entière)
 Opérateurs arithmétiques unaires (un seul opérande)
 Moins unaire: - Incrémentation: ++ Decrémentation: --
 Opérateurs logiques
 Négation: !
 ET logique: &&
 OU logique: ||
 Opérateurs de relation ( ils rendent 1 si la condition est vrai et 0 sinon)
 < , > , <= , >= , == , !=

Mohamed
El Nabil
Abdellaoui SaïdSaidi 13
 Instructions de contrôle (1/11)
 Contrôler le déroulement de l‟enchaînement des instructions à
l‟intérieur d‟un programme, ces instructions peuvent être des
instructions conditionnelles ou itératives
 Instructions conditionnelles : if ….else
 Prototype:

Expression
if( condition ) logique
{
instruction 1
}
Vrai (!=0) Faux (=0)
else
{
instruction 2
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 14
 Instructions de contrôle (2/11)
 Une valeur égale à 0 représente l‟expression logique Faux
 Une valeur différente de 0 représente l‟expression logique Vrai

 1 // vrai
 a=5 //instruction toujours vrai
 a // vrai car a est différent de 0
 !a // faux car !a vaut 0
 a && 7 // vrai car a && 7 vaut 1
 a || 0 // vrai car a || 0 vaut 1
 a && 0 // faux car a && 0 vaut 0
 (a && 0) || (a && 7) // vrai
 (a > 7) && (a > 3) // faux (a > 7) vaut 0 et (a > 3) vaut 1

Mohamed
El Nabil
Abdellaoui SaïdSaidi 15
 Instructions de contrôle (3/11)
#include <iostream.h>
using namespace std;
int main ()
{ int a , b; //entrées
int max; //sorties

cout << " Entrez la 1ere valeur : " << endl;

cin >> a; //saisie
cout << " Entrez la 2eme valeur : " << endl;
Recherche
cin >> b; //saisie
du max
if( a > b )
entre deux entiers
max = a
max = b;

//affichage
cout << " la valeur maximal est : " << max;

return 0;
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 16
 Instructions de contrôle (4/11)
 Instructions de branchement : Switch

switch (expression)
{
case constante_1 : [ suite_d'instructions_1 ] ;
case constante_2 : [ suite_d'instructions_2 ];
..............
case constante_n : [ suite_d'instructions_n ];
default : suite_d'instructions ;
 Exemple : }

int a;
switch (a)
{
case 7 : a=2; //si a égal à 7 j‟affecte 2 à a
case 4 : a=3; //si a égal à 4 j‟affecte 3 à a
default : a=0; //sinon j‟affecte 0 à a
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 17
 Instructions de contrôle (5/11)
#include <iostream.h>
using namespace std;
int main ()
{
char operateur;
cin >> operateur;
switch (operateur)
{
Affiche le travail de l’opérateur
case „+‟ : cout << " addition " ; break;
que l’utilisateur a saisi
case „-‟ : cout << " soustraction " ; break;
au clavier
case „/‟ : cout << " division " ; break;

case „+‟ : cout << " multiplication " ; break;

default : cout << " operateur invalide " ;

}
return 0;
}
Mohamed
El Nabil
Abdellaoui SaïdSaidi 18
 Instructions de contrôle (6/11)
 Instructions itératives

 while tant que (condition) …. faire instruction

 Effectue l‟instruction tant que la condition est vérifiée

while( condition )
{
instruction
}

o si condition est évalué à faux dés le début alors la suite

d‟instruction n‟est jamais exécuté.
o si condition est toujours évalué à vrai, on a un bouclage
infini.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 19
 Instructions de contrôle (7/11)
#include <iostream.h>
using namespace std;
int main ()
{ int max; //entrée
int i; // variable-local
int somme; // sortie
// pre-condition: max >0
// post-relation: somme = 1 + … + max
Calcul de la somme des entiers
i = 1; // initialisation
de 1 à max somme = 0; // initialisation

cin >> max; //saisie

while (i <= max)

{ somme = somme + i;
i = i + 1; } // on écrit en général i++

cout << somme; //affichage

return 0;
}
Mohamed
El Nabil
Abdellaoui SaïdSaidi 20
 Instructions de contrôle (8/11)

 do … while faire instruction …..tant que (condition)

 La condition est évaluée à la fin de la boucle.
 L‟instruction est exécutée au moins 1 fois.

do
{
instructions
}
while( condition ) ;

 Point virgule à la fin!

Mohamed
El Nabil
Abdellaoui SaïdSaidi 21
 Instructions de contrôle (9/11)
#include <iostream.h>
int main ()
{
int max; //entrée
int i; // variable-local
int somme; // sortie
// pre-condition: max >0
// post-relation: somme = 1 + … + max
Calcul de la somme des entiers
i = 1; // initialisation
de 1 à max somme = 0; // initialisation
cin >> max; //saisie

do
{ somme = somme + i;
i = i + 1;
} while (i <= max); // on écrit en général i++

cout << somme; //affichage

return 0;
}
Mohamed
El Nabil
Abdellaoui SaïdSaidi 22
 Instructions de contrôle (10/11)

 La boucle for :

for( exp1 ; exp2 ; exp3 )

{
instructions;
…
}

 Exp1 : initialisation

 Exp2 : condition

 Exp3 : progression

 Utile lorsqu‟on connaît précisément le nombre de fois que l‟on veut

exécuter l‟instruction

Mohamed
El Nabil
Abdellaoui SaïdSaidi 23
 Instructions de contrôle (11/11)
#include <iostream.h>
int main ()
{
int max; //entrée
Calcul de la somme des int i; // variable-local
entiers de 1 à max int somme; // sortie
// pre-condition: max >0
// post-relation: somme = 1 + … + max
// i = 1; // initialisation
somme = 0; // initialisation
Initialisation cin >> max; //saisie
for (i = 1 ; i<= max ; i++)
{ somme = somme + i;
Progression
// i = i + 1; // on écrit en général i++
}
cout << somme; //affichage
return 0; }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 24
 Rupture de séquence

 Break

 Fait sortir de la boucle (while, do…while, for, switch).

 Continue

 Concerne while, do…while et for.

 Saute l‟itération en cours.

 Return

 Dans une fonction => retour à la fonction appelante.

 Peut renvoyer éventuellement une valeur.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 25
 Exercice 1
 Ecrire un programme qui demande à l'utilisateur de taper un entier N
et qui calcule u(N) défini par :* #include <iostream.h>
using namespace std;
u(0)=3 int main () {
u(1)=2
u(n)=n.u(n-1)+(n+1).u(n-2)+n int N,u,i=0,v,w;
cout<<"Tapez la valeur de N : ";
cin>>N; u=3; v=2;
if(N==0)w=u;
else if(N==1)w=v;
else for(i=2;i<=N;i++)
{w=i*v+(i+1)*u+i;
u=v; v=w;}
cout<< "u(" << N << ")=" <<w<< endl;
return 0; }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 26
 Exercice 2
 Ecrire un algorithme qui calcule n! (le nombre n doit être saisie au
clavier). Utiliser une boucle for puis une boucle while.

#include <iostream.h>
using namespace std;
int main () {
int N,i,f=1;
cout << "Tapez un entier : ";
cin>>N;
for(i=2; i<=N; i++) f=f*i;
cout <<N<<"! vaut "<<f<<endl;
return 0; }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 27
 Les tableaux

 Suite de n données du même type, stockées de manières consécutive en mémoire.

 Un tableau est donc une suite de cases (espace mémoire) de même taille. La taille de
chacune des cases est conditionnée par le type de donnée que le tableau contient.
 Les éléments du tableau peuvent être:
 des données de type simple: int, char, float, long, double, ...
(la taille d'une case du tableau est alors le nombre d'octets sur lequel la
donnée est codée).
 des tableaux.
 des structures.
 Lorsque le tableau est composé de données de type simple, on parle de tableau
monodimensionnel (ou vecteur)
 Lorsque celui-ci contient lui même d'autres tableaux on parle alors de tableaux
multidimensionnels (aussi matrice ou table)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 28
 Les tableaux unidimensionnels
 Déclaration d‟un tableau:

type Nom_du_tableau [Nombre d'éléments] ;

 Exemple: un tableau de 10 entiers

int tab [10]; int int int int int int int int int int

Indices 0 1 2 3 4 5 6 7 8 9

Mohamed
El Nabil
Abdellaoui SaïdSaidi 29
 Exemple de manipulation
 Manipulation des éléments comme des variables normales:

int Toto[10]; // Déclaration d‟un tableau de 10 entiers ( [0….9] ).

int h;
int Toto[h]; // erreur de compilation! h est une variable et pas une constante

Toto[7] = 6; // On affecter la valeur 6 au 8ème élément

Toto[9] = Toto[0] + Toto[1]; // On affecte au 10ème élément le résultat de

// l'addition des éléments 1 et 2

int i = 3;
Toto[i+2] = 5; // On affecte 5 au 6 ème élément

Mohamed
El Nabil
Abdellaoui SaïdSaidi 30
 Initialisation d’un tableau

• Valeur par valeur (bof…) • Utilisation d‟une boucle (mieux!)

int Toto[10]; //déclaration

int Toto[10]; //déclaration int Indice; //var locale
//Initialisation for (Indice = 0; Indice < 10; Indice++)
Toto[0]=8; {
Toto[1]=32; Toto[Indice] = 0;
//etc… }

• A la déclaration

int Toto[10] = {1, 2, 6, 5, 2, 1, 9, 8, 1, 5}; // toutes les éléments ont une valeur

int Toto[10] = {1, 2, 6, 5}; // les éléments non définit sont initialisé à 0
// au moins un élément doit être définit

Mohamed
El Nabil
Abdellaoui SaïdSaidi 31
 Restriction
 On ne peut pas affecter une série de valeurs en dehors de la déclaration.

int t[3] = {4, 5, 8}; // OK

int t[3] ;
t = {1, 2, 6, 5}; // ERREUR

 On ne peut pas affecter un tableau à un autre.

int x[3] ,int y[3] ; // déclaration de deux tableaux d‟entier

…
x = y; // ERREUR

 On ne peut pas comparer deux tableaux.

int x[3] ,int y[3] ; // déclaration de deux tableaux d‟entier

…
if(x == y) // ERREUR

Mohamed
El Nabil
Abdellaoui SaïdSaidi 32
Exemple : produit scalaire de deux vecteurs
int main() {

int u[10], v[10]; // déclaration de deux vecteurs de 10 éléments : entrées

int Produit_scalaire = 0; //sortie
int ind; // variable local
cout << "saisie de u"<<endl;

for (ind=0;ind<10;ind++) // saisie des 10 éléments du vecteur u

cin >> u[ind];
cout << "saisie de v"<<endl;

for (ind=0;ind<10;ind++) // saisie des 10 éléments du vecteur v

cin >> v[ind];
for (ind=0;ind<10;ind++) // calcul du produit scalaire
Produit_scalaire = Produit_scalaire + u[ind] * v[ind] ;
cout<< "Le produit scalaire de u et v est: "<< Produit_scalaire <<endl;
return 0;
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 33
 Les tableaux Multidimensionnels
 Déclaration d‟un tableau:

type Nom_du_tableau [dim1][dim2]…[dimn] ;

 Exemple: un tableau d‟entiers à 2 dimensions (3 lignes, 4 colonnes)

Tableau[0][0] Tableau[0][1] Tableau[0][2] Tableau[0][3]

int tab [3][4]; Tableau[1][0] Tableau[1][1] Tableau[1][2] Tableau[1][3]
Tableau[2][0] Tableau[2][1] Tableau[2][2] Tableau[2][3]

Mohamed
El Nabil
Abdellaoui SaïdSaidi 34
 Initialisation d’un tableau

• Valeur par valeur • Utilisation d’une boucle

int Toto[3][5]; //déclaration int Toto[3][5]; //déclaration
int i,j; //var locale
//Initialisation for (i = 0; i < 3; i++)
Toto[0][0]=8; { for (j = 0; j < 5; j++)
Toto[1][2]=32; {
//etc… Toto[i][j] = 0;
}
}

• A la déclaration

int Toto[3][5] = {1, 2, 6, 5, 2, 1, 9, 8, 1, 5,8,3,6,7,9};

// de la forme:
// { [0][0] , [0][1] , [0][2] , [0][3] , [0][4] , [1][0] , [1][1] , [1][2] , [1][3] ,etc ….}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 35
 Transtypages
 Permet de changer le type d‟une valeur.

(type) expression

Type désiré Expression à convertir

 Exemple:

int i=5, j=2;

float result1;
float result2;
Result1 = i / j; // Result1 prend la valeur 2
Result2 =(float) i / (float) j; // Result2 prend la valeur 2.5
// i et j ont été transformés en float pour cette opération

Mohamed
El Nabil
Abdellaoui SaïdSaidi 36
 Les pointeurs

 Enormément utilisé en C/C++ !

 Pourquoi? A quoi ça sert?
 Manipuler directement la mémoire de l‟ordinateur.
 Déclarer des tableaux de taille variable.
 Copier directement des tableaux ou des chaînes de caractères.
 Utile pour le passage de paramètres.
 …

Mohamed
El Nabil
Abdellaoui SaïdSaidi 37
 La notion d’adresse

 La mémoire de l‟ordinateur peut être vu comme une série de cases.

 Ces cases sont repérées par des adresses.
 Dans ces cases sont stockées les valeurs des variables (ou des instructions).

Adresses valeurs
@65775417 123
@65775416 3.2132
@65775415 ‘M’
@65775414 ‘i’
@65775413 ‘a
@65775412 ‘m’

Mohamed
El Nabil
Abdellaoui SaïdSaidi 38
 Qu’est ce qu’un pointeur ?
 Un pointeur est une variable qui contient l‟adresse d‟une variable.
 Le stockage en mémoire de la variable (char, int, etc…) est alors sous la
responsabilité du programmeur.
 On dit que le pointeur pointe sur l‟objet pointé.
 Le type du pointeur est construit à partir du type de l‟objet pointé.
 Exemple
 Déclaration d‟un pointeur

int * Var ; Nom de la variable

Type de l‟objet pointé

On a déclaré une variable de type
« Pointeur sur entier »
Cette variable contient l’adresse d’une case mémoire
contenant un entier

Mohamed
El Nabil
Abdellaoui SaïdSaidi 39
 Opérateur concernant les pointeurs

 Comment accéder à la variable contenue dans un pointeur ?

 Comment récupérer l‟adresse d‟une variable ?

& Opérateur d‟adresse

* Opérateur d‟indirection
-> Membre d‟une structure pointée

 Soit a une variable et p un pointeur:

&a désigne l‟adresse de la variable a

*p désigne la variable pointée par p

Mohamed
El Nabil
Abdellaoui SaïdSaidi 40
Exemple de déclaration et d’utilisation

int i=0; /* Déclare une variable entière. */

int *pi;
/* Déclare un pointeur sur un entier. */

pi=&i; /* Initialise le pointeur avec l‟adresse de cette variable. */

*pi = *pi+1;
/* Effectue un calcul sur la variable pointée par pi,
c‟est-à-dire sur i lui-même, puisque pi contient
l‟adresse de i. */
/* À ce stade, i ne vaut plus 0, mais 1. */

int *px, y, z; // px est un pointeur sur entier

// y et z sont des entiers

Mohamed
El Nabil
Abdellaoui SaïdSaidi 41
 Initialisation des pointeurs (1/5)

 Il faut s‟assurer que les pointeur que l‟on manipule sont bien initialisé!

 Il doivent contenir l‟adresse d‟une variable valide.

 Accéder à la variable d‟un pointeur non initialisé revient à:

 Ecrire ou lirer, dans la mémoire à un endroit aléatoire.

 Plantage à l‟exécution du programme.

 En général on initialise les pointeurs à la déclaration.

 On peut les initialisé comme pointeur NULL.

int * Var; // pour le compilateur Var pointe sur quelque chose (n‟importe quoi)

int * Var = NULL; // le compilateur sait que Var ne pointe sur rien

Mohamed
El Nabil
Abdellaoui SaïdSaidi 42
 Initialisation des pointeurs (2/5)
 Affectation à une variable existante.

int i = 2;
int * P; 65775417
P = &i;
65775416

65775415 2 i = *P

? 65775414

P 65775413 XXXXX
65775415 P

65775412

Mohamed
El Nabil
Abdellaoui SaïdSaidi 43
 Initialisation des pointeurs (3/5)
int i,j; // i, j variables de type int
int * pi, *pj; // pi et pj, variables de type « pointeurs vers int »
pi=&i; // le pointeur est initialisé à &i, il pointe à l‟adresse &i, donc sur i
*pi=2; // accès à l‟élément pointé, i est mis à 2
(*pi)++; // incrémente i qui passe à 3

int t[10]; // tableau de 10 int

pi = &t[2]; // pi pointe sur la case qui contient la valeur T[2]
*(pi + 1) = 0; // T[3] est mis à 0 (les éléments d‟un tableau se suivent en mémoire)

int i=2, j , k ;
int * p1, * p2;
p1 = &i; // p1 contient l‟adresse de i
*p1 = i; // inutile! Car pi=&i donc automatiquement *pi=i
p2 = k; // attention l‟adresse p2 prend une valeur non défini(p2 pointe n‟importe ou)
*p2 = 3; // on écrit quelque chose à un endroit inconnu ! Plantage!

Mohamed
El Nabil
Abdellaoui SaïdSaidi 44
 Initialisation des pointeurs (4/5)
 Allocation dynamique.
 On réserve la place pour la variable pointée.
 Syntaxe: Nom_Variable = new type ;

int * P;
65775417
P = new int ;
65775416

65775415 *P

65775414
?
P 65775413 XXXXX
65775415 P

65775412

Mohamed
El Nabil
Abdellaoui SaïdSaidi 45
 Initialisation des pointeurs (5/5)

 Allocation dynamique
 Il faut penser à libérer la mémoire après utilisation !
 Syntaxe: delete Nom_Variable ;
 Même si on déclare un pointeur dans une fonction (local), il doit être libéré !

char * C; // C est un pointeur qui pointe sur n‟importe quoi

C = new char ; // Allocation d‟un espace pouvant stocker un caractère
// C pointe sur cet espace

double * D;
D = new double ;
*D = 12.34;
delete D ; // libération de l‟espace occupé par le double

Mohamed
El Nabil
Abdellaoui SaïdSaidi 46
 Arithmétique des pointeurs
 Les opérateur ++, --, +, = ….. Sont définis pour les pointeurs, mais attention, ils
s‟appliquent aux adresses.

int * P;
…. //allocation
65775417 123
P ++ ;
65775416 12
P=P–2;
int * Q = P + 3; Q 65775415 156
65775414 3
65775413 9
65775412 456
P

Mohamed
El Nabil
Abdellaoui SaïdSaidi 47
 Les tableaux dynamiques (1/3)
 Un tableau est en fait un pointeur!

int tableau[3];
int * P = tableau ;
tableau [2] = 5 ;
*(tableau+1) = 4; 65775417
P[0]=1; // *(P+0) = 1 65775416

65775415 5
P 65775414 4
65775413 1
tableau
65775412

Mohamed
El Nabil
Abdellaoui SaïdSaidi 48
 Les tableaux dynamiques (2/3)
int tab[3];
int * Ptab, x; // Ptab pointeur sur un int
Ptab = & tab [0]; // Ptab pointe sur le début du tableau
// équivalent à Ptab = tab
x = *Ptab; // équivalent à x = tab[0]
*(Ptab+ i) = 3; // équivalent à tab[i]=3, *(tab + i) = 3 , Ptab[i]=3

 Les allocation dynamique

 Possibilité de créer un tableau de taille non constante !
 Syntaxe: Type * NomTab;
NomTab = new Type [Taille]; // allocation
delete [ ] NomTab; // destruction

int n = 3;
int tab[n]; // INTERDIT
int * Ptab = new int [n]; // OK
….
delete [ ] Ptab; // désallocation du pointeur

Mohamed
El Nabil
Abdellaoui SaïdSaidi 49
 Les tableaux dynamiques (3/3)
 Un tableau est un pointeur constant !

int tab[3]; // déclaration d‟un tableau de 3 éléments

int * Ptab = new int [3]; // déclaration d‟un pointeur avec allocation pour 3 éléments
Ptab ++; // OK
tab++; // ERREUR tab est constant
Ptab = tab; // ok les deux pointeur Ptab et tab pointe au même endroit (sur tab[0])
Tab = Ptab ; // ERREUR tab est constant

 On peut donc transtyper un pointeur en tableau mais pas l‟inverse!

 L‟affectation est possible entre pointeur.

int * tab1 = new int [3]; // déclaration d‟un pointeur avec allocation pour 3 éléments
int * tab2 = new int [3]; ;
Tab2 = tab1 ; //attention Tab2 pointe maintenant au même endroit que Tab1
char * chaine;
chaine = "coucou";

Mohamed
El Nabil
Abdellaoui SaïdSaidi 50
 Affectation de pointeur

int * tab1 = new int [3];

65775417
int * tab2 = new int [3]; 12
// remplissage 65775416
3
tab2 = tab1;
65775415 65
delete [] tab2; tab2
delete [] tab1; 65775414
789

Erreur 65775413 31

65775412 756
tab2 = tab1

Mohamed
El Nabil
Abdellaoui SaïdSaidi 51
TD 1

52