Les pointeurs

1. Qu’est-ce qu’un pointeur ?

1. Allouer un tableau en même temps qu’une structure

L’allocation dynamique d’une structure permet en même temps d’allouer dynamiquement un tableau placé comme dernier champ de cette structure et défini par l’opérateur crochet vide [ ]. Par exemple :

typedef struct {  
    int temps;  
    float stock[];  
}Mesure; 

Structure et tableau peuvent être alloués dynamiquement en une seule fois de la façon suivante :

Mesure* mesure = malloc(sizeof(Mesure) + sizeof(float[10])); 

La structure allouée contient ici un tableau de 10 float. Autre exemple :

Mesure* mesure = malloc(sizeof(Mesure) + 16); 

La structure allouée contient alors un tableau de 4 float (sizeof(float)*4 font 16 octets).

Mise en œuvre de l’exemple :

#include <stdio.h> 
#include <stdlib.h>  
   
#define NBMAX   10   
typedef struct {  
    int temps;  
    float stock[];  
}Mesure;  
   
void pause(void);  
   
int main()  
{  
    Mesure *mesure= malloc(sizeof(Mesure)+ sizeof(float[NBMAX]));  
      
    mesure->temps = 1;  
    for (int i = 0; i < NBMAX; i++)  
        mesure->stock[i] = (float)rand() / RAND_MAX * 10;  
    for (int i = 0; i < NBMAX; i++)  
        printf("stock[%d]=%.2f\n", i, mesure->stock[i]);  
   
    pause();  
    return 0;  
}...

1. Passage par référence

Les paramètres de fonctions sont des variables locales à la fonction initialisées avec des valeurs au moment de l’appel de la fonction. Lors d’un passage de tableau, le paramètre est un pointeur qui prend comme valeur l’adresse du premier élément qui est aussi l’adresse de tout le bloc mémoire du tableau. Cette section a pour objet l’étude du passage d’adresse mémoire pour n’importe quel type de variable et pas seulement les tableaux. C’est ce que l’on appelle un "passage par référence" et il s’agit de la référence à une variable via son adresse mémoire. Nous préciserons également quelques finesses quant au passage des tableaux.

void modif(int e1) 
{ 
     e1=50; 
} 

#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
int v=10; 
    modif(v); 
    printf("v=%d \n", v); 
    return 0; 
} 

1. Association de structures de types différents

Par exemple, dans un programme nous devons avoir d’un côté des pilotes et de l’autre des avions. Chaque pilote peut piloter un avion et chaque avion possède ou non un pilote.

Pour programmer cette situation nous définissons deux structures : une structure pour pilote et une structure pour avion. Dans la structure pilote, nous plaçons un pointeur sur une structure avion et dans la structure avion nous plaçons un pointeur sur une structure pilote. Ainsi, chaque pilote peut être associé à un avion et réciproquement chaque avion peut être relié à un pilote.

Voici une structure pilote :

#define MAXCHAR    256 
typedefstruct avion 
{ 
    struct pilote*pilote; // peut pointer sur un pilote 
    char type[MAXCHAR]; 
    intnum; 
}avion; 

Une structure avion :

typedefstruct pilote 
{ 
    struct avion*avion; // peut pointer sur un avion 
    char nom[MAXCHAR]; 
 
}pilote; 

Un constructeur pour créer dynamiquement un pilote :

pilote* ConstructPilote(char*nom, avion*a)  
{  
    pilote* p;  
    p = (pilote*)malloc(sizeof(pilote));  
    strcpy_s(p->nom, MAXCHAR, nom);  
    p->avion = a;  
    if (a != NULL)  
           a->pilote = p;  
    return...