C++ Structure (struct)

Les tableaux C/C++ permettent de définir des variables pouvant stocker des éléments de données du même type, maisStructureest un autre type de données disponible défini par l'utilisateur en C++, qui permet de stocker des éléments de données de types différents.

Les structures sont utilisées pour représenter un enregistrement. Supposons que vous souhaitiez suivre la dynamique des livres dans une bibliothèque ; vous devrez peut-être suivre les attributs suivants de chaque livre :

  • Titre : Titre
  • Auteur : auteur
  • Sujet : catégorie
  • ID du livre : l'ID du livre

Définir une structure

En C++, l'instruction struct est utilisée pour définir une structure.

Une structure est un type de données défini par l'utilisateur utilisé pour combiner des données de types différents. Comme les classes, les structures permettent de définir des variables membres et des fonctions membres.

Pour définir une structure, vous devez utiliser l'instructionstruct. L'instruction struct définit un nouveau type de données contenant plusieurs membres ; le format de l'instruction struct est le suivant :

struct type_name { member_type1 member_name1; member_type2 member_name2; member_type3 member_name3; . . } object_names;

type_nameest le nom du type de structure,member_type1 member_name1est une définition de variable standard, par exempleint i;oufloat f;ou d'autres définitions de variables valides. À la fin de la définition de la structure, avant le dernier point-virgule, vous pouvez spécifier une ou plusieurs variables de structure ; c'est facultatif. Ce qui suit déclare un type de structureBooks, la variable estbook：

struct Books { char title[50]; char author[50]; char subject[100]; int book_id; } book;

Avantages des structures :

  • Encapsulation simple des données: adapté pour encapsuler des données simples de plusieurs types, généralement utilisé pour le stockage de données.
  • Léger: comparé àclass, la syntaxe des structures est plus concise et adaptée aux petits objets de données.
  • Prise en charge de la programmation orientée objet: prend en charge les constructeurs, les fonctions membres et le contrôle d'accès, permettant une conception orientée objet.

Accès aux membres d'une structure

Pour accéder aux membres d'une structure, nous utilisonsl'opérateur d'accès aux membres (.). L'opérateur d'accès aux membres est un point entre le nom de la variable de structure et le membre de structure auquel nous voulons accéder.

L'exemple suivant montre l'utilisation des structures :

Exemple

#include <iostream> #include <cstring> using namespace std; // Déclarer un type de structure Books struct Books { char title[50]; char author[50]; char subject[100]; int book_id; }; int main( ) { Books Book1; // Définir une variable Book1 du type de structure Books Books Book2; // Définir une variable Book2 du type struct Books // Détails de Book1 strcpy( Book1.title, "Tutoriel C++"); strcpy( Book1.author, "Exemple"); strcpy( Book1.subject, "Langage de programmation"); Book1.book_id = 12345; // Détails de Book2 strcpy( Book2.title, "Tutoriel CSS"); strcpy( Book2.author, "Exemple"); strcpy( Book2.subject, "Technologie front-end"); Book2.book_id = 12346; // Afficher les informations de Book1 cout << "Titre du premier livre:" << Book1.title <<endl; cout << "Auteur du premier livre:" << Book1.author <<endl; cout << "Catégorie du premier livre:" << Book1.subject <<endl; cout << "ID du premier livre :" << Book1.book_id <<endl; // Afficher les informations de Book2 cout << "Titre du deuxième livre :" << Book2.title <<endl; cout << "Auteur du deuxième livre :" << Book2.author <<endl; cout << "Catégorie du deuxième livre :" << Book2.subject <<endl; cout << "ID du deuxième livre :" << Book2.book_id <<endl; return 0; }

L'exemple définit le type de structure Books et ses deux variables Book1 et Book2. Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

第一本书标题 : C++ 教程
第一本书作者 : Example
第一本书类目 : 编程语言
第一本书 ID : 12345
第二本书标题 : CSS 教程
第二本书作者 : Example
第二本书类目 : 前端技术
第二本书 ID : 12346

Structures comme paramètres de fonction

Vous pouvez passer une structure en tant que paramètre de fonction, d'une manière similaire à des variables ou des pointeurs d'autres types. Vous pouvez utiliser la méthode de l'exemple ci-dessus pour accéder aux variables de structure :

Exemple

#include <iostream> #include <cstring> using namespace std; void printBook( struct Books book ); // Déclarer un type de structure Books struct Books { char title[50]; char author[50]; char subject[100]; int book_id; }; int main( ) { Books Book1; // Définir une variable Book1 du type struct Books Books Book2; // Définir une variable Book2 du type struct Books // Détails de Book1 strcpy( Book1.title, "Tutoriel C++"); strcpy( Book1.author, "Exemple"); strcpy( Book1.subject, "Langage de programmation"); Book1.book_id = 12345; // Détails de Book2 strcpy( Book2.title, "Tutoriel CSS"); strcpy( Book2.author, "Exemple"); strcpy( Book2.subject, "Technologie front-end"); Book2.book_id = 12346; // Afficher les informations de Book1 printBook( Book1 ); // Afficher les informations de Book2 printBook( Book2 ); return 0; } void printBook( struct Books book ) { cout << "Titre du livre :" << book.title <<endl; cout << "Auteur du livre :" << book.author <<endl; cout << "Catégorie du livre :" << book.subject <<endl; cout << "ID du livre :" << book.book_id <<endl; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

书标题 : C++ 教程
书作者 : Example
书类目 : 编程语言
书 ID : 12345
书标题 : CSS 教程
书作者 : Example
书类目 : 前端技术
书 ID : 12346

Présentation détaillée des différentes parties d'une structure

  • mot-clé struct :est utilisé pour définir une structure ; il indique au compilateur que ce qui suit est un type personnalisé.

  • Variables membres :Les variables membres sont des éléments de données définis dans une structure ; elles peuvent être de n'importe quel type de base ou d'autres types personnalisés. Dans une struct, ces membres sont publics par défaut et sont accessibles directement.

  • Fonctions membres :Les structures peuvent également contenir des fonctions membres, ce qui les rend fonctionnellement similaires aux classes. Les fonctions membres peuvent opérer sur les variables membres de la structure, assurant l'encapsulation et la manipulation des données.

  • Autorisations d'accès :Comme pour une classe, vous pouvez utiliser public, private et protected dans struct pour définir les autorisations d'accès des membres. Dans struct, tous les membres sont publics par défaut, tandis que dans une classe ils sont privés par défaut.

Pointeur vers une structure

Vous pouvez définir des pointeurs vers des structures d'une manière similaire à la définition de pointeurs vers des variables d'autres types, comme montré ci-dessous :

struct Books *struct_pointer;

Le code ci-dessus définit un pointeur struct_pointer vers la structure Books.

Maintenant, vous pouvez stocker l'adresse d'une variable de structure dans la variable pointeur définie ci-dessus. Pour trouver l'adresse d'une variable de structure, placez l'&opérateur avant le nom de la structure, comme montré ci-dessous :

struct_pointer = &Book1;

Le code ci-dessus assigne l'adresse de la variable de structure Book1 à struct_pointer.

Pour accéder aux membres d'une structure à l'aide d'un pointeur vers cette structure, vous devez utiliser l'opérateur->, comme indiqué ci-dessous :

struct_pointer->title;

Le code ci-dessus accède au membre title de la structure Book1 via struct_pointer.

Utilisons un pointeur de structure pour réécrire l'exemple ci-dessus, ce qui vous aidera à comprendre le concept de pointeurs de structure :

Exemple

#include <iostream> #include <string> using namespace std; // Déclarer un type de structure Books struct Books { string title; string author; string subject; int book_id; // constructeur Books(string t, string a, string s, int id) : title(t), author(a), subject(s), book_id(id) {} }; // Fonction pour afficher les informations du livre, prend un pointeur vers la structure Books void printBookInfo(const Books* book) { cout << "Titre du livre :" << book->title << endl; cout << "Auteur du livre :" << book->author << endl; cout << "Catégorie du livre :" << book->subject << endl; cout << "ID du livre :" << book->book_id << endl; } int main() { // Créer deux objets livre Books Book1("Tutoriel C++", "Exemple", "Langage de programmation", 12345); Books Book2("Tutoriel CSS", "Exemple", "Technologie front-end", 12346); // Utiliser des pointeurs pour pointer vers les objets de ces deux livres Books* ptrBook1 = &Book1; Books* ptrBook2 = &Book2; // Afficher les informations du livre, passer des pointeurs printBookInfo(ptrBook1); printBookInfo(ptrBook2); return 0; }

Description:

  • Définition de structure：BooksLa définition de la structure est la même qu'avant, contenanttitle、author、subjectetbook_idquatre variables membres, et il y a un constructeur pour initialiser ces membres.

  • printBookInfoFonction: Maintenant, cette fonction accepte un pointeur versBooksPointeur vers une structureconst Books* book. À l'intérieur de la fonction, nous utilisons->l'opérateur pour accéder à la variable membre pointée par le pointeur de structure.

  • mainFonction：

    • Création de deuxBooksobjets de typeBook1etBook2。

    • Utilisation&l'opérateur pour obtenir les adresses des deux objets et les affecter aux pointeursptrBook1etptrBook2。

    • AppelprintBookInfoLors du passage de la fonction, ce qui est passé est un pointeur versBooksPointeur vers un objet.

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

书籍标题: C++ 教程
书籍作者: Example
书籍类目: 编程语言
书籍 ID: 12345
书籍标题: CSS 教程
书籍作者: Example
书籍类目: 前端技术
书籍 ID: 12346

mot-clé typedef

Voici une manière plus simple de définir une structure : vous pouvez donner un alias au type créé. Par exemple :

typedef struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
}Books;

Maintenant, vous pouvez directement utiliserBookspour définirBooksvariables de ce type, sans avoir besoin du mot-clé struct. Voici un exemple :

Books Book1, Book2;

Vous pouvez utiliser le mot-clétypedefpour définir des types non-structure, comme montré ci-dessous :

typedef long int *pint32;
 
pint32 x, y, z;

x, y et z sont tous des pointeurs vers long int.

Différences entre structures et classes

En C++, struct et class sont essentiellement très similaires ; la seule différence est le droit d'accès par défaut :

  • structL'accès par défaut aux membres et l'héritage sontpublic。
  • classL'accès par défaut aux membres et l'héritage sontprivate。

Vous pouvezstructtraités comme une forme simplifiée declass, adaptée à une encapsulation simple des données sans trop de fonctionnalités complexes.

Combiner des structures avec des fonctions

Vous pouvez initialiser une structure via un constructeur, et vous pouvez également passer une structure par référence pour éviter des copies inutiles.

Exemple

struct Books {
    string title;
    string author;
    string subject;
    int book_id;

    // constructeur
    Books(string t, string a, string s, int id)
        : title(t), author(a), subject(s), book_id(id) {}

    void printInfo() const {
        cout << Titre du livre : << title << endl;
        cout << Auteur du livre : << author << endl;
        cout << Catégorie du livre : << subject << endl;
        cout << Identifiant du livre : << book_id << endl;
    }
};

void printBookByRef(const Books& book) {
    book.printInfo();
}
autres extensions