Langage C - C++
Structures
Accueil

du site


Structures - définition - déclaration -

Une structure est un ensemble de données de types divers (contrairement aux tableaux qui rassemblent des données de même type).

Voici la définition d'une structure, visiblement destinée à constituer un agenda d'adresses.

//fiches.h

#define MAXNOM 64
#define MAXDATE 18
#define MAXADRESSE 128
#define MAXOBSERV 128
#define MAXTEL 20
#define MAXCOURRIEL 64

struct ficheID
{
-char Nom[MAXNOM];
-char Prenom[MAXNOM];
-char Sexe;
-char DateNaissance[MAXDATE];
-char Adresse[MAXADRESSE];
-char TelDom[MAXTEL];
-char Ville[MAXNOM];
-int CodePostal;
-char TelMob[MAXTEL];
-char TelBur[MAXTEL];
-char Courriel[MAXCOURRIEL];
-char Observations[MAXOBSERV];
-long Index;
};

ficheID est l'identificateur de la structure
Nom, Prenom, Sexe, etc en sont des membres.

Les divers membres ont bien ici des types différents (ce qui n'est nullement obligatoire) :
Nom, Prenom, DateNaissance, Adresse, TelDom, Ville,TelMob, TelBur, Courriel, Observations sont du type tableau de caractères. Sexe est de type caractère, CodePostel est un entier, Index est un long.

Noter que nous avons parlé de "définition" et non de "déclaration" car une déclaration s'accompagne de réservation d'espace mémoire pour la variable ou la constante déclarée.

Ici, aucune réservation n'est faite : ficheID est l'identificateur de la structure mais aucun espace mémoire n'est réservé pour lui, pas plus que pour les divers membres.

Pour réserver de l'espace mémoire pour une ou plusieurs structures, on peut le faire dès sa définition :

Exemple : nous définissons ici à la fois l'identificateur "complexe" et réservons de la mémoire pour trois variables de ce type de structure : c1, c2 et c3.

//. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
struct complexe { double a; double b;} c1,c2,c3;
//. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Toutefois, il est préférable de séparer la définition de la structure dela déclaration avec réservation mémoire des variables :

//. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
struct complexe { double a; double b;}; //Déclaration de la structure
//. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
struct complexe c1,c2,c3; //Déclaration des variables de type "complexe"
//. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

C'est pourquoi l'on écrit souvent les définitions de structures dans des fichiers d'entête ".h" séparés (comme dans notre premier exemple "fiches.h" ci-dessus).

On peut ainsi insérer ces fichiers par un "#include" dans tous les fichiers source où l'on déclare des variables du type correspondant.

 

Exploitation des structures

Maintenant que l'on sait ce qu'est une structure on va apprendre à s'en servir.

#include < stdio.h >
#include < math.h >

//Définition d'un nombre complexe de partie réelle "pR" et imaginaire "pI"
struct complexe
{
-double pR;
-double pI;
};

int main()
{
-//Déclarations :
-struct complexe N,M;
-double module,Reelle,Imaginaire;

-//Affectations : IdentificateurStructure.Membre
-N.pR = -1.20;
-N.pI =- 2.30;
-M.pR = -0.50;
-M.pI = -1.30;

-//Exploitation :

-// Le module est la racine carrée de la somme des carrés
-// des parties réelle et imaginaire :
-module = sqrt( (N.pR * N.pR) + (N.pI * N.pI) );
-printf("Module du nombre complexe (1.2 + 2.3i) = %f\n" , module );

-//Calculons la somme des nombres complexes : N + M
-Reelle = N.pR + M.pR ;
-Imaginaire = N.pI + M.pI ;
-printf("Somme (1.2+2.3i) + (0.5-1.3i) = %f + %f i\n",Reelle, Imaginaire);

-//Calculons le produit des nombres complexes : N + M
-Reelle = N.pR * M.pR - N.pI * M.pI;
-Imaginaire = N.pR * M.pI + N.pI * M.pR ;
-printf("Produit (1.2+2.3i)*(0.5-1.3i) = %f + %f i\n",Reelle, Imaginaire);

-return 0;
}

Affichage à l'exécution :

Module du nombre complexe (1.2 + 2.3i) = 2.594224
Somme (1.2+2.3i) + (0.5-1.3i) = 1.700000 + 1.000000 i
Produit (1.2+2.3i)*(0.5-1.3i) = 3.590000 - 0.410000 i
Press any key to continue

 

Passage d'un pointeur de structure en paramètre dans une procédure

On ne passe jamais une structure en paramètre à une fonction, mais toujours un pointeur sur la structure. Exemple :.

#include < stdio.h >
#include < math.h >

-//Définition d'un nombre complexe de partie réelle "pR" et imaginaire "pI"
-struct complexe
-{ double pR; double pI; };

-double Module(struct complexe * pC)
-{
--return sqrt( (pC->pR * pC->pR) + (pC->pI * pC->pI) );
-}

//Les deux termes de la somme sont des structures
//passées par leurs pointeurs pA et pB

//Le code appelant devra avoir prévu une structure S
//passée par pointeur pS pour recevoir la valeur de la somme
-void Somme (struct complexe * pA, struct complexe * pB,
-struct complexe * pS)
-{
--pS->pR = pA->pR + pB->pR;
--pS->pI = pA->pI + pB->pI;
-}

//Les deux facteurs sont des structures
//passées par leurs pointeurs pA et pB

//Le code appelant devra avoir prévu une structure P
//passée par pointeur pQ pour recevoir la valeur du produit.pS
-void Produit (struct complexe * pA, struct complexe * pB,
-struct complexe * pP)
-{
--pS->pR = (pA->pR * pB->pR) - (pA->pI * pB->pI) ;
--pS->pI = (pA->pR + pB->pI) + (pA->pI + pB->pR);
-}

int main()
{
-struct complexe N,M,R;
-//Affectations : IdentificateurStructure.Membre
-N.pR = -1.20;
-N.pI =- 2.30;
-M.pR = -0.50;
-M.pI = -1.30;

-//Exploitation :
-printf("Module : %f\n",Module(&N));

-//Calculons la somme des nombres complexes : N + M
-Somme(&N,&M,&R);
-printf("Somme (1.2+2.3i) + (0.5-1.3i) = %f + %f i\n",R.pR, R.pI);

-//Calculons le produit des nombres complexes : N + M
-Produit(&N,&M,&R);
-printf("Produit (1.2+2.3i)*(0.5-1.3i) = %f + %f i\n",R.pR, R.pI);

-return 0;
}

Affichage à l'exécution (le même que ci-dessus):

Module du nombre complexe (1.2 + 2.3i) = 2.594224
Somme (1.2+2.3i) + (0.5-1.3i) = 1.700000 + 1.000000 i
Produit (1.2+2.3i)*(0.5-1.3i) = 3.590000 - 0.410000 i
Press any key to continue

 

 

USAGE

//Définition

struct identificateurStruc {

type Membre;
............
};

//Déclaration d'une variable "Variable" de type identificateurStruc

struct identificateurStruc VariableStruc;

//Exploitation

VariableStruc.Membre = ? ;
ou
? = VariableStruc.Membre ;

//Référencement

struct identificateurStruc * ptrVariableStruc;

... = ptrVariableStruc -> Membre ;
ou
ptrVariable -> Membre = . . . ;

Exercice sur les structures : annuaire

Exercices élémentaires sur les structures

Sommaire Langage C C++
Accueil

du site