3IIR
Exercices en C++ : Manipulation des
tableaux avec pointeurs
Exercice 1:
Les pointeurs
Une variable pointeur est destinée à manipuler des adresses d’informations d’un type donné.
On la déclare comme dans ces exemples :
int * ad_int ; // ad_int contiendra des adresses d’entiers de type int
float * ad_float ; // ad_float contiendra des adresses de flottants de type
float
L’opérateur & permet d’obtenir l’adresse d’une variable :
int n;
/*
Instructions
*/
ad_int = &n ; // ad_int contient l’adresse de n
L’opérateur * permet d’obtenir l’information d’adresse donnée. Ainsi * ad_int désigne la
valeur de l’adresse mémoire de ad_int, c’est-à-dire ici n :
int p = *ad_int ; // place dans p la valeur de n
*ad_int = 40 ; // place la valeur 40 à l’adresse contenue dans ad_int,
// donc ici dans n
NB : Il existe un type « pointeur générique », c’est-à-dire pour lequel on ne précise pas la nature
des informations pointées, à savoir le type void *.
Opérations sur les pointeurs :
On peut incrémenter ou décrémenter des pointeurs d’une valeur donnée. Par exemple :
ad_int++ ; // modifie ad_int de manière qu’elle pointe
// sur l’entier suivant n
ad_int -= 10 ; // modifie ad_int de manière qu’elle pointe
// 10 entiers avant
L’unité d’incrémentation ou de décrémentation des pointeurs génériques est l’octet.
On peut comparer ou soustraire des pointeurs de même type (pointant sur des éléments de
même type).
Tableaux et Pointeurs :
Un nom de tableau est une constante pointeur. Exemple 1:
int t[10] ;
t+1 est équivalent à &t[1] ;
1
t+i est équivalent à &t[i] ;
ti] est équivalent à *(t+i).
Exemple 2 :
int t[3] [4] ;
t est équivalent à &t[0][0] ou à t[0] ;
t+2 est équivalent à &t[2][0] ou à t[2]
Lorsqu’un nom de tableau est utilisé en argument effectif, c’est (la valeur de) l’adresse qui est
transmise à la fonction. La notion de transmission par référence n’a pas de sens dans ce cas.
Dans la déclaration d’une fonction disposant d’un argument de type tableau, on peut utiliser
indifféremment le formalisme « tableau » (avec ou sans la dimension effective du tableau) ou
le formalisme pointeur ; ces trois déclarations sont équivalentes :
void fct (int t[10])
void fct (int t[])
void fct (int * t)
Exercice 1:
Écrire une fonction qui ne renvoie aucune valeur et qui détermine la valeur maximale et la
valeur minimale d’un tableau d’entiers (à un indice) de taille quelconque. On prévoira 4
arguments : le tableau, sa dimension, le maximum et le minimum. Pour chacun d’entre eux, on
choisira le mode de transmission le plus approprié (par valeur ou par référence). Dans le cas où
la transmission par référence est nécessaire, proposer deux solutions : l’une utilisant
effectivement cette notion de référence, l’autre la « simulant » à l’aide de pointeurs.
Écrire un petit programme d’essai.
Solution :
En C++, par défaut, les arguments sont transmis par valeur. Mais, dans le cas d’un tableau,
cette valeur, de type pointeur, n’est rien d’autre que l’adresse du tableau. Quant à la
transmission par référence, elle n’a pas de signification dans ce cas. Nous n’avons donc aucun
choix concernant le mode de transmission de notre tableau.
En ce qui concerne le nombre d’éléments du tableau, on peut indifféremment en transmettre
l’adresse (sous forme d’un pointeur de type int *), ou la valeur ; ici, la seconde solution est
la plus appropriée, puisque la fonction n’a pas besoin d’en modifier la valeur.
En revanche, en ce qui concerne le maximum et le minimum, ils ne peuvent pas être transmis
par valeur, puisqu’ils doivent précisément être déterminés par la fonction. Il faut donc
obligatoirement prévoir de passer :
- soit des références. L’en-tête de notre fonction se présentera ainsi :
void maxmin (int t[], int n, int & admax, int & admin)
- soit des pointeurs sur des float. L’en-tête de notre fonction se présentera ainsi :
void maxmin (int t[], int n, int * admax, int * admin)
La fonction avec transmission par référence :
void maxmin (int t[], int n, int & admax, int & admin)
{ int i ;
admax = t[1] ;
2
admin = t[1] ;
for (i=1 ; i<n ; i++)
{ if (t[i] > admax) admax = t[i] ;
if (t[i] < admin) admin = t[i] ;
}
}
Avec transmission par pointeurs :
void maxmin (int t[], int n, int * admax, int * admin)
{ int i ;
*admax = t[1] ;
*admin = t[1] ;
for (i=1 ; i<n ; i++)
{ if (t[i] > *admax) *admax = t[i] ;
if (t[i] < *admin) *admin = t[i] ;
}
}
Ici, si l’on souhaite éviter les « indirections » qui apparaissent systématiquement dans les
instructions de comparaison, on peut travailler temporairement sur des variables locales à
la fonction (nommées ici max et min). Cela nous conduit à une fonction de la forme
suivante :
void maxmin (int t[], int n, int * admax, int * admin)
{
int i, max, min ;
max = t[1] ;
min = t[1] ;
for (i=1 ; i<n ; i++)
{ if (t[i] > max) max = t[i] ;
if (t[i] < min) min = t[i] ;
}
*admax = max ;
*admin = min ;
}
Voici un petit exemple de programme d’utilisation de la première fonction :
#include <iostream>
using namespace std ;
main()
{
void maxmin (int [], int, int &, int &) ;
int t[8] = { 2, 5, 7, 2, 9, 3, 9, 4} ;
int max, min ;
maxmin (t, 8, max, min) ;
cout << "valeur maxi : " << max << "\n" ;
cout << "valeur mini : " << min << "\n" ;
}
Et voici le même exemple utilisant la seconde fonction :
#include <iostream>
using namespace std ;
main()
3
{ void maxmin (int [], int, int *, int *) ;
int t[8] = { 2, 5, 7, 2, 9, 3, 9, 4} ;
int max, min ;
maxmin (t, 8, &max, &min) ;
cout << "valeur maxi : " << max << "\n" ;
cout << "valeur mini : " << min << "\n" ;
}
Exercice 2 :
Écrire une fonction qui fournit en retour la somme des valeurs d’un tableau de flottants à deux
indices dont les dimensions sont fournies en argument.
Écrire un programme qui demande à l’utilisateur de lui fournir un nombre entier entre 1 et 7 et
qui affiche le nom du jour de la semaine ayant le numéro indiqué (lundi pour 1, mardi pour 2,
... dimanche pour 7).
Solution :
Une démarche consiste à créer un « tableau de 7 pointeurs sur des chaînes », correspondant
chacune au nom d’un jour de la semaine. Comme ces chaînes sont ici constantes, il est possible
de créer un tel tableau par une déclaration comportant une initialisation de la forme :
char * jour [7] = { "lundi", "mardi", "mercredi", "jeudi",
"vendredi", "samedi", "dimanche"} ;
N’oubliez pas alors que jour[0] contiendra l’adresse de la première chaîne, c’est-à-dire
l’adresse de la chaîne constante "lundi" ; jour[1] contiendra l’adresse de "mardi"...
Pour afficher la valeur de la chaîne de rang i, il suffit de remarquer que son adresse est
simplement jour[i-1]. Le programme demandé :
#include <iostream>
using namespace std ;
main()
{
char * jour [7] = { "lundi", "mardi", "mercredi", "jeudi",
"vendredi", "samedi", "dimanche"
} ;
int i ;
do
{ cout << "donnez un nombre entier entre 1 et 7 : " ;
cin >> i ;
}
while ( i<=0 || i>7) ;
cout << "le jour numéro " << i << " de la semaine est " << jour[i-1] ;
}
