Plan du cours de Programmation avance

Les pointeurs

Les fonctions

La rcursivit

Les fichiers
1
Les pointeurs en langage C
Introduction:

Un pointeur est un identificateur qui contient ladresse mmoire dune information.
Comme toute variable, un pointeur doit tre dclar au pralable, et doit avoir un type.
Syntaxe :
type *nom_pointeur; // la prsence de *, permet de distinguer un pointeur .
Exemple : int *p;
Manipulation :

Le nom dun pointeur dsigne ladresse mmoire de la valeur stocke.
La valeur correspondante un pointeur est accessible laide de celui-ci prcd de *
La rcupration de ladresse dune variable ordinaire est ralise laide de &.
Exemple :
int i , j , *p;
.
i = 6 ;
p = NULL; // p contient ladresse nulle : pas dadresse (par dfaut).
p= &i ; //p pointe vers la case mmoire de la variable i
j=*p ; // affecter j la valeur de la case mmoire pointe par p(=6)
*p = j + 1; // stocker dans la case mmoire, pointe par p, la valeur de j+1




Chapitre I : Les pointeurs en langage <<C>> 2
Les pointeurs en langage C
Oprations arithmtiques :
Comme pour les variables numriques, on peut effectuer des oprations arithmtiques sur
Les pointeurs.
Les oprations restent lies au type du pointeur.
Exemple :
int *p;
// initialisation de p
p++; //incrmentation de ladresse mmoire de p,
Rem : cette incrmentation dpend du type de p, dans ce cas p est incrment de la taille dun
entier, soit 4 octets , sachant que lespace mmoire dsign est dj allou.
Donc , p va pointer vers un espace mmoire, avec un dplacement de 4 octets par rapport
lancienne adresse.
Exemple :
char *p;
.//initialisation de p
p++;
Rem : dans ce cas, p est incrment de la taille dun caractre, soit 1 octet.

Conclusion : lunit dincrmentation ou de dcrmentation dun pointeur est toujours de la
taille mmoire du type associ.
Chapitre I : Les pointeurs en langage <<C>> 3
Les pointeurs en langage C
Pointeurs&Tableau :
Malgr que les tableaux statiques sont gnralement parcourus laide des indices, il est
possible de se dplacer laide des pointeurs.
Le nom dun tableau, sans indice, reprsente ladresse de son 1
er
lment, de l on peut se
dplacer grce larithmtique des pointeurs.

Exemple :
int v[10],*p , x;
..//initialisation de v
p=v; //p contient ladresse du 1
er
lment de v, ou autrement : p=&v[0]
x=*p; // x contient la valeur de la case mmoire pointe par p :c--d v[0]
p++; // p est incrment de 4 octets(entier), donc p pointe sur v[1]
x=*p + 1; //x contient v[1] +1
x=*(p+1); //x contient la valeur de la case mmoire pointe par p+1: soit v[2]
x=*++p; // p est incrment de 1 pour pointer sur v[2], dont la val est affecte x
x=++*p; // incrmenter de 1 la case pointe par p, soit ++v*2+, puis laffecter x
x=*p++; // la valeur de la case pointe par p est affecte x, soit v[2], puis p est
// incrment de 1 pour pointer vers v[3]



Chapitre I : Les pointeurs en langage <<C>> 4
Exercice dapplication


En utilisant les pointeurs , crire un programme qui ralise les taches
suivantes :

Remplissage dun vecteur, par n notes, dans le sens inverse.
Comptage des notes < la moyenne des notes.
Chapitre I : Les pointeurs en langage <<C>> 5
Solution de lexercice
#include <stdio.h>
#include <conio.h>
const int max=50;
main()
{
int n,c;
float note[50],moy,*p;

do {
printf("nbre de notes entre 1 et %d :",max);scanf("%d",&n);
}while(n<1 || n>max);

puts("saisie des notes et stockage partir de la fin du vecteur :");

for(p=note+n-1,moy=0;p>=note;p--)
{
do { scanf("%f",p);}while(*p<0 || *p>20); // contrle
moy+=*p;

}

moy/=n;
for(p=note,c=0;p<note+n;p++)

if(*p<moy)c++;

printf("\nLe nbre de notes < %.2f est %d ",moy,c);

getch();
}
Chapitre I : Les pointeurs en langage <<C>> 6
Les pointeurs en langage C
Allocation dynamique :

Sachant que la mmoire est alloue, de faon automatique, au moment de la dclaration
dune variable ( allocation statique).
Exemple : int v[10]; // allocation de 10 cases mmoires de 4 octets chacune.
Lallocation statique prsente 2 inconvnients majeurs :
La mmoire alloue est large gaspillage de la mmoire.
La mmoire alloue est insuffisante imposer lutilisateur un seuil.
On peut viter ces 2 inconvnients, en adoptant une allocation dynamique.
La fonction malloc :
syntaxe : malloc(n); // allocation de n octests (n : entier non sign bien dfini)
cette fonction retourne ladresse du bloc allou en cas de succs, et NULL en cas
dchec.
Rem : le bloc allou na pas de type procder par une conversion explicite.
Syntaxe gnrale de malloc :
nom_pointeur = ( type *) malloc( n*sizeof(type)) ;// rserver n units de ce type
Exemple :
unsigned int n; float *v;
scanf(%d,&n);
v=(float *)malloc(n*sizeof(float));
.



Chapitre I : Les pointeurs en langage <<C>> 7
Les pointeurs en langage C
Limite de malloc : malgr que lallocation est effectue de faon dynamique, lextension
de cet espace mmoire nest pas support par malloc .
fonction realloc : elle complte le travail de malloc , en permettant lextension de
lespace mmoire, tout en prservant les informations dj mmorises.
Syntaxe :
nouveau_pointeur=(type *)realloc(ancien_pointeur , total_octets );
Rem : si le nouveau bloc est allou un autre emplacement, le contenu de lancien bloc est
copi dans le nouveau.
Exemple : float *v , *w;
unsigned int n;
printf(taille du tableau :); scanf(%d,&n);
v= (float *)malloc( n*sizeof(float));// contrler lallocation(chec/succs)
..
w=(float *)realloc(v , (n+1)*sizeof(float));
if ( w!=NULL) { v=w ; n++;}
else puts( chec de rallocation!!);
Fonction free : pour une meilleure gestion de la mmoire, il est conseill de librer
toute allocation dynamique(par malloc ou realloc ) en cas de non besoin.
syntaxe : free(pointeur) ;
exemple : free(v);
Chapitre I : Les pointeurs en langage <<C>> 8