Accès aux membres d'une structure

Remonter à Structures - Index

Les membres des structures et des unions sont accessibles à l'aide des opérateurs suivants :

• . (point)
• -> (flèche droite)

Supposons que l'objet s soit une structure de type S et sptr un pointeur sur S. Si m est un identificateur de membre de type M déclaré dans S, les expressions s.m et sptr->m sont de type M, et représentent toutes deux l'objet membre m de S. L'expression sptr->m est un synonyme pratique pour (*sptr).m.

L'opérateur . est appelé opérateur d'accès direct au membre, l'opérateur -> est dit opérateur d'accès indirect au membre. Par exemple :

 struct mystruct
 {
    int i;
    char str[21];
    double d;
 } s, *sptr = &s;
     .
     .
     .
 s.i = 3;            // affectation au membre i de mystruct s
 sptr -> d = 1.23;   // affecte au membre d de mystruct s

L'expression s.m est une lvalue, à condition que s ne soit pas une lvalue et m ne soit pas de type tableau. L'expression sptr->m est une lvalue à moins que m ne soit un type tableau

Si la structure B contient un champ dont le type est la structure A, les membres de A sont accessibles par deux applications des sélecteurs de membre

 struct A {
    int j;
    double x;
 };
 struct B {
    int i;
    struct A a;
    double d;
 } s, *sptr;
     .
     .
     .
 s.i = 3;            // affectation au membre i de B
 s.a.j = 2;          // affectation au membre j de A
 sptr->d = 1.23;     // affectation au membre d de B
 sptr->a.x = 3.14  // affectation au membre x de A

Chaque déclaration de structure introduit un type unique de structure, de sorte que dans

 struct A {
    int i,j;
    double d;
 } a, a1;
 struct B {
    int i,j;
    double d;
 } b;

les objets a et a1 sont tous les deux de type structure A, mais a et b sont des types structures différents. Les structures ne peuvent faire l'objet d'affectation que si la source et la destination ont le même type :

 a = a1;   // OK: même type, donc affectation membre par membre
 a = b;    // ILLEGAL: types différents
 a.i = b.i; a.j = b.j; a.d = b.d /* mais vous pouvez faire une affectation membre par membre */