'>

Les Structures de données dans C-plus-plus

 Nous avons déjà appris comment des groupes de données séquentielles peuvent être utilisés en C + +. Mais c'est un peu restrictif, car dans de nombreuses occasions que nous voulons stocker sont pas de simples séquences d'éléments tout de même type de données, mais des ensembles d'éléments différents avec différents types de données.

Les structures de données
Une structure de données est un groupe d'éléments de données groupés sous un même nom. Ces éléments de données, appelés membres, peuvent avoir différents types et de différentes longueurs. Les structures de données sont déclarées en C + + en utilisant la syntaxe suivante:

struct {structure_name
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
Object_names};

où structure_name est un nom pour le type de structure, object_name peut être un jeu d'identifiants valides pour les objets qui ont le type de cette structure. Entre accolades {} il ya une liste avec les membres de données, chacun est spécifié avec un type et un identificateur valide comme son nom l'.

La première chose que nous devons savoir, c'est que d'une structure de données crée un nouveau type: une fois une structure de données est déclarée, un nouveau type avec l'identifiant spécifié comme structure_name est créé et peut être utilisé dans le reste du programme comme s'il s'agissait d'une autre type. Par exemple:

1
 2
 3
 4
 5
 6
 7


  

 struct product { int weight; float price; } ; product apple; product banana, melon;



Nous avons tout d'abord déclaré un type de structure appelée produit de deux éléments: le poids et le prix, chacun d'un type fondamental différent. Nous avons ensuite utilisé ce nom du type de structure (produit) de déclarer trois objets de ce type: pomme, banane et le melon comme nous l'aurions fait avec n'importe quel type de données fondamental.

Une fois déclaré, le produit est devenu un nouveau nom de type valide comme les fondamentaux int, char ou à court et à partir de là, nous sommes en mesure de déclarer des objets (variables) de ce nouveau type composé, comme nous l'avons fait avec la pomme, la banane et le melon .

Juste à la fin de la déclaration de struct, et avant le point-virgule de fin, nous pouvons utiliser le nom_objet champ facultatif de déclarer directement les objets du type de structure. Par exemple, nous pouvons aussi déclarer la structure des objets pomme, la banane et le melon au moment où nous définissons le type de structure de données de cette façon:

 1
 2
 3
 4


  

 struct product { int weight; float price; } apple, banana, melon;



Il est important de différencier clairement entre ce qui est le nom du type de structure, et ce qui est un objet (variable) qui a ce type de structure. Nous pouvons instancier d'objets (ie variables, comme la pomme, la banane et le melon) à partir d'un seul type de structure (produit).

Une fois que nous avons déclaré nos trois objets d'un type de structure déterminée (pomme, banane et melon), nous pouvons fonctionner directement avec leurs membres. Pour ce faire, nous utilisons un point (.) Inséré entre le nom de l'objet et le nom du membre. Par exemple, nous pourrions fonctionner avec n'importe quel de ces éléments comme s'ils étaient des variables standard de leurs types respectifs:

 1
 2
 3
 4
 5
 6


  

 apple.weight apple.price banana.weight banana.price melon.weight melon.price



Chacun d'eux a le type de données correspondant à l'élément qu'ils appellent: apple.weight, banana.weight et melon.weight sont de type int, alors que apple.price, banana.price et melon.price sont de type float.

Voyons un exemple réel où vous pouvez voir comment un type de structure peut être utilisée de la même façon que les types fondamentaux:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38


  

 // example about structures #include <iostream> #include <string> #include <sstream> using namespace std; struct movies_t { string title; int year; } mine, yours; void printmovie (movies_t movie); int main () { string mystr; mine.title = "2001 A Space Odyssey" ; mine.year = 1968; cout << "Enter title: " ; getline (cin,yours.title); cout << "Enter year: " ; getline (cin,mystr); stringstream(mystr) >> yours.year; cout << "My favorite movie is:\n " ; printmovie (mine); cout << "And yours is:\n " ; printmovie (yours); return 0; } void printmovie (movies_t movie) { cout << movie.title; cout << " (" << movie.year << ")\n" ; }

  

  Entrez le titre: Alien
  Entrez année: 1979

  Mon film préféré est:
   2001 A Space Odyssey (1968)
  Et le vôtre est:
   Alien (1979)



L'exemple montre comment nous pouvons utiliser les membres d'un objet comme des variables ordinaires. Par exemple, le yours.year membre est une variable valide de type int, et mine.title est une variable valide de type string.

La mine d'objets et les vôtres peuvent également être traitées comme des variables valide de type movies_t, par exemple, nous sommes passés à la fonction printmovie comme nous l'aurions fait avec des variables régulières. Par conséquent, l'un des avantages les plus importants de structures de données, c'est que nous pouvons soit faire référence à leurs membres, individuellement ou à l'ensemble de la structure comme un bloc avec un seul identifiant.

Les structures de données sont une caractéristique qui peut être utilisé pour représenter des bases de données, en particulier si l'on considère la possibilité de construire des tableaux de leur:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40


  

 // array of structures #include <iostream> #include <string> #include <sstream> using namespace std; #define N_MOVIES 3 struct movies_t { string title; int year; } films [N_MOVIES]; void printmovie (movies_t movie); int main () { string mystr; int n; for (n=0; n<N_MOVIES; n++) { cout << "Enter title: " ; getline (cin,films[n].title); cout << "Enter year: " ; getline (cin,mystr); stringstream(mystr) >> films[n].year; } cout << "\nYou have entered these movies:\n" ; for (n=0; n<N_MOVIES; n++) printmovie (films[n]); return 0; } void printmovie (movies_t movie) { cout << movie.title; cout << " (" << movie.year << ")\n" ; }

  

  Entrez le titre: Blade Runner
  Entrez année: 1982
  Entrez le titre: Matrix
  Entrez année: 1999
  Entrez le titre: Taxi Driver
  Entrez année: 1976

  Vous avez entré ces films:
  Blade Runner (1982)
  Matrix (1999)
  Taxi Driver (1976)



Pointeurs vers des structures
Comme tout autre type, les structures peuvent être pointées par son propre type de pointeurs:

 1
 2
 3
 4
 5
 6
 7


  

 struct movies_t { string title; int year; }; movies_t amovie; movies_t * pmovie;



Voici amovie est un objet de type structural movies_t et pmovie est un pointeur pour pointer vers des objets de type structural movies_t. Ainsi, le code suivant serait également valable:



  

 pmovie = &amovie;



La valeur de la pmovie pointeur se verrait attribuer la mention de la amovie d'objet (son adresse mémoire).

Nous allons maintenant passer à un autre exemple qui comprend des pointeurs, qui serviront à introduire un nouvel opérateur: l'opérateur flèche (->):

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31


  

 // pointers to structures #include <iostream> #include <string> #include <sstream> using namespace std; struct movies_t { string title; int year; }; int main () { string mystr; movies_t amovie; movies_t * pmovie; pmovie = &amovie; cout << "Enter title: " ; getline (cin, pmovie->title); cout << "Enter year: " ; getline (cin, mystr); (stringstream) mystr >> pmovie->year; cout << "\nYou have entered:\n" ; cout << pmovie->title; cout << " (" << pmovie->year << ")\n" ; return 0; }

  

  Entrez le titre: Invasion of the Body Snatchers
  Entrez année: 1978

  Vous avez entré:
  Invasion of the Body Snatchers (1978)



Le code précédent inclut une introduction importante: l'opérateur flèche (->). Il s'agit d'un opérateur de déréférencement qui est utilisé exclusivement avec des pointeurs vers des objets avec des membres. Cet opérateur sert à accéder à un membre d'un objet pour lequel nous avons une référence. Dans l'exemple que nous avons utilisé:



  

 pmovie->title



Quel est, à toutes fins équivalentes à:



  

 (*pmovie).title



Les deux expressions pmovie-> titre et (* pmovie). Titres sont valides et les deux signifie que nous évaluons le titre de membre de la structure de données pointées par un pointeur appelé pmovie. Il doit être clairement différenciée de:



  

 *pmovie.title



ce qui est équivalent à:



  

 *(pmovie.title)



Et ce serait accéder à la valeur pointée par un membre du pointeur hypothétique appelé titre de l'objet pmovie de la structure (qui dans ce cas ne serait pas un pointeur). Le panneau suivant résume les combinaisons possibles des pointeurs et des membres de la structure:

Expression     Ce qui est évalué     Equivalent
ab     Membre b de l'objet a   
a-> b     Membre b de l'objet pointé par un     (* A). B
* Ab     Valeur pointée par membre b de l'objet a     * (Ab)

Structures de nidification

Les structures peuvent également être imbriqués de sorte qu'un élément valable d'une structure peut également être à son tour une autre structure.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12


  

 struct movies_t { string title; int year; }; struct friends_t { string name; string email; movies_t favorite_movie; } charlie, maria; friends_t * pfriends = &charlie;



Après la déclaration précédente, nous pourrions utiliser les expressions suivantes:

 1
 2
 3
 4


  

 charlie.name maria.favorite_movie.title charlie.favorite_movie.year pfriends->favorite_movie.year


(Où, soit dit en passant, les deux dernières expressions font référence au même membre).
Publié par Drupal Study