Cours3 C-2021

25/12/2021
UNIVERSITÉ DES SCIENCES ET DE LA TECHNOLOGIE D’ORAN « USTOMB »

FACULTÉ DE GÉNIE ÉLECTRIQUE - DÉPARTEMENT D’ELN
MASTER 1: RT / ESE / II / IB MODULE: POO
Tableaux, Pointeurs, Chaines

de caractères en C++
La responsable du module: Dr. MEDDEBER-ZOUAGUI L.

lmeduniv@gmail.com
Tableaux
Statiques
1
25/12/2021
Les tableaux
Schématiquement, un tableau est une collection d’éléments de même
type.
type
 Ici, tableau à une dimension « unidimensionnel » contenant 5 éléments
V0 V1 V2 V3 V4
 Ici, tableau à 2 dimensions contenant 6 éléments.

V00 V01 V02
V10 V11 V12
En pratique, un nom de tableau est un pointeur vers son emplacement

mémoire.
Les éléments se suivent séquentiellement en mémoire

3
Les tableaux
Déclaration:
type ident [expr], …;
• Type: type d’éléments contenus

• Ident: le nom donné à cette variable
• Expr: le nombre d’éléments
int tableau [100];
2
25/12/2021
Les tableaux
La borne inférieure d’un indice de tableau vaut
toujours 0
int tableau [5];
Les indices
du tableau t[0] t[1] t[2] t[3] t[4]
Les valeurs v0 v1 v2 v3 V4
du tableau
Les tableaux - Initialisation
Un tableau peut être initialisé à sa déclaration par un agrégat

agrégat.
int tab[5] = {1, 2, 3, 4, 5};
tab 1 2 3 4 5
La liste n’a pas besoin d’être complète

complète. Seuls les 1ers éléments sont
initialisés explicitement
static int tab[5] = {2, 4, 6};
2 4 6 0 0
Les éléments seront initialisés à « 0 » par défaut

défaut, également pour la
classe « auto »
6
3
25/12/2021
#include <iostream>
using namespace std; 2
4
int main () 6
{ 0
int tab[5] = {2, 4, 6}; 0
Appuyer une ...
for (int i=0; i<5; i++)
cout << tab[i] << "\n";
system ("pause");
return EXIT_SUCCESS;
}

La liste n’ayant pas besoin d’être complète, on peut la laisser vide pour
initialiser un tableau à 0
int tab[5] = {}; 0 0 0 0 0
Plus rapide et « simple » qu’une boucle.

Si tous les éléments sont initialisés, alors la taille du tableau peut
être déduite par le compilateur.
int tab[] = {2, 4, 6, 8, 1}; 2 4 6 8 1
Le compilateur ne pourra pas accepter un nombre d’éléments

dépassant la taille spécifiée.
int tab[3] = {2, 4, 6, 8, 1};

8
4
25/12/2021
Les tableaux – à 2 dimensions

La déclaration d’un tableau à 2 dimensions se fait en ajoutant les dimensions
int tab [2][3];
float cube [3][3][3];
L’accès à un élément se fait également en utilisant les coordonnées de la cellule choisie
tab [1][1] = 12;

12
Souvenons-nous qu’il n’y a aucun contrôle des contraintes.
tab [1][3] = 12;

9 12

En réalité, les tableaux multidimensionnels sont des tableaux de tableaux
0,0
0,0 0,1
0,1 0,2
0,2
int tab [2][3];
1,0
1,0 1,1
1,1 1,2
1,2
tab
tab[0] tab[1]
&tab[0][0] &tab[1][0]
10
5
25/12/2021
tab ? ? ? ? ? ?
tab[0] tab[1]
&tab[0][0] &tab[1][0]
tab: désigne un tableau de tableaux

tab[1]: désigne un tableau à 1 dimension et comprenant 3 éléments
tab[1][1]: désigne un des éléments du tableau
&tab[1][0]:désigne l’adresse de la cellule du tableau aux coordonnées [1][0]
tab[0]
&tab[0][0] 0,0
0,0 0,1
0,1 0,2
0,2
tab[1]
&tab[1][0] 1,0
1,0 1,1
1,1 1,2
1,2
11

Du point de vue mémoire, le dernier indice de la déclaration varie le
plus rapidement
for (int li=0; li<2; li++)

{
// afficher les éléments 0,0 0,1 0,2
for (int co=0; co<3; co++)
cout << tab[li][co]; 1,0 1,1 1,2
// passer à la ligne
cout << "\n";
}
12
6
25/12/2021

L’initialisation des tableaux à 2 dimensions:
int tab [2][3] = {{10, 15,12}, 10 15 12
{13, 14, 5}}; 13 14 5
Un agrégat en C/C++ n’ayant pas besoin d’être complet, nous pouvons

écrire:
int tab [2][3] = { {0, 1, 2}, 0 1 2
{1} };
 1 0 0
int tab [2][3] = {0, 1, 2, 1};


0 1 2 1 0 0
int tab [2][3] = { {0, 1}, 0 1 0

{2} };
2 0 0
int tab [2][3] = {0, 1, 2}; 

13 0 1 0 2 0 0
A titre d’exemple, un tableau à 3 dimensions initialisé avec des valeurs

entières successives
int tab [3][5][7];
int m = 0;
for (int i = 0; i < 3; i++ )
for (int j = 0; j < 5; j++ )
for (int k = 0; k < 7; k++ )
tab [i][j][k] = m++;
14
7
25/12/2021
Les tableaux – en paramètre
L’identificateur d’un tableau est en fait un pointeur (adresse du

tableau).
NB : pour passer un tableau en paramètre,

paramètre il ne faut pas utiliser « & ».
int tableau[10];
int sp (int tab []);

En réalité, les 2 écritures suivantes sont possibles dans ce cas.
int sp (int tab []);
int sp (int tab [10]);

S’agissant d’un tableau à une dimension, la valeur entre les « [ ] » sera
ignorée par le compilateur.
15
Les bornes n’étant pas connues, il sera par contre nécessaire de les
transmettre
int minimum ( int vecteur [],int taille )
{
// cas du tableau vide n'est pas géré ici!
int min = vecteur [0];
for (int i = 1; i < taille; i++ )

if (vecteur [i]< min)
min = vecteur [i];
return min;
}
int tab[10];
…
cout << minimum (tab, 10);
16
8
25/12/2021

Le compilateur doit pouvoir calculer la position en mémoire des
éléments. Pour les tableaux à 1 dimension, hormis le respect des
éléments
contraintes, il n’y a aucun problème particulier. En revanche, pour les
tableaux à plusieurs dimensions
dimensions, il faudra renseigner le
compilateur plus complètement pour pouvoir calculer la position de
chacun des éléments.
éléments
Void essai (int tab [ ][3], int ligne, int col);
Dans le cas d’un tableau à 3 dimensions, nous aurions :

void sp (int tab [2][3][4],int n,int m,int k);
ou
void sp (int tab [ ][3][4], int n, int m, int k);
17
17
La déclaration d'un tableau en mémoire
18
9
25/12/2021
Les éléments d'un tableau en mémoire
19
Attention à ne pas sortir du tableau
20
10
25/12/2021
21
Tableaux
Dynamiques
« vector »
11
25/12/2021
Les tableaux – Classe « Vector »
La classe « vector » permet d’utiliser des tableaux d’éléments de

n’importe quel type, à plusieurs dimensions…
Dans le cas de « vector » qui est une classe générique, il faut encore
préciser le type des éléments à manipuler.
vector<int> unVecteur;
Nous disposons maintenant d’un tableau vide!

vide à cause du constructeur
par défaut
défaut.
vector<int
int> unVecteur (10);
Un vecteur de 10 entiers initialisés à 0

23

Pour utiliser « vector » il faut inclure
#include <vector>
La classe « vector » fait partie de ce que l’on appelle les conteneurs qui
permettent la gestion de structures dynamiques de données complexes
Les autres fonctionnalités (méthodes) complétées d’éventuels

paramètres sont applicables à un objet en particulier
objet.methode (paramètres);
24
12
25/12/2021
25
Quelques possibilités offertes par « vector »

v[1] = 2; Accès et affectation d’un élément.
v[12] = 2; Toujours aucun contrôle!

Affectation avec cette fois le contrôle de
v.at(1) = 2;
l’existence de l’élément accédé.
Si l’élément n’existe pas, l’exception
v.at(12) = 2;
« out_of_range » est levée.
Affectation globale du vecteur v2 dans le
v1 = v2;
vecteur v1. Peuvent être de tailles différentes.
26
13
25/12/2021
Quelques possibilités offertes par « vector »

v.size() Retourne la taille (nbre éléments)
Retourne « true » si l’objet considéré
v.empty()
est vide, « false » dans le cas contraire.
Redimensionne le vecteur. Si la taille
v.resize(5); est plus grande, le vecteur risque d’être
déplacé en mémoire => pointeurs ?!
Ajoute un élément en fin de structure.
v.push_back(2);
La structure est également mise à jour.
supprime le dernier élément de la
v.pop_back();
structure.
v.back(); Retourne la valeur du dernier élément.
27
28
14
25/12/2021

La valeur la plus petite dans un vecteur.
int minimum ( vector<int> vecteur )

{
int min = vecteur [0];
for (int i = 1;i < vecteur.size(); i++ )
if ( vecteur [i] < min )

min = vecteur [i];
return min;
}
29
Les tableaux – Classe « Vector » à 2 dimensions
Un « vecteur » peut lui-même consister en une classe quelconque, pourquoi

pas un autre vecteur
// un vecteur d’entiers
vector<int> unVecteur (10); // un vecteur
// un vecteur de vecteurs
vector < vector<int> > tab;
Pour l’instant, « tab » ne contient aucun élément
15
25/12/2021
Les tableaux – Classe « Vector » à 2 dimensions

Pour dimensionner ce vecteur de vecteurs, il faudra le faire en 2 fois:
// 3 vecteurs de vecteurs vide pour l’instant
tab.resize(3);
// dimensionner chacun des vecteurs imbriqués

for (int ligne=0; ligne<tab.size(); ligne++ )
tab [ligne].resize (4);
Donc 1 vecteur de 3 éléments désignant chacun 1 vecteur de 4

éléments. L’accès
accès aux données se fait normalement
cout << tab[3][2];
tab 3 4 v0 v1 v2 v3
4 v0 v1 v2 v3
31 4 v0 v1 v2 v3
Les pointeurs
32
16
25/12/2021
C++ : les pointeurs
33
C++ : les pointeurs
Attention, source d’erreur :

Il faut faire attention quand on déclare plusieurs
pointeurs à la suite :
int *p1, p2; // p1 est un pointeur, p2 est un entier
int *p1, *p2; // p1 et p2 sont des pointeurs
int *p1=NULL, *p2=NULL; // ils sont initialisés
#include <cstdlib>
34
17
25/12/2021
C++ : les pointeurs
35
C++ : les pointeurs/précision
Il y a donc toujours deux temps à respecter avant d’utiliser un pointeur

(comme pour toute variable, d’ailleurs) :
int *p1; // JE DECLARE
p1 = &i; // JE DONNE UNE VALEUR(Adresse de i)
int *p2; // JE DECLARE
p2 = new int; // JE DONNE UNE VALEUR (VERSION AVEC ALLOCATION
DYNAMIQUE)
// ...
delete p2; // MAIS IL FAUDRA LIBERER LA MEMOIRE
Le danger vient que l’on manipule ici des adresses. Un pointeur non
initialisé pointe vers n’importe quoi (ce qui provoque des erreurs «
aléatoires », non reproductibles).
36
18
25/12/2021
C++ : les pointeurs
37
C++ : les pointeurs
38
19
25/12/2021
C++ : « arithmétique » des pointeurs
*P *P+1 *P+2
(*P)+1 (*P)+2
39
Exemples:
40
20
25/12/2021

Exemples:
int *pi; // pi pointe sur un objet de type entier

float *pr; // pr pointe sur un objet de type réel
char *pc; // pc pointe sur un objet de type caractère
*pi = 421; // 421 est le contenu de la case mémoire p et des 3 suivantes
*(pi+1) = 53; // on range 53, 4 cases mémoire plus loin
*(pi+2) = 0xabcd; // on range 0xabcd 8 cases mémoire plus loin
*pr = 45.7; // 45,7 est rangé dans la case mémoire r et les 3 suivantes
pr++; // incrémente la valeur du pointeur pr (de 4 cases mémoire)
*pc = 'j'; // le contenu de la case mémoire pc est le code ASCII de 'j'
pc--; // décrémente la valeur du pointeur pc (d'une case mémoire)
41
C++ : new et delete
objectif: allouer et désallouer de la mémoire sans dépendre la durée de

vie des variables.
 « P = new type ; » alloue un espace mémoire pour contenir un objet
de type type et retourne l’adresse ce cette zone mémoire.
 « delete P ; » désalloue l’espace mémoire d’adresse P.
 « P = new type[N] ; » alloue un espace mémoire capable de
contenir N objets de type type ...
 «delete P ou delete [ ] P ; » désalloue l’espace mémoire d’adresse P.
Une zone allouée par new n’est désallouée que par l’appel de delete. . .
42
21
25/12/2021
C++ : new et delete
43
C++ : new et delete
44
22
25/12/2021
C++ : Pointeurs et tableaux
45
C++ : Pointeurs et tableaux
46
23
25/12/2021
C++ : new et delete
 Manipulation de la valeur pointée :

int *p = new int; // p est de type pointeur sur entier « int* »
(*p)=3; // (*p) est de type int
int *tab = new int [20]; // tab correspond à l’adresse du début //de la zone
mémoire allouée pour contenir 20 entiers
(*tab)=3; // équivalent à tab[0]=3
 Manipulation de pointeur :
tab++; //décalage de tab d’une zone mémoire de taille sizeof(int) tab pointe sur la
zone mémoire devant contenir le 2ème élément du tableau
(*tab)=4; // équivalent à tab[0]=4 car on a décalé tab à l’instruction précédente
*(tab+1)=5; // équivalent à tab[1]=5 sans décaler tab
tab-=2 ; // tab est repositionné au début de la zone mémoire
// allouée par new
47
C++ :Manipulation des pointeurs et des valeurs pointées

« new et delete »
 Manipulation de la valeur pointée :

int *p = new int; // p est de type int*
(*p)=3; // (*p) est de type int
int *tab = new int [20]; // tab correspond à l’adresse du début
 Libération de la mémoire allouée:

delete p;
delete [] tab; //Ne pas oublier de libérer la mémoire allouée!!
48
24
25/12/2021

« new et delete »
*(tab+1)=3
49

« new et delete »
50
25
25/12/2021
#include <iostream>
#include <ctime>
usingspace std;
void display(long double **);
void de_allocate(long double **);
const int MAX =50;
Const int MIN =25;
int main(void)
{ double **data; int m,n; //m: Nb_Rows , n:Nb_Columns
srand(time(NULL));
cout<<"n= " ; cin>>n; cout<< " m " ; cin>>m;
data = new double*[m]; // STEP 1: SET UP THE ROWS.
for (int j = 0; j < m; j++)
data[j] = new double[n]; // STEP 2: SET UP THE COLUMNS
for (int i = 0; i < m; i++)

for (int j = 0; j < n; j++)
data[i][j] = (rand() % (MAX - MIN + 1)) + MIN;
display(data);
de_allocate(data);
return 0;
51 }
void display(double **data)

{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
cout << data[i][j] << " ";
cout << "\n" << endl;
}
}
void de_allocate(double **data)

{
for (int i = 0; i < m; i++)
delete[] data[i]; // STEP 1: DELETE THE COLUMNS
delete[] data; // STEP 2: DELETE THE ROWS
52
26
25/12/2021
Les chaines de
caractères
53
C++ : les chaines de caractères
54
27
25/12/2021
C++ : Longueur d’une chaine de caractères
55
C++ : Caractère de fin d’une chaine de caractères
56
28
25/12/2021
C++ : Accéder à un caractère de la chaîne
57
C++ : Fonctions relatives aux chaine de caractères
58
29
25/12/2021
C++ : Comparaison des chaines de caractères
59
C++ : Comparaison des chaines de caractères
60
30
25/12/2021
C++ : Comparaison des chaines de caractères « strcmp »
61
C++ : Recopier des chaines de caractères
62
31
25/12/2021
C++ : Recopier des chaines de caractères « strcpy »
63
C++ : Longueur d’une chaine de caractères « strlen »
64
32
25/12/2021
C++ : Convertir une chaîne en une valeur numérique

« atoi » et « atof »
65
C++ : Les chaînes de caractères avec la classe <string>
66
33
25/12/2021
67
68
34

Cours3 C-2021

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

Cours3 C-2021

Transféré par

Droits d'auteur :

Formats disponibles

25/12/2021

UNIVERSITÉ DES SCIENCES ET DE LA TECHNOLOGIE D’ORAN « USTOMB »

MASTER 1: RT / ESE / II / IB MODULE: POO

Tableaux, Pointeurs, Chaines

La responsable du module: Dr. MEDDEBER-ZOUAGUI L.

 Ici, tableau à 2 dimensions contenant 6 éléments.

En pratique, un nom de tableau est un pointeur vers son emplacement

Les éléments se suivent séquentiellement en mémoire

• Type: type d’éléments contenus

int tableau [100];

int tableau [5];

Les tableaux - Initialisation

Un tableau peut être initialisé à sa déclaration par un agrégat

int tab[5] = {1, 2, 3, 4, 5};

La liste n’a pas besoin d’être complète

static int tab[5] = {2, 4, 6};

Les éléments seront initialisés à « 0 » par défaut

Les tableaux - Initialisation

Les tableaux - Initialisation

Plus rapide et « simple » qu’une boucle.

Le compilateur ne pourra pas accepter un nombre d’éléments

int tab[3] = {2, 4, 6, 8, 1};

Les tableaux – à 2 dimensions

int tab [2][3];

float cube [3][3][3];

L’accès à un élément se fait également en utilisant les coordonnées de la cellule choisie

tab [1][1] = 12;

Souvenons-nous qu’il n’y a aucun contrôle des contraintes.

tab [1][3] = 12;

Les tableaux – à 2 dimensions

Les tableaux – à 2 dimensions

tab: désigne un tableau de tableaux

Les tableaux – à 2 dimensions

for (int li=0; li<2; li++)

Les tableaux – à 2 dimensions

Un agrégat en C/C++ n’ayant pas besoin d’être complet, nous pouvons

int tab [2][3] = {0, 1, 2, 1};

int tab [2][3] = { {0, 1}, 0 1 0

int tab [2][3] = {0, 1, 2}; 

Les tableaux – à 3 dimensions

A titre d’exemple, un tableau à 3 dimensions initialisé avec des valeurs

int tab [3][5][7];

Les tableaux – en paramètre

L’identificateur d’un tableau est en fait un pointeur (adresse du

NB : pour passer un tableau en paramètre,

int sp (int tab []);

int sp (int tab [10]);

Les tableaux – en paramètre

for (int i = 1; i < taille; i++ )

Les tableaux – en paramètre

Void essai (int tab [ ][3], int ligne, int col);

Dans le cas d’un tableau à 3 dimensions, nous aurions :

La déclaration d'un tableau en mémoire

Les éléments d'un tableau en mémoire

Attention à ne pas sortir du tableau

Les tableaux – Classe « Vector »

La classe « vector » permet d’utiliser des tableaux d’éléments de

Nous disposons maintenant d’un tableau vide!

Un vecteur de 10 entiers initialisés à 0

Les tableaux – Classe « Vector »

Les autres fonctionnalités (méthodes) complétées d’éventuels

Les tableaux – Classe « Vector »

Les tableaux – Classe « Vector »