Structures des données dans C++


Une structure de donnĂ©es est un groupe d’Ă©lĂ©ments de donnĂ©es regroupĂ©s sous un mĂªme nom. Ces Ă©lĂ©ments de donnĂ©es, appelĂ©s membres, peuvent avoir diffĂ©rents types et diffĂ©rentes longueurs. Les structures de donnĂ©es peuvent Ăªtre dĂ©clarĂ©es en C ++ en utilisant la syntaxe suivante:

struct nom_type {
type_membre1 nom_membre1;
type_membre2 nom_membre2;
type_membre3 nom_membre3;
.
.
} object_names;

OĂ¹ nom_type est un nom pour le type de structure, nom_objet peut Ăªtre un ensemble d’identificateurs valides pour les objets ayant le type de cette structure. Entre accolades {}, il y a une liste avec les membres de donnĂ©es, chacun Ă©tant spĂ©cifiĂ© avec un type et un identifiant valide comme nom.

Par exemple:

struct produit{
  int poids;
  double prix;
};

produit pomme;
produit banane, melon;

Cela dĂ©clare un type de structure, appelĂ© produit, et le dĂ©finit avec deux membres: poids et prix, chacun d’un type fondamental diffĂ©rent. Cette dĂ©claration crĂ©e un nouveau type (produit), qui est ensuite utilisĂ© pour dĂ©clarer trois objets (variables) de ce type: pomme, banane et melon. Notez qu’une fois le produit dĂ©clarĂ©, il est utilisĂ© comme tout autre type.

Juste Ă  la fin de la dĂ©finition de la structure, et avant le point-virgule de fin (;), le champ facultatif object_names peut Ăªtre utilisĂ© pour dĂ©clarer directement des objets du type de structure. Par exemple, les objets structure pomme, banane et melon peuvent Ăªtre dĂ©clarĂ©s au moment oĂ¹ le type de structure de donnĂ©es est dĂ©fini:

struct produit {
  int poids;
  double prix;
} pomme, banane, melon;

Dans ce cas, lorsque les noms d’objet sont spĂ©cifiĂ©s, le nom du type (produit) devient facultatif: struct requiert un nom de type ou au moins un nom dans les noms d’objet, mais pas nĂ©cessairement les deux.

Il est important de bien distinguer le nom du type de structure (produit) du type d’objet de ce type (pomme, banane et melon). De nombreux objets (tels que pomme, banane et melon) peuvent Ăªtre dĂ©clarĂ©s Ă  partir d’un seul type de structure (produit).

Une fois que les trois objets d’un type de structure dĂ©terminĂ© sont dĂ©clarĂ©s (pomme, banane et melon), ses membres sont accessibles directement. La syntaxe pour cela consiste simplement Ă  insĂ©rer un point (.) Entre le nom de l’objet et le nom du membre. Par exemple, nous pourrions utiliser n’importe lequel de ces Ă©lĂ©ments comme s’il s’agissait de variables standard de leurs types respectifs:

pomme.poids
pomme.prix
banane.poids
banane.prix
melon.poids
melon.prix

Chacun de ces types a le type de données correspondant au membre auquel ils font référence: pomme.poids, banane.poids et melon.poids sont de type int, tandis que pomme.prix, banane.prix et melon.prix sont de type double .

Ă€ lire aussi  Les classes dans C++

Voici un exemple réel avec des types de structure en action:

// exemple sur les 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 = "Odyssée de l'espace 2001";
  mine.year = 1968;

  cout << "Entrez le titre:";
  getline (cin, yours.title);
  cout << "Entrez l'année:";
  getline (cin, mystr);
  stringstream (mystr) >> yours.year;

  cout << "Mon film préféré est: \ n";
  printmovie (mine);
  cout << "Et le vôtre est: \ n";
  printmovie (yours);
  return 0;
}

void printmovie (movies_t movie)
{
  cout << movie.title;
  cout << "(" << movie.year << ") \ n";
}

Résultat de l’exécution :

Entrez le titre: Alien
Entrez l'année: 1979

Mon film préféré est:
 2001 Une odyssée de l'espace (1968)
Et le vĂ´tre est:
 Alien (1979)

L’exemple montre comment les membres d’un objet agissent comme des variables normales. Par exemple, le membre yours.year est une variable valide de type int et mine.title est une variable valide de type string.

Mais les objets mine et yours sont aussi des variables de type (movies_t). Par exemple, les deux fonctions ont Ă©tĂ© passĂ©es Ă  fonctionner comme si elles Ă©taient de simples variables. Par consĂ©quent, l’une des caractĂ©ristiques des structures de donnĂ©es est la possibilitĂ© de se rĂ©fĂ©rer Ă  leurs membres individuellement ou Ă  l’ensemble de la structure. Dans les deux cas utilisant le mĂªme identifiant: le nom de la structure.

Les structures Ă©tant des types, elles peuvent Ă©galement Ăªtre utilisĂ©es comme type de tableaux pour construire des tables ou des bases de donnĂ©es:

// tableau de structures
#include <iostream>
#include <string>
#include <sstream>
using namespace std;

struct movies_t {
  string title;
  int year;
} films [3];

void printmovie (movies_t movie);

int main ()
{
  string mystr;
  int n;

  pour (n = 0; n <3; n ++)
  {
    cout << "Entrez le titre:";
    getline (cin, films [n] .title);
    cout << "Entrez l'année:";
    getline (cin, mystr);
    stringstream (mystr) >> films [n] .year;
  }

  cout << "\ nVous avez entré ces films: \ n";
  pour (n = 0; n <3; n ++)
    film (films [n]);
  return 0;
}

void printmovie (movies_t movie)
{
  cout << movie.title;
  cout << "(" << movie.year<< ") \ n";
}

Résultat de l’exécution :

Entrez le titre: Blade Runner
Entrez l'année: 1982
Entrez le titre: The Matrix
Entrez l'année: 1999
Entrez titre: Taxi Driver
Entrez l'année: 1976
 
Vous avez entré ces films:
Coureur de lame (1982)
La matrice (1999)
Chauffeur de taxi (1976)

Pointeurs et structures

Comme tout autre type, les structures peuvent Ăªtre dĂ©signĂ©es par leur propre type de pointeurs:

struct movies_t {
  string title;
  int year;
};

movies_t amovie;
movies_t * pmovie;

Ici, film est un objet de type structure movies_t et pmovie est un pointeur pointant sur des objets de type structure movies_t. Par conséquent, le code suivant serait également valide:

pmovie = & amovie;

La valeur du pointeur pmovie serait attribuĂ©e Ă  l’adresse d’objet amovie.

Ă€ lire aussi  Premier programme en C++

Voyons maintenant un autre exemple qui mĂ©lange des pointeurs et des structures et servira Ă  introduire un nouvel opĂ©rateur: l’opĂ©rateur de flèche (->):

// pointeurs vers 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 << "Entrez le titre:";
  getline (cin, pmovie-> title);
  cout << "Entrez l'année:";
  getline (cin, mystr);
  (stringstream) mystr >> pmovie-> year;

  cout << "\ nVous avez entré: \ n";
  cout << pmovie-> title;
  cout << "(" << pmovie-> year << ") \ n";

  return 0;
}

Résultat de l’exécution:

Entrez titre: Invasion des voleurs de corps
Entrez l'année: 1978
 
Vous avez entré:
Invasion des voleurs de corps (1978)

L’opĂ©rateur de flèche (->) est un opĂ©rateur de dĂ©rĂ©fĂ©rence utilisĂ© exclusivement avec des pointeurs sur des objets ayant des membres. Cet opĂ©rateur permet d’accĂ©der au membre d’un objet directement Ă  partir de son adresse. Par exemple, dans l’exemple ci-dessus:

pmovie -> title

est équivalent à:

 (*pmovie).title

Les deux expressions, pmovie-> title et (* pmovie) .title sont valides, et les deux accèdent au titre du membre de la structure de donnĂ©es pointĂ©e par un pointeur appelĂ© pmovie. C’est certainement quelque chose de diffĂ©rent de:

*pmovie.title

ce qui est plutôt équivalent à:

 *(pmovie.title)

Cela permettrait d’accĂ©der Ă  la valeur indiquĂ©e par un membre de pointeur hypothĂ©tique appelĂ© title de l’objet de structure pmovie (ce qui n’est pas le cas, car title n’est pas un type de pointeur).

 


Articles similaires

2 commentaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page