Langage C

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

les structures en C

Une structure est un type de données défini par l'utilisateur en C / C++. Une structure crée un type de données qui peut être utilisé pour grouper des éléments de types éventuellement différents en un seul type.

Comment créer une structure?

Le mot-clé ‘struct’ est utilisé pour créer une structure. Voici un exemple.

Exemple 1 :
                                struct personne{
                                    char nom[20];
                                    char adresse[60];
                                    int age;
                                    float salaire;
                                };
                            
Comment déclarer des variables de type structure?

Une variable de structure peut être déclarée avec une déclaration de structure ou comme une déclaration séparée comme les types de base.

Exemple 2 :
                                // Une déclaration variable avec déclaration de structure.
                                struct Point{
                                    int x,y;
                                }p1; // La variable p1 est déclarée avec "Point"


                                // Une déclaration de variables comme les types de données de base
                                struct Point{
                                    int x,y;
                                };

                                int main(void){
                                    struct Point p1; //La variable p1 est déclarée comme une variable normale 

                                    return 0;
                                }
                            
Comment initialiser les membres de la structure?

Les membres de structure ne peuvent pas être initialisés dans la déclaration. Par exemple, le programme C suivant échoue lors de la compilation.

Exemple 3 :
                                struct Point{
                                    int x=0; // Erreur de compilation: ne peut pas initialiser les membres ici
                                    int y=0; // Erreur de compilation: ne peut pas initialiser les membres ici
                                };
                            
La raison de l'erreur ci-dessus est simple, lorsqu'un type de données est déclaré, aucune mémoire n'est allouée pour celui-ci. La mémoire est allouée uniquement lorsque des variables sont créées.

Les membres de structure peuvent être initialisés à l’aide d’accolades '{}'. Par exemple, voici une initialisation valide.

Exemple 4 :
                                struct Point{
                                    int x, y;
                                };
                                int main(void){
                                    // Une initialisation valide. membre x obtient la valeur 0 et y
                                    // obtient la valeur 1. L'ordre de déclaration est respecté.

                                    struct Point p1={0,1};
                                    return 0;
                                }
                            
Comment accéder aux éléments de la structure?

Les membres de la Structure sont accessibles à l'aide de l'opérateur point (.)

Exemple 5 :
                                #include< stdio.h> 
                                struct Point{
                                    int x, y;
                                };
                                int main(void){
                                    struct Point p1={0,1};
                                    p1.x=10;
                                    printf ("x = %d, y = %d", p1.x, p1.y); 
                                    return 0;
                                }
                            
  x = 10, y = 1
Qu'est-ce qu'un tableau de structures ?

Comme d'autres types de données primitifs, nous pouvons créer un tableau de structures.

Exemple 6 :
                                #include< stdio.h> 
                                struct Point{
                                    int x, y;
                                };
                                int main(void){
                                    // Créer un tableau de structures
                                    struct Point tab[10];

                                    // Accéder aux membres du tableau
                                    // Premier point
                                    tab[0].x=2;
                                    tab[0].y=3;

                                    // afficher les coordonnées du premier point
                                    printf ("coordonnées du premier point; x = %d, y = %d", tab[0].x, tab[0].y); 
                                    return 0;
                                }
                            
  coordonnées du premier point; x = 2, y = 3
Qu'est-ce qu'un pointeur de structures ?

Comme les types primitifs, nous pouvons avoir un pointeur sur une structure. Si nous avons un pointeur sur la structure, les membres sont accessibles à l'aide de l'opérateur (->) .

Exemple 7 :
                                #include< stdio.h> 
                                struct Point{
                                    int x, y;
                                };
                                int main(void){
                                    struct Point p1={0,1};

                                    // p2 est un pointeur sur la structure p1
                                    struct Point *p2=&p1;

                                    printf ("x = %d, y = %d", p2->x, p2->y); 
                                    return 0;
                                }
                            
  x = 0, y = 1

Limitations des structures en C

En langage C, les structures fournissent une méthode pour regrouper des données de types différents. Une structure est un outil utile pour gérer un groupe d’éléments de données liés de manière logique. Cependant, les structures en C ont quelques limitations.

  • La structure C ne permet pas au type de données struct d'être traité comme un type de données intégré :
    Nous ne pouvons pas utiliser d'opérateurs comme +, - etc. sur les variables de structure. Par exemple, considérons le code suivant:
    Exemple 8 :
                                            struct number 
                                            { 
                                                float x; 
                                            }; 
                                            int main() 
                                            { 
                                                struct number n1,n2,n3; 
                                                n1.x=4; 
                                                n2.x=3; 
                                                n3=n1+n2; 
                                                return 0; 
                                            } 
                                        
      error: invalid operands to binary + (have 'struct number' and 'struct number') n3=n1+n2;
  • Pas de masquage de données: Les structures C ne permettent pas le masquage de données. Les membres de la structure sont accessibles par n’importe quelle fonction, n’importe où dans le périmètre de la structure.
  • Fonctions à l'intérieur de la structure: Les structures en C ne permettent pas les fonctions à l'intérieur de la structure
  • Membres statiques: les structures C ne peuvent pas avoir de membres statiques dans leur corps
  • Modificateurs d'accès: Le langage de programmation C ne prend pas en charge les modificateurs d'accès. Ils ne peuvent donc pas être utilisés dans les structures C.
  • Création de construction dans Structure: Les structures en C ne peuvent pas avoir de constructeur à l'intérieur de Structures.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :