Définition des variables de structure et des types de structure

1. Définition du type de structure

Méthode de définition 1 :

Typedef struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域
} *LinkList;

Méthode de définition 2 :

struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域

};
Typedef struct  LNode  *LinkList;

Les deux méthodes de définition ci-dessus sont équivalentes, c'est-à-dire définir*LinkListdéfini commestruct LNodetype, c'est-à-direLinkListest défini comme un nom de type. De cette façon, vous pouvez utiliserLinkListpour définir et déclarer de nouvelles variables, telles que :

LinkList  L;

c'est-à-dire définirLdéfini commestruct LNodevariable pointeur de type.

2. Définition d'une variable de type structure

Méthode de définition 1 :

struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域

}LnodeA;

Méthode de définition 2 :

struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域

};
struct  LNode LnodeA;

Les deux méthodes de définition ci-dessus sont également équivalentes, de cette façon, définirLnodeAdéfini comme une variable de typestruct LNode, c'est-à-direLnodeAcomme un nom de variable de typestruct LNode.

Méthodes de définition des structures et des tables internes

1. Structure, zone de table transparente, ÉLÉMENT DE DONNÉES, DOMAINE

Une table transparente est une description logique d'une table physique. La table transparente contient de nombreux champs, et certains champs sont définis comme CLÉ PRIMAIRE. Les champs contiennent également un ÉLÉMENT DE DONNÉES, qui est utilisé pour décrire les attributs linguistiques et techniques. L'ÉLÉMENT DE DONNÉES contient également un DOMAINE, qui définit le type de données et la longueur du champ.

Une structure est généralement utilisée pour définir une variable de structure, avec stockage de données temporaires, et sans CLÉ PRIMAIRE. Une structure contient un COMPOSANT plutôt qu'un CHAMP.

2. Les attributs d'une table interne sont divisés en trois types : TYPE DE LIGNE, CLÉ, TYPE DE TABLE.

TYPE DE LIGNE : Une seule ligne dans une TABLE INTERNE est appelée TYPE DE LIGNE, et la structure de chaque ligne est la même.

CLÉ : Équivalente à la clé primaire dans une base de données. Elle est utile lors du tri, qu'elle soit UNIQUE ou NON-UNIQUE.

TYPE DE TABLE : Il est divisé en STANDARD, TRIÉE, HACHÉE.

Définition des trois types de tables internes

Table standard :

DATA itab1 TYPE STANDARD TABLE OF scarr WITH NON-UNIQUE KEY carrid.

Table triée :

DATA itab2 TYPE SORTED TABLE OF scarr WITH NON-UNIQUE KEY carrid.

Table hachée :

DATA itab3 TYPE HASHED TABLE OF scarr WITH UNIQUE KEY carrid.

Méthode de définition générale (table standard)

Définir une table standard à partir d'une table de base de données

DATA itab4 TYPE TABLE OF scarr.

Définir une table standard à partir d'une variable de structure auto-définie (le plus courant)

DATA: BEGIN OF wa,
    carrid TYPE scarr-carrid,
    carrnamen TYPE scarr-carrname,
    END OF wa.
DATA itab5 LIKE TABLE OF wa.

Définir une table standard à partir d'un type de table dans le dictionnaire de données

DATA itab6 TYPE ztabtype00_1.

Définir une table interne à partir d'une table interne

DATA itab7 LIKE itab6.

Définir une structure à partir d'une table interne

DATA wa1 LIKE LINE OF itab7.

3. Façons de définir une structure

Définir la variable (ou le type) de structure d'un programme à partir d'une table ou d'une structure du dictionnaire de données

types str1 type spfli.
data str2 type  sflight.

Auto-définir une variable (ou un type) de structure dans un programme - le plus courant

data: begin of wa,
carrid type spfli-carrid,
com(10) type c,
end of wa.

Définir une structure à partir d'une table interne

data wa like line of itab.

Remarque :Ce qui est défini à partir d'une table de base de données doit être une structure

Affectation des champs de même nom (important)

Move-corresponding A  to  B.

READ sert à lire un enregistrement d'une table interne

read table itab like table of wa.

Pour lire plusieurs enregistrements d'une table interne, utilisez LOOP

loop at itab into wa.

Explication dans le langage C/C++

Définition de structure

Une structure (struct) est une collection de données composée d'une série de données de même type ou de types différents, également appelée structure.

Fonction des structures

Une structure est comme les autres types de données de base, tels que le type int, le type char ; seule une structure peut être transformée en un type de données que vous souhaitez, afin de faciliter son utilisation future.

Dans les projets réels, les structures existent en grand nombre. Le personnel de R&D utilise souvent des structures pour encapsuler certaines propriétés afin de former de nouveaux types.

Le rôle des structures dans les fonctions n'est pas la commodité ; son rôle principal est l'encapsulation. L'avantage de l'encapsulation est qu'elle peut être réutilisée. Elle permet aux utilisateurs de ne pas se soucier de ce que c'est, mais simplement de l'utiliser selon la définition.

Taille des structures et alignement mémoire

La taille d'une structure n'est pas simplement la somme de ses éléments, car les ordinateurs courants que nous utilisons aujourd'hui ont des CPU d'une longueur de mot de 32 bits. Pour ce type de CPU, lire une valeur de 4 octets est plus efficace et plus pratique que de lire un octet. Par conséquent, si la première adresse de chaque membre d'une structure est un multiple de 4, la récupération des éléments de données sera relativement plus efficace. C'est l'origine de l'alignement mémoire.

Le compilateur de chaque plateforme spécifique a son propre « facteur d'alignement » par défaut (également appelé module d'alignement). Les programmeurs peuvent utiliser la commande de précompilation#pragma pack(n)，n=1,2,4,8,16 pour modifier ce facteur, où n est le « facteur d'alignement » que vous souhaitez spécifier.

Règles :

1. Règle d'alignement des membres de données : pour les membres de données d'une structure (struct) (ou union), le premier membre de données est placé au décalage 0, et chaque membre de données suivant est aligné selon#pragma packla plus petite valeur entre la valeur spécifiée et la longueur du membre de données lui-même.
2. Règle d'alignement globale d'une structure (ou union) : Après que chaque membre de données a terminé son propre alignement, la structure (ou union) elle-même doit également être alignée. L'alignement sera basé sur< span class="marked">#pragma pack la plus petite entre la valeur spécifiée et la longueur du plus grand membre de données dans la structure (ou union).
3. En combinant 1 et 2, on en déduit : lorsque la valeur n de #pragma pack est égale ou supérieure aux longueurs de tous les membres de données, la taille de cette valeur n n'aura aucun effet.

Structures en C++

En langage C, vous pouvez définir des types de structure pour regrouper plusieurs variables liées en un tout. Les variables d'une structure peuvent être de types de données identiques, partiellement identiques ou complètement différents. En langage C, les structures ne peuvent pas contenir de fonctions. En programmation orientée objet, les objets ont un état (attributs) et un comportement ; l'état est stocké dans des variables membres, et le comportement est mis en œuvre via des méthodes membres (fonctions). Les structures en C ne peuvent décrire que l'état d'un objet, pas le comportement d'un objet. En C++, compte tenu de la continuité de la transition de C à C++, les structures sont étendues. Les structures en C++ peuvent contenir des fonctions, de sorte que les structures en C++ ont également les fonctionnalités des classes. Contrairement à class, les fonctions contenues dans une structure sont publiques par défaut, et non privées.

Exemple de sortie console C++ :

Exemple

#include <cstdlib>　 #include <iostream>//Définir la structure using namespace std;　 struct point　 {　　 //Contient deux variables membres int x;　　 int y;　 };　　 int main(int argc, char *argv[])　 {　　 struct point pt;　 pt.x=1;　 pt.y=2;　 cout<<pt.x<<endl<<pt.y<<endl; return EXIT_SUCCESS; }

Différences entre les structures et les classes en C++

En C++, les classes et les structures ne diffèrent que de deux manières ; à part cela, il n'y a aucune différence.

(1) La permission d'accès par défaut des membres dans une classe est privée, tandis que dans une struct elle est publique.
(2) L'héritage depuis une classe est privé par défaut, tandis que l'héritage depuis une struct est public par défaut.

Quelle est la différence entre ces deux définitions ?

typedef struct student
{
    int num;
    struct student *next;
}student;

struct student
{
    int num;
    struct student *next;
};

La seconde "struct student" définit une structure student, comprenez-vous cela ?

La première utilise typedef pour redéfinir le nom de type de structure "struct student" en "student". C'est-à-dire que "struct student" et "student" représentent la même chose et sont tous deux des identifiants d'un type. Par exemple, "typedef int zhengshu;" renomme l'entier int en zhengshu. Les définitions suivantes : "int i;" et "zhengshu i;" sont équivalentes.

Une structure est une combinaison de diverses variables composées de types de données de base et nommées par un identifiant. Différents types de données peuvent être utilisés dans une structure.

Déclaration de structure et définition de variable de structure

Dans Turbo C, une structure est aussi un type de données, et des variables de structure peuvent être utilisées. Par conséquent, comme les variables d'autres types, les variables de structure doivent être définies avant utilisation.

Le format général pour définir une variable de structure est :

struct 结构名
{ 
    类型 变量名;
    类型 变量名;
...
} 结构变量;

Le nom de la structure est l'identifiant de la structure, et non le nom de la variable.

Les types sont les cinq types de données décrits à la section 2 (entier, à virgule flottante, caractère, pointeur et void).

Chaque variable de type qui compose une structure est appelée un membre de structure. Il est comme un élément de tableau, mais les éléments de tableau sont accessibles par des indices, tandis que les structures accèdent aux membres par des noms de variables.

Voici un exemple pour illustrer comment définir une variable de structure.

struct string 
{ 
    char name[8]; 
    int age; 
    char sex[4]; 
    char depart[20]; 
    float wage1,wage2,wage3; 
}person;

Cet exemple définit une variable de structure "person" avec un nom de structure "string". Si le nom de variable "person" est omis, cela devient une déclaration de la structure. Un nom de structure déjà déclaré peut également être utilisé pour définir des variables de structure. Lorsqu'elles sont définies de cette façon, l'exemple ci-dessus devient :

struct string 
{ 
    char name[8]; 
    int age; 
    char sex[4]; 
    char depart[20]; 
    float wage1,wage2,wage3; 
}; 
struct string person;

Si vous devez définir plusieurs variables de structure de même forme, cette méthode est plus pratique. Elle déclare d'abord la structure, puis utilise le nom de la structure pour définir les variables.

Par exemple :

struct string Tianyr, Liuqi, ...;

Si le nom de la structure est omis, elle est appelée une structure anonyme. Cette situation se produit souvent à l'intérieur des fonctions. Lorsque vous utilisez ce type de structure, l'exemple précédent devient :

struct 
{ 
    char name[8]; 
    int age; 
    char sex[4]; 
    char depart[20]; 
    float wage1,wage2,wage3; 
} Tianyr, Liuqi;

Utilisation des variables de structure

Une structure est un nouveau type de données, donc les variables de structure peuvent être affectées et utilisées dans des opérations comme des variables d'autres types. La différence est que les variables de structure utilisent des membres comme variables de base.

La représentation des membres de structure est :

structure variable.member name

Si vous considérez variable de structure.nom de membre comme un tout, le type de données de ce tout est le même que le type de données de ce membre dans la structure, donc il peut être utilisé comme les variables décrites précédemment.

L'exemple suivant définit une variable de structure, où chaque membre reçoit des données à partir du clavier, puis additionne les nombres à virgule flottante de la structure et affiche le résultat. Veuillez noter l'accès aux différents membres de structure dans cet exemple.

Exemple

#include <stdio.h> #include <conio.h> int main() { struct { char name[8]; int age; char sex[4]; char depart[20]; float wage1,wage2,wage3; }a; float wage; char c='Y'; while(c=='Y'||c=='y') { printf(\nName:); scanf(%s, a.name); printf(Age:); scanf(%d, &a.wage); printf(Sex:); scanf(%s, a.sex); printf(Dept:); scanf(%s, a.depart); printf(Wage1:); scanf(%f, &a.wage1); printf(Wage2:); scanf(%f, &a.wage2); printf(Wage3:); scanf(%f, &a.wage3); wage=a.wage1+a.wage2+a.wage3; printf(Le sum de wage est %6.2f\n, wage); printf(Continuer?); c=getche(); } }

Tableaux de structures et pointeurs de structures

Une structure est un nouveau type de données, et elle peut également avoir des tableaux de structures et des pointeurs de structures.

1. Tableaux de structures

Un tableau de structures est une collection de variables de même type de structure. Par exemple, pour définir les noms, sexes, âges et adresses de 40 étudiants dans une classe, vous pouvez le définir comme un tableau de structures. Comme montré ci-dessous :

struct
{ 
    char name[8]; 
    char sex[4]; 
    int age; 
    char addr[40]; 
}student[40];

Il peut également être défini comme :

struct string
{ 
    char name[8]; 
    char sex[4]; 
    int age; 
    char addr[40]; 
}; 
struct string student[40];

Il convient de souligner que l'accès aux membres d'un tableau de structures considère l'élément du tableau comme une variable de structure, et sa forme est :

structure array element.member name

Par exemple :

student[0].name 
student[30].age

En fait, un tableau de structures est équivalent à une structure bidimensionnelle. La première dimension correspond aux éléments du tableau de structures, chaque élément est une variable de structure, et la deuxième dimension correspond aux membres de la structure.

Remarque: Les membres d'un tableau de structures peuvent aussi être des variables de tableau.

Par exemple :

struct a 
{ 
    int m[3][5]; 
    float f; 
    char s[20]; 
}y[4];

Pour accéder à la variable de structure dans la structure ay[2]cette variable, elle peut s'écrire commey[2].m[1][4]

2. Pointeurs de structure

Un pointeur de structure est un pointeur vers une structure. Il est défini par un opérateur * placé avant le nom de la variable de structure. Par exemple, utilisez la structure décrite précédemment pour définir un pointeur de structure comme suit :

struct string
{ 
    char name[8]; 
    char sex[4]; 
    int age; 
    char addr[40]; 
}*student;

Vous pouvez également omettre le nom du pointeur de structure et faire seulement une déclaration de structure, puis utiliser l'instruction suivante pour définir le pointeur de structure.

struct string *student;

L'utilisation d'un pointeur de structure pour accéder aux membres d'une structure diffère, dans l'expression, de l'utilisation d'une variable de structure pour accéder aux membres d'une structure. L'accès aux membres d'une structure via un pointeur de structure s'exprime comme suit :

structure pointer name->structure member

où->sont deux symboles-et>combinés, comme une flèche pointant vers un membre de structure. Par exemple, pour affecter des valeurs à name et age dans la structure définie ci-dessus, vous pouvez utiliser les instructions suivantes :

strcpy(student->name, Lu G.C); 
student->age=18;

En fait,student->nameest(*student).namel'abréviation de.

Il convient de souligner qu'un pointeur de structure est un pointeur vers une structure, c'est-à-dire la première adresse du premier membre de la structure. Par conséquent, avant utilisation, le pointeur de structure doit être initialisé, c'est-à-dire allouer un espace d'octets de la longueur totale de la structure. Cela peut être fait avec la fonction suivante, en utilisant toujours l'exemple précédent pour illustrer comme suit :

student=(struct string*)malloc(size of (struct string));

size of (struct string)Obtient automatiquement la longueur en octets de la structure string. La fonction malloc() définit une zone mémoire de la taille de la longueur de la structure, puis renvoie sa première adresse comme pointeur de structure.

Remarque :

1. Une structure est un type de données, donc les variables de structure ou variables de pointeur de structure définies ont également des variables locales et des variables globales, selon l'endroit où elles sont définies.
2. Le nom de la variable de structure n'est pas l'adresse pointant vers la structure, ce qui est différent de la signification d'un nom de tableau. Par conséquent, si vous devez trouver la première adresse du premier membre de la structure, elle doit être&[nom de la variable de structure]。
3. Forme complexe de structure : structures imbriquées

Une structure imbriquée signifie qu'un membre de structure peut inclure une autre structure. Turbo C autorise ce type d'imbrication.

Par exemple : ce qui suit est une structure avec imbrication

struct string
{ 
    char name[8]; 
    int age; 
    struct addr address; 
} student;

Ici : addr est le nom de structure d'une autre structure, et il doit être déclaré d'abord, c'est-à-dire,

struct addr
{ 
    char city[20]; 
    unsigned lon zipcode; 
    char tel[14]; 
}

Si vous souhaitez affecter une valeur à zipcode dans la structure address, qui est un membre de la structure student, vous pouvez écrire :

student.address.zipcode=200001;

Chaque nom de membre de structure est listé un par un depuis la couche la plus externe jusqu'à la couche la plus interne, c'est-à-dire que l'expression des membres de structure imbriqués est :

structure variable name.nested structure variable name.structure member name

Il peut y avoir de nombreuses structures imbriquées, et le nom de membre de structure est le nom d'un membre dans la structure la plus interne qui n'est pas une structure.

Lien original : https://www.cnblogs.com/yuxinJ/p/4688496.html