les structures en C

Les structures en langage C

Une structure est un type de données défini par l'utilisateur qui permet de regrouper des éléments de types différents sous un même nom. Elle est l'outil fondamental pour modéliser des entités du monde réel (un point, une personne, un produit…) en associant leurs attributs dans un seul type cohérent.

1. Créer une structure

struct NomStructure
{
    type1 membre1;
    type2 membre2;
    /* ... */
};   /* ne pas oublier le point-virgule final */

Exemple n°1 — Structure personne

struct personne
{
    char  nom[20];
    char  adresse[60];
    int   age;
    float salaire;
};

2. Déclarer des variables de type structure

Il existe deux façons de déclarer une variable de type structure.

Exemple n°2 — Deux façons de déclarer une variable structure

/* Méthode 1 — variable déclarée avec la structure */
struct Point
{
    int x, y;
} p1;   /* p1 est déclarée immédiatement */


/* Méthode 2 — variable déclarée séparément */
struct Point
{
    int x, y;
};

int main(void)
{
    struct Point p1;   /* déclarée comme une variable ordinaire */
    return 0;
}

typedef struct
{
    int x, y;
} Point;

int main(void)
{
    Point p1;   /* plus besoin d'écrire "struct Point" */
    return 0;
}

3. Initialiser les membres

Les membres d'une structure ne peuvent pas être initialisés dans la déclaration du type. L'initialisation se fait lors de la création d'une variable, avec des accolades {} dans l'ordre de déclaration des membres.

/* Incorrect — erreur de compilation */
struct Point
{
    int x = 0;   /* erreur : ne peut pas initialiser ici */
    int y = 0;   /* erreur : ne peut pas initialiser ici */
};

Exemple n°3 — Initialisation valide avec {}

#include <stdio.h>

struct Point
{
    int x, y;
};

int main(void)
{
    /* x reçoit 0, y reçoit 1 — ordre de déclaration respecté */
    struct Point p1 = {0, 1};

    printf("x = %d, y = %d\n", p1.x, p1.y);

    return 0;
}

x = 0, y = 1

4. Accéder aux membres

Les membres d'une structure sont accessibles via deux opérateurs selon le contexte :

Exemple n°4 — Accès et modification via opérateur point

#include <stdio.h>

struct Point
{
    int x, y;
};

int main(void)
{
    struct Point p1 = {0, 1};

    p1.x = 10;   /* modification d'un membre */

    printf("x = %d, y = %d\n", p1.x, p1.y);

    return 0;
}

x = 10, y = 1

5. Tableau de structures

Comme pour tout type de données, on peut créer un tableau de structures. Chaque case du tableau est une structure complète dont les membres sont accessibles via la notation tab[i].membre.

struct NomStructure tab[taille];

/* Accès aux membres */
tab[i].membre = valeur;

Exemple n°5 — Tableau de points et affichage

#include <stdio.h>

struct Point
{
    int x, y;
};

int main(void)
{
    struct Point tab[3];
    int i;

    /* Initialisation des 3 points */
    tab[0].x = 2;  tab[0].y = 3;
    tab[1].x = 5;  tab[1].y = 7;
    tab[2].x = 1;  tab[2].y = 4;

    /* Affichage */
    for (i = 0; i < 3; i++)
        printf("Point %d : x = %d, y = %d\n", i, tab[i].x, tab[i].y);

    return 0;
}

Point 0 : x = 2, y = 3
Point 1 : x = 5, y = 7
Point 2 : x = 1, y = 4

6. Pointeur sur structure

On peut déclarer un pointeur sur une structure. Dans ce cas, les membres sont accessibles via l'opérateur -> (flèche), qui combine le déréférencement * et l'accès par point ..

p2->x        /* notation flèche — recommandée */
(*p2).x      /* déréférencement + point — équivalent */

Exemple n°6 — Pointeur sur structure

#include <stdio.h>

struct Point
{
    int x, y;
};

int main(void)
{
    struct Point  p1 = {0, 1};
    struct Point *p2 = &p1;   /* p2 pointe sur p1 */

    /* Accès via flèche */
    printf("via flèche  : x = %d, y = %d\n", p2->x,    p2->y);

    /* Accès via déréférencement + point — identique */
    printf("via (*p2).  : x = %d, y = %d\n", (*p2).x,  (*p2).y);

    /* Modification via le pointeur */
    p2->x = 99;
    printf("après p2->x=99 : p1.x = %d\n", p1.x);

    return 0;
}

via flèche  : x = 0, y = 1
via (*p2).  : x = 0, y = 1
après p2->x=99 : p1.x = 99

Exemple n°7 — Passer une structure à une fonction via pointeur

#include <stdio.h>

struct Point
{
    int x, y;
};

/* Passage par pointeur — modifie la structure originale */
void translater(struct Point *p, int dx, int dy)
{
    p->x += dx;
    p->y += dy;
}

int main(void)
{
    struct Point p = {3, 4};

    printf("avant  : x = %d, y = %d\n", p.x, p.y);
    translater(&p, 10, -2);
    printf("après  : x = %d, y = %d\n", p.x, p.y);

    return 0;
}

avant  : x = 3, y = 4
après  : x = 13, y = 2

7. Limitations des structures en C

Les structures C sont utiles mais présentent plusieurs limitations par rapport aux classes du C++ ou d'autres langages orientés objet.

Exemple n°8 — Limitation : opérateurs non applicables

struct number
{
    float x;
};

int main(void)
{
    struct number n1, n2, n3;
    n1.x = 4;
    n2.x = 3;

    n3 = n1 + n2;   /* erreur de compilation */

    return 0;
}

error: invalid operands to binary + (have 'struct number' and 'struct number')

/* Contournement correct */
n3.x = n1.x + n2.x;

Récapitulatif