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 .

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.

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).