Université Louis Pasteur
LICENCE 1ère année
Mercredi 2 mai 2007
 
Travaux Dirigés
Algorithmique et Programmation
(sujet n°5)

Pointeurs




Notions et points abordés :


Déclaration d'un pointeur

Syntaxe

Exemple

// Déclaration

type *nom;

// Déclaration d'un pointeur sur une valeur entière

int *p;

Affectation d'un pointeur (de l'adresse d'une variable)

Syntaxe

Exemple


nom = &variable;



nom = NULL;

// Affectation à p de l'adresse d'une variable entière i
// préalablement déclarée de type int

int i;

p = &i; // &i est l'adresse de la valeur de i

// Affectation à p de la valeur NULL (ce qui signifie que le pointeur ne pointe actuellement sur aucune valeur)

p = NULL;

Accès à la valeur pointée

Syntaxe

Exemple

*nom = value;

// La valeur pointée par p est 2

*p = 2;
variable = *nom;

int j;

j = *p;


printf( "%d", *nom );

// Affichage de la valeur pointée par p

printf( "%d", *p );


scanf( "%d", nom );
 // Lecture de la valeur pointée par p

scanf( "%d", p );


Pour utiliser correctement un pointeur, il est recommandé
1) de l'affecter à NULL au moment sa déclaration pour indiquer qu'initialement il ne pointe sur rien. 
2) de tester s'il n'est pas égal à NULL avant chaque accès à la valeur pointéee.

int i;
int *p = NULL;


...

if(p != NULL)
  i = *p;
else
  printf("Attention : pointeur NULL !\n");


...
Pointeur en argument d'une fonction (On passe à la fonction l'adresse d'une variable)

#include <stdio.h>

void incr ( int *x ) // incrémente un variable entière
{
*x = *x+1;
}

int main()
{
int a;

a=1;
printf( "a = %d\n",a);
incr(&a);
printf( "a = %d\n",a);

return 0;
}
Pointeur et tableau (Une variable de type tableau est un pointeur sur le premier élément du tableau)

#include <stdio.h>

int main()
{
int t[5] = {2, 3, 5, 7, 11};;
int *p = NULL;

p = t ; // p pointe sur la même chose que t
printf( "t[0] = %d *p = %d\n",t[0],*p);
printf( "t[1] = %d *(p+1) = %d\n",t[1],*(p+1));
printf( "t[2] = %d *(p+2) = %d\n",t[2],*(p+2));
printf( "t[3] = %d *(p+3) = %d\n",t[3],*(p+3));
printf( "t[4] = %d *(p+4) = %d\n",t[4],*(p+4));

return 0;
}
Remarque : en C, int t[] a la même signification que int *t.

Tableau dynamique (L'allocation d'une zone mémoire se fait dynamiquement au moyen d'un appel explicite à la fonction malloc. On utilise la fonction free pour libérer une zone mémoire précédemment allouée)

#include <stdio.h>
#include <malloc.h>

int main()
{
int *t = NULL;

t = malloc(5*sizeof(int)) ; // t pointe sur un zone mémoire de taille égale à 5 entiers (5*sizeof(int))

// t[i] a la même signification que *(t+i)

t[0] = 2;
t[1] = 3;
t[2] = 5;
t[3] = 7;
t[4] = 11;

printf( "t[0] = %d *t = %d\n",t[0],*t);
printf( "t[1] = %d *(t+1) = %d\n",t[1],*(t+1));
printf( "t[2] = %d *(t+2) = %d\n",t[2],*(t+2));
printf( "t[3] = %d *(t+3) = %d\n",t[3],*(t+3));
printf( "t[4] = %d *(t+4) = %d\n",t[4],*(t+4));

free(t);

return 0;
}


Exercices


Echange de 2 variables

    Écrire une fonction qui échange les valeurs de 2 variables entières :

        void swap( int *x, int *y )


Division euclidienne

    Écrire une fonction qui calcule le reste et le quotien de la division entière de 2 nombres entiers :  une fonction ne pouvant renvoyer qu'un seul résultat, cette fonction va recevoir 2 pointeurs qu'elle va utiliser pour remplir les zones mémoire pointées avec les résultats voulus. 

        void division( int a, int b, int *reste, int *quotient )


Minimum et maximum

    Écrire une fonction qui calcule le minimum et le maximum de 2 entiers.


Premiers carrés

   
    Écrire une fonction qui crée un tableau de n entiers, le remplit avec les n premiers carrés et renvoie un pointeur vers cette nouvelle zone mémoire :

       int *cree_tab_carre(int n) 


Copie
   
    Écrire une fonction qui effectue une copie d'une zone mémoire (un tableau de n entiers) vers une autre et renvoie un pointeur vers cette nouvelle zone mémoire :


       int *cree_copie(int *t, int n)


Concaténation

    Écrire une fonction qui crée et renvoie un tableau contenant les entiers de deux zones mémoire (des tableaux d'entiers) passées en paramètre.


        int *concatenation(int *t1, int n1, int *t2, int n2)