Cours : Structures

Qu'est-ce qu'une structure ?

Les structures sont une forme de type de variable que vous définissez vous-même et qui vous permet de créer des variables qui regroupent plusieurs informations.

Exemple de cas d'utilisation

Imaginons que vous avez un repère avec un système de coordonnées x, y :

	0	1	2	3	4	5
0
1			X
2
3
4

Vous avez 5 lignes et 6 colonnes. En temps normal pour indiquer la position du X vous devriez déclarer deux int :

int pos_y = 1;
int pos_x = 2;

(Pour rappel : y sont les lignes, x les colonnes et une position s'indique toujours en y;x)

Ces deux valeurs, pos_y et pos_x vont ensemble vous allez quasi toujours les utiliser ensemble. Une structure vous permettrait de les stocker en une seule variable.

Déclarer une structure

La déclaration d'une structure se fait dans un fichier .h.

struct.h

#ifndef TESTS_STRUCT_H  
#define TESTS_STRUCT_H  
  
struct s_pos {  
    int pos_y;  
    int pos_x;  
};  
  
typedef struct s_pos position;  
  
#endif //TESTS_STRUCT_H

Il se passe deux chose différentes dans l'exemple ci-dessus :

struct s_pos {  
    int pos_y;  
    int pos_x;  
}; 

Nous déclarons que nous allons définir un nouveau type de structure en utilisant le mot clé struct. Ensuite nous précisons le nom de notre nouveau type : s_pos.

Nous indiquons que notre structure s_pos va contenir deux variables de type int, une appelée pos_y et l'autre pos_x.

Enfin pour nous faciliter la vie plus tard et ne pas avoir à écrire plein de fois struct s_pos dans notre code, nous utilisons un typedef (type definition) pour indiquer à notre programme que position est un synonyme de struct s_pos.

Utiliser une structure

#include <stdlib.h>  
#include <stdio.h>  
#include "struct.h"  
  
  
int main()  
{  
    position pos;  
    pos.pos_y = 1;  
    pos.pos_x = 2;  
  
    printf("La position de la case est Y : %d; X : %d\n", pos.pos_y, pos.pos_x);  
  
    exit(0);  
}

position pos;

J'utilise le synonyme que j'ai déclaré dans mon fichier .h pour créer une nouvelle variable de type position que je vais appeler pos. J'aurais également pu l'appeler coord par exemple, je lui donne le nom que je souhaite.

pos.pos_y = 1;  
pos.pos_x = 2; 

Ensuite je vais remplir les "sous-variables" contenues dans ma structure.

Pour accéder à une sous variable je dois écrire : nom_de_la_struct.nom_de_la_sous_variable

Les structures et les pointeurs

Comme tous les types de variables, il est possible d'utiliser un pointeur qui contient l'adresse d'une structure, mais vous allez voir, il y a un petit changement.

#include <stdlib.h>  
#include <stdio.h>  
#include "struct.h"  
  
void fill_pos(position * pos)  
{  
    pos->pos_y = 1;  
    pos->pos_x = 2;  
}  
  
int main()  
{  
    position pos;  
    fill_pos(&pos);  
  
    printf("La position de la case est Y : %d; X : %d\n", pos.pos_y, pos.pos_x);  
  
    exit(0);  
}

En effet lorsque je manipule un pointeur sur une structure et que je veux manipuler les sous-variables de la structure je dois utiliser structure->variable à la place de structure.variable.

Allouer la mémoire pour une structure

Si votre structure ne contient pas de pointeurs, c'est assez simple :

#include <stdlib.h>  
#include <stdio.h>  
#include "struct.h"  
  
int main()  
{  
    position *pos = malloc(sizeof(*pos));  
  
    pos->pos_y = 1;  
    pos->pos_x = 2;  
  
    printf("L'adresse de la structure est %p. La position de la case est Y : %d; X : %d\n",pos, pos->pos_y, pos->pos_x);  

    free(pos);
    exit(0);  
}

Par contre si votre structure contient des pointeurs (un char * par exemple), vous allez devoir allouer la mémoire pour la structure puis la mémoire pour chacun des pointeurs qu'elle contient.

Changeons notre exemple

struct.h

#ifndef TESTS_STRUCT_H  
#define TESTS_STRUCT_H  
  
struct s_character {  
    char *name;  
    int health;  
    int mana;  
};  
  
typedef struct s_character character;  
  
#endif //TESTS_STRUCT_H

main.c

#include <stdlib.h>  
#include <stdio.h>  
#include <string.h>  
#include "struct.h"  
  
int main()  
{  
    character *perso = malloc(sizeof(*perso));  
    perso->name = malloc(strlen("Gandalf") * sizeof(char));  
    perso->name = strcpy(perso->name, "Gandalf");  
  
    perso->health = 100;  
    perso->mana = 250;  
  
    printf("The character name is %s. The character has %d health points and %d mana points\n", perso->name, perso->health, perso->mana);  
    
    free(perso->name);
    free(perso);
    
    exit(0);  
}

J'alloue la mémoire pour ma structure :

character *perso = malloc(sizeof(*perso));

Puis j'alloue la mémoire pour la sous variable qui est un pointeur :

perso->name = malloc(strlen("Gandalf") * sizeof(char));

20 October 2025