TP1: Les Pointeurs 2019/2020

Les Pointeurs

Objectifs Durée Outil

- Se familiariser avec le concept de pointeur
- Manipuler les opérateurs d’adressage et de
6h00
déréférencement (& et *) CodeBlocks
(2 séances de TP)
- Utiliser les pointeurs avec les tableaux et les chaînes de
caractères, les fonctions et les structures

Pointeurs et variables
Excercice1:

1. Saisir le programme suivant :

#include <stdio.h>

int main()

int i=100;

printf ("La variable i a comme adresse %d et contient la valeursuivante %d\n",&i,i);

int *pi=NULL;

pi=&i;

printf("le pointeur pi contient la valeur %d et pointe vers lavaleur %d\n",pi,*pi);

*pi=200;

printf("le pointeur pi contient la valeur %d et pointe vers lavaleur %d\n",pi,*pi);

printf ("La variable i a comme adresse %d et contient la valeursuivante %d\n",&i,i);

2. Exécuter le programme et interpréter le rôle d’un pointeur

3. On veut changer le programme pour n’utiliser que la variable pi, compléter le programme
suivant :

#include<stdio.h>

1 ProgrammationII
TP1: Les Pointeurs 2019/2020

main ()

int *pi=NULL;

*pi=200;

printf ("pi pointe vers la case contenant %d\n",…………..);

Excercice2:
Soit le morceau de programme suivant :

int a; int *pa; double x; int **p;

a=8;

pa=&a;

x=3.14159;

p=&pa;

**p=281;

déterminer le contenu des différentes variables à la fin de l'exécution du programme.

Excercice3:
Ecrire un programme effectuant les opérations suivantes :
 Déclare un entier i et un pointeur p vers un entier.
 Initialise i à la valeur 14.
 Fait pointer p vers i.
 Affiche la valeur de i en utilisant p.
 Affecte 12 à i en passant par p ;
 Affiche l’adresse de p.
 Affiche l’adresse de i en passant par p.

2 ProgrammationII
TP1: Les Pointeurs 2019/2020

Pointeurs et fonctions

Exercice 4:
1) Ecrire et appeler une fonction somme_diff() qui calcule la somme et la différence de
deux entiers passés en paramètres.

2) Ecrire la fonction min_max() permettant de déterminer le maximum et le minimum

entre trois entiers passés en paramètre.
3) Ecrire la fonction permuter() permettant d'échanger le contenu de deux réels passés en
paramètre.

Pointeurs et tableaux
Excercice4:

1. Saisir et exécuter le programme suivant :

#include<stdio.h>

intmain() {

/* declaration d’un tableau d’entiers à 3 elements*/

inta[3]={0,2,5} ;

intdist ;

/* declaration d’un pointeur entier */

int *ptr_int;

/*initialisation de ptr_int avec l’adresse dupremier élément de tableau */

ptr_int=&a[0];

printf("la valeur de a[0] = %d\n", a[0]) ;

printf("l'adresse de a[0] = %u (%x)\n", &a[0],&a[0]);

printf("la valeur de ptr_int= %u (%x)\n", ptr_int,ptr_int) ;

printf("la valeur pointe par ptr_int =%d\n",*ptr_int);

*ptr_int=*ptr_int+2; //incrementation du contenupointe par ptr_int

3 ProgrammationII
TP1: Les Pointeurs 2019/2020

printf("\n apresincrementation de *ptr\n\n");

printf("la valeur de a[0] = %d\n", *ptr_int) ;

ptr_int++; //incrémentation de l’adresse mémoirecontenu dans ptr_int

printf("l'adresse de a[1] = %d (%x) \n",&a[1],&a[1]) ;

printf("la valeur de ptr_intapresincrementation

(ptr_int++) %u (%x)\n",ptr_int, ptr_int);

dist=ptr_int-&a[0]; /* vaut le nombre d’entiersreprésentables entre l’adresse ptr_int et l’adresse du

premierélément de a*/

printf("le nombre d'entiers représentables entreptr_int (%x) et a[0] (%x) = %d\n", ptr_int,&a[0],dist);

dist=(char*)ptr_int-(char*)&a[0]; /* vaut le nombrede chars représentables entre l’adresse ptr_int et

l’adresse dupremier élément de a */

printf("le nombre de caractèresreprésentables entreptr_int (%x) et a[0] (%x) = %d\n",

ptr_int,&a[0],dist);

2. Soit les instructions suivantes :

intA[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};

int *P;

P = A;

Donner les résultats de ces expressions, comparer et interpréter :

Expression 1 Expression 2 Interprétation

*P= A[0]=
*P+2= *(P+2)=
A= A+3 =
&A[7]-P = A+7-P=

Exercice5 :
En utilisant uniquement le formalisme pointeur
1) Ecrire la fonction remplir_tab() permettant de remplir un tableau d’entiers.
2) Ecrire la fonction Affich_tab() permettant d’afficher un tableau d’entiers.
3) Ecrire la fonction Som_tab()permettant de calculer la somme d’un tableau d’entiers.
4) Ecrire la fonction copie_tab()permettant de copier un tableau d’entiers A passé en
paramètre à la fin d'un autre tableau d’entiers également passé en paramètre.

4 ProgrammationII
TP1: Les Pointeurs 2019/2020

5) Ecrire la fonction Supp_occ() permettant d'éliminer toutes les occurrences d'un entier X
passé en paramètre d'un tableau A(également passé en paramètre) en tassant les
éléments restants.
6) Ecrire un programme principal permettant de créer dynamiquement un tableau
d'entiers de taille N puis de tester ces fonctions

Pointeurs et chaînes de caractères

En utilisant uniquement le formalisme pointeur

1) Ecrire la fonction Long_ch()qui retourne la longueur d’une chaine de caractères.

2) Ecrire une fonction char * recherche_char(char* s, char c) qui renvoie un pointeur
vers la première occurrence d'un caractère c, passé en argument, dans la chaine s. Si ce
caractère n’apparait pas dans la chaine, la fonction devra renvoyer NULL.
3) À l’aide de recherche_char, écrire une fonction int compte_char(char *s, char c)qui
compte le nombre d’occurrences de c dans s.
4) Ecrire et tester une fonction void miroir( char* src, char* dest )qui copie le miroir
(mot à l'envers) d'une chaîne de caractères src dans une autre chaîne de caractères dest.
Le programme utilisera les pointeurs p1 et p2 pour parcourir les deux chaînes.
5) Réécrire la fonction miroir précédente de manière à ce que la fonction crée et renvoie
une chaîne contenant le miroir de la chaîne passé en paramètre.
Prototype : char * miroir(char* src) ;
6) Ecrire et tester une procédure void majuscules( char* src, char* dest ) qui convertit
les lettres minuscules de la chaîne de caractères pointée par src dans la chaîne de
caractères pointée par dest.
7) Ecrire et tester une fonction int estPrefixe( char* pre, char *s ) qui vérifie si la chaîne
de caractère pointée par pre est le préfixe de la chaîne de caractères pointée par s. Par
exemple poly est préfixe de polycopié et la fonction renvoie la valeur 1. Sinon, la fonction
renvoie la valeur 0 en cas d'échec. Le programme utilisera les pointeurs p1 et p2 pour
parcourir les deux chaînes.

5 ProgrammationII
TP1: Les Pointeurs 2019/2020

Pointeurs et structures

Nombres complexes

8) Écrire une structure complexe qui représente un nombre complexe. Cette structure
contient deux flottants re et im représentant respectivement la partie réelle et la partie
imaginaire du nombre.
9) Écrire une fonction qui prend en paramètre deux flottants, et qui retourne un pointeur
vers un nouveau complexe.
Prototype : complexe * new_complexe(float r, float i) ;
10) Écrire une fonction qui prend en paramètre un pointeur vers un complexe, et qui affiche
ce complexe dans la console.
Prototype : void print_complexe(complexe *p) ;
11) Écrire une fonction qui prend en paramètre deux pointeurs vers des complexes, et qui
retourne un pointeur vers un nouveau complexe, somme des deux reçus en paramètre.
Prototype : complexe * addition_complexes(complexe *c1, complexe*c2) ;
12) Écrire une fonction qui prend en paramètre deux pointeurs vers des complexes, et qui
retourne un pointeur vers un nouveau complexe, produit des deux reçus en paramètre.
Prototype : complexe * produit_complexes(complexe *c1, complexe *c2) ;

6 ProgrammationII