Algorithme et Structures de

Données
Wurtz Jean-Marie

Université Louis Pasteur

Wurtz@igbmc.u-strasbg.fr

Mémoire d’un ordinateur

Les pointeurs en C
Adresse
•Opérateurs * et &, priorité

•Déclaration : type et fonction (define, struct, union)

27
•Tableaux et pointeurs, initialisation

•Passage par adresse : scanf

•Retour des fonctions : struct, union, fonction

i=27
•Allocation dynamique pi = adresse(i); /* adresse de la cellule mémoire qui
contient la valeur 27 */

Les pointeurs en C : Les pointeurs en C :

les opérateurs * et & déclaration de types
• int i, j, *ip; i j ip Priorité : * < [] < ()
• i=11;
11 21 Ad(i) • int i → Un entier
• ip= &i;
• int *pi → Pointeur vers un entier
• j=21; → Pointeur de pointeur d’entier
• int **ppi
• int it[] → Tableau d’entier
i j ip
• int *pit[] → Tableau de pointeurs d’entier
• *ip=j; 21 21 Ad(i) • int *if() → Fonction retournant un pointeur d’entier
• int (*ipf)() → Pointeur de fonction retournant un entier

1
 Les pointeurs en C : Les pointeurs en C :
passage par adresse (1) passage par adresse (2)
void echange(int a, int b) void echange(int *a, int* b)
{ {
• passage par valeur , int f1(int a, int b) : la int tmp; int tmp;
fonction f1 crée une copie des variables « a » et tmp = a; tmp = *a;
«b» a = b; *a = *b;
b = tmp; *b = tmp;
} }
• passage par adresse, int f2(int *a, int *b) : la a =11; a =11;
fonction f2 peut modifier le contenu des b = 27; b = 27;

variables « a » et « b »de la fonction appelante echange(a,b); echange(&a,&b);

a et b inchangées a et b échangées

Les pointeurs en C : Les pointeurs en C :

passage par adresse (3) les tableaux
i i+1

• int ti[];
•int f3(int a[], int b), « a » passage par adresse : les
modifications du tableau « a » seront répercutées au • double td[];
niveau de la fonction appelante. • char tc[];
• struct nœud tn [];
•Une variable définit comme un tableau est transmise struct nœud {
comme un pointeur : a[n] == *(a+n)
int i;
enum/sizeof
struct nœud *s;
} t[i] = *(t+i)
TD/sizeof.c

Les pointeurs en C Les pointeurs en C :

ne sont pas des entiers struct et union
• Si p est un pointeur : int *p, i; • struct nœud { union uni {
p++ : pointe sur l’élément suivant, int val; int i;
p+ = i : pointe sur le ième élément suivant, struct nœud *s; double d;
incrémente d’après la taille de l’élément
} n, *pn; } u, *pu;
• Différence entre pointeurs, mais pas d’addition Les seules opérations possibles :
-prendre l’adresse avec & : pn = &n
• Si t est un tableau : int t[100], *p; -accéder une valeur :
p = &t[0] est correcte, de même p = t n.val = 11 ou
mais pas t = p ou t++ ou p = &t pn->val = 11 ou
*pn.val = 11

2
 Les pointeurs en C : Les pointeurs en C :
retour de fonction les fonctions
• Une fonction peut retourner : • int uneFonction(), (*pf)() :
– des types simples : char, short, int, unsigned, long, -adresse de la fonction:
double
– ou un pointeur vers un tel type
pf = uneFonction
-exécuter la fonction : (*pf)()
• Une fonction ne peut retourner que des pointeurs de
fonction, struct ou union • Un pointeur de fonction :
-n’est pas une variable
• Pas de valeur retournée :
– void uneFonction()
-peut-être assigné à un tableau

Les pointeurs en C : Exemple

les fonctions (2)
struct donnée {
int main()
hello(1); int type;
{
/* un pointeur de fonction object *pObjet;
pf = hello2;
retournant un entier */ }
int (*pf)();
(*pf)();
/* un tableau de pointeurs de
tpf[0] = hello3; switch obj.type {
fonction retournant un entier */
int (*tpf1[10])(); RECT (*affiche[obj.type])(pObjet);
(*tpf[0])();
int (*tpf1)())[]; Faux CERCLE
tpf1[0] = hello4;
/* un tableau de pointeurs de POLY
fonction retournant un entier */
(*tpf1[0])(); }
typedef int (*pF)();
}
pF tpf[10];
TD/ptrfontion.c.html

Les pointeurs en C : Les pointeurs en C :

conversion de pointeurs (2) allocation dynamique
•Définition de type : • void* calloc(n,sizeof(Type)) : alloue un
–typedef ENTIER int; typedef ptrENTIER *int; espace de taille sizeof(Type) et cela « n »
fois
•Fonction scanf (contrôle, arg1, arg2, ..) :
lecture standard (stdin); sscanf, fscanf • void * malloc(n) : alloue un espace de n
–char *str="25 années 15.3" ; int i; double f; octets
–sscanf(str, "%d %*s %f" , &i,&f)

3
 Les pointeurs en C : Les pointeurs en C :
allocation dynamique (2) conversion de pointeurs

•void *realloc(p, n) : libère l’espace • Les fonctions d’allocation d’espace retourne un

alloué à p, et réalloue n octets pointeur de void qui pointe sur l’espace alloué

• Conversion de type :
• void free(p) : libère l’espace alloué – pType = (Type *)malloc(n*sizeof(Type))

Exercice 1: malloc et free Exercice 2 : tableau, avec allocation

dynamique de la taille
TD/TD1-tableau1.c
#include <stdio.h> int strlen()
#include <stdlib.h> void * malloc(n) #define BLOC 2 #include <stdio.h>
void free(p) Variables globales :
#include <string.h> #include <stdlib.h>
int compteur=0, taille=0;
Saisir la taille de la zone : taille int *tableau;
Si > 0 alors Fonctions :
int inserer(int i)
Saisir la chaine int inserer(int i)
-taille du tableau suffisant ? :
Vérifier la taille : taille < longueur ! erreur realloc
Afficher la chaine -insérerl'entier comme avant
Libérer l'espace

http://www-bio3d-igbmc.u-strasbg.fr/~wurtz pointeur/allocation.c http://www-bio3d-igbmc.u-strasbg.fr/~wurtz pointeur/tableau1_malloc.c

Exercice 3 : tableau de chaîne de caractères Exercice 3 : tableau de chaîne de caractères (2)

TD/TD1-tableau1.c
int main() {
#define BLOC 2 char t[20];
#include <stdio.h>
Variables globales : strcpy(t, "Marie"); inserer(t);
#include <stdlib.h>
int taille=0, compteur=0; strcpy(t, "Robert"); inserer(t);
#include <string.h> strcpy(t, "Anne"); inserer(t);
char *tableau[];
inserer("Albert");
Fonctions :
int inserer(char *s) inserer("Yann");
int inserer(char *s) inserer("Rose");
-taille du tableau suffisant ? :
void afficher() inserer("Myriam");
malloc, realloc affiche();
int supprimer(char *s)
-insérer la chaîne s : }
free()
malloc

http://www-bio3d-igbmc.u-strasbg.fr/~wurtz pointeur/tableau1-char-malloc.c

4
 Créer une structure de données
décrivant un point
• un point a 2 composantes :
x et y
• Description en C?
• struct Point {
double x, y;
} } TPoint;
• Définition d'une variable Point
struct Point pnt = {1.5,3.0};
struct Point p1, *p2;
// accès aux champs x et y de pnt
p1 = pnt; // tester cette assignation
p2 = &pnt; // comment accéder les
//champs x et y de p2
Utilisation de typedef
typedef struct Point {
double x, y;
TPoint pnt = {1.5,3.0};
TPoint p1, *p2;
Décrire des formes géométriques
• Un cercle : son centre et le rayon
• un carré : son centre et le coté
• un rectangle : son centre et la hauteur et la largeur
• un polygone : un nombre quelconque de points ( > 3) avec
comme centre le centre de masse des points
• Décrire les structures de données et les fonctions
d'initialisation :
struct Cercle { //une variable cercle
struct Point c; // le centre //et un pointeur de cercle
double r; // le rayon Struct Cercle ce, *pce;
}
struct Cercle * créerCercle(struct Point *c, double r)

Décrire un type Cercle

Décrire un polygone
• Un cercle : son centre et le rayon
struct Cercle { //une variable cercle • #define POLYGONE 3
struct Point c; // le centre //et un pointeur de cercle
double r; // le rayon Struct Cercle ce, *pce; • typedef struct Polygone {
}
struct Cercle * créerCercle(struct Point *c, double r)
TPoint centre; //le centre de masse
int taille; // nbre de points
TPoint *poly; //la liste des points
#define CERCLE 0 } TPolygone;
typedef struct Cercle {
TPoint centre; // le centre //une variable cercle
double rayon; // le rayon //et un pointeur de cercle • TPolygone * creerPolygone(TPoint tp[], int taille)
} TCercle; TCercle ce, *pce;
• void affPolygone(TPolygone *po)
TCercle * créerCercle(TPoint *c, double r)

Gérer une liste de forme Gérer une liste de forme

géométrique géométrique(2)
• Stocker ces formes dans un tableau : • puis définir un type forme quelconque qui aura
struct Forme tabForm[]; comme membres :
• struct Forme {????} – un type : le type de l'objet
• Remplir le tableau forme un cercle, carré, un – un pointeur vers une des forme géométrique
rectangle et un polygone
• Puis lister pour chaque élément du tableau son
type, un nom, et ses attributs
– écrire une fonction afficheCercle(struct Cercle * pc)