Bonjour et bienvenue. Nous sommes dans une nouvelle section.
Nous allons parler de structures.
Il s'agit d'un nouveau concept en c qui vous
permet de regrouper des éléments, similaire à array mais plus puissant.
Je veux parler de ce qu'est une structure, comment vous pouvez créer et comment
vous pouvez utiliser une structure.
Ainsi, les structures en c fournissent un autre outil pour regrouper des éléments.
Encore une fois, j'ai mentionné qu'ils sont similaires à un tableau, mais qu'ils sont en fait un peu plus puissants.
Si vous êtes familier avec la
programmation orientée objet, si vous programmez en java ou
c-plus plus ou tout autre langage orienté objet, c'est en quelque sorte considéré
comme un objet mais uniquement avec des données membres, pas de comportement réel, pas de méthodes.
C'est donc un concept puissant
que vous utiliserez dans de nombreux programmes c que
vous développez car vous pouvez regrouper différents éléments en un
seul nom et ceux-ci peuvent représenter essentiellement des attributs de données.
Par exemple, disons que vous souhaitez stocker une date dans un programme.
Une date se compose généralement de trois variables: mois, jour et année.
Vous créeriez ces trois variables pour stocker ces données.
Par exemple, vous diriez que le mois entier équivaut à 9 jours, 25
ans équivaut à 2015.
Supposons que votre programme ait également besoin de stocker la date d'achat d'un article particulier.
Eh bien, vous devrez probablement créer trois autres variables pour chaque
date que vous utilisez dans votre programme. Vous pouvez donc voir comment cela
peut devenir très répétitif et vous finissez par créer beaucoup de variables.
Mais ce que vous devriez remarquer, c'est que ces variables sont liées logiquement. Ce sont tous des rendez-vous.
Ils devraient vraiment être regroupés.
Ils devraient presque être leur propre type de données et vous devriez alors pouvoir les
créer et accéder aux différents éléments.
Vous ne devriez pas avoir à créer trois variables distinctes pour chaque date.
Encore une fois, c'est là qu'il entre en relation avec des objets
et une classe qui a trois attributs de données.
Ce serait donc bien mieux si vous pouviez en quelque sorte regrouper ces ensembles de trois variables.
Et c'est précisément ce que fait l'élément de structure et c.
Il vous permet de regrouper ces différents éléments avec un nom particulier.
Vous pouvez alors créer différentes variables de ce nom
et accéder aux éléments de ce
nom, aux différents attributs de données, ils sont vraiment appelés membres.
Alors, comment créez-vous une structure en c.
C'est très très simple. La déclaration de structure décrit comment une structure est constituée.
Quels éléments se trouvent à l'intérieur de la structure.
Et nous nous référons généralement à ces éléments en tant que membres.
Parce que vous devez d'abord définir la structure ou déclarer la structure, décrivez
ce qui se trouve à l'intérieur de la structure.
Et vous pouvez donc le faire avec le mot-clé struct.
Le mot-clé struct vous permet de définir une collection
de variables de différents types appelée structure que vous pouvez traiter comme une seule unité.
Très, très puissant.
Donc, en utilisant ce mot-clé struct, tout ce que vous avez à faire est de fournir un
nom, ce que l'on appelle généralement le nom de la balise. Dans cet exemple, nous avons un nom de balise de date.
Mais vous voyez le mot-clé struct, c'est le mot-clé qui indique au
compilateur c que cela va être une fonction spécifique.
Cela peut avoir des fonctionnalités spécifiques qui vous permettent de regrouper des éléments.
Donc struct est le mot clé suivi du
nom de la balise, puis vous avez
l'accolade gauche et l'accolade droite suivies d'un point-virgule pour terminer.
Et puis à l'intérieur, vous pouvez définir tous les types de variables que vous voulez, vous pouvez même y mettre des pointeurs.
Et ceux-ci sont appelés les membres de la structure.
C'est donc une nouvelle déclaration qui définit une structure de
date que le compilateur c comprendra.
Il indique au compilateur c ce que la structure d'état
va contenir, trois éléments: mois,
jour et année. Il n'y a pas d'allocation de mémoire pour cette déclaration.
Encore une fois, ce que vous dites, c'est que c'est une structure qui existe.
Je n'ai pas encore commencé à l'utiliser. Je viens de dire que c'est ainsi que cela va être défini.
Cela va être la structure de date et c'est en quoi elle consiste.
Les noms de variables dans la structure de date, le mois, le jour
et l'année, ceux-ci sont appelés membres ou champs.
Les membres de la structure apparaissent entre les accolades qui
suivent la date du nom de la balise struct, donc le nom de la balise date.
Syntaxe très, très simple pour regrouper ces éléments dans un seul nom qui est la date.
Et vous remarquez que c'est différent d'un tableau car il n'y
a pas d'indices, vous ne spécifiez pas réellement de taille.
Ce n'est pas exactement le même type de données.
Vous pouvez avoir différents types de données et vous pouvez en avoir plusieurs.
Alors, comment utiliseriez-vous cette structure.
Eh bien, la définition de la date définit un nouveau type dans la langue.
Vous pouvez vraiment le considérer comme un autre type, tout comme un int, un double ou un float.
Sauf ce type que vous avez défini, vous pouvez presque le considérer comme une énumération.
Sauf qu'une énumération ne contient qu'une seule valeur.
Cette structure de date peut contenir trois valeurs, mais il s'agit d'un autre type de données.
Les variables peuvent maintenant être déclarées comme étant de type struct à ce jour.
C'est donc exactement ce que vous feriez.
Vous pouvez créer une nouvelle variable appelée aujourd'hui
et elle sera de type struct date.
Et aujourd'hui va essentiellement pouvoir contenir trois valeurs.
Et puis si vous avez besoin de déclarer plus
de dates, vous pouvez créer plus de variables du même type.
Ainsi, vous n'avez plus besoin d'avoir trois variables distinctes pour une date d'achat,
trois variables distinctes pour la date
actuelle, trois variables distinctes pour une date de facturation.
Vous pouvez avoir une
ou deux variables d'instances différentes de cette structure réelle.
Encore une fois, j'espère que vous remarquerez à quel point cela peut être puissant.
Donc, cette déclaration ci-dessus doit être de type struct date,
date d'achat.
La mémoire est maintenant allouée car vous avez déclaré que la
variable Memory est allouée pour cette structure.
La mémoire est allouée pour les trois valeurs entières ou les trois membres
de chaque variable, de sorte
que la mémoire va être allouée.
Et aussi la raison pour laquelle il va être alloué est parce qu'il n'y a pas de pointeurs là-dedans.
S'il y avait des pointeurs dans cette structure, vous devrez allouer de la mémoire pour ce pointeur.
Mais comme cette structure de date d'aujourd'hui est une structure très simple
que je commence lentement, elle contient trois entiers, ces membres sont automatiquement alloués pour vous.
Mais assurez-vous de bien comprendre cette distinction par rapport à la diapositive précédente et à la diapositive actuelle.
Il y a une différence entre définir une structure et déclarer les variables de
ce type de structure particulier.
Encore une fois, la structure financière dit simplement au compilateur c: voici une
structure et ceci - ce sont les données qui se trouvent à l'intérieur.
Mais en fait, déclarer une variable de ce type de structure particulier
signifie que je vais commencer à utiliser cette structure.
J'ai maintenant de la mémoire allouée pour les trois éléments de notre exemple, et
je peux accéder à ces éléments et les définir.
Alors, comment accédez-vous aux membres d'une structure?
Alors maintenant que vous savez comment définir une structure et que
vous savez maintenant comment déclarer des variables de structure,
vous devez maintenant être en mesure de comprendre comment faire référence à ces membres de struct.
Vous devez y accéder. Si vous ne pouviez pas y accéder pour voir les valeurs ou définir des valeurs, cela ne servirait à rien.
Ainsi, un nom de variable de structure n'est pas un pointeur.
Vous avez donc besoin d'une syntaxe spéciale pour accéder aux membres.
Parce que les pointeurs ne contiennent généralement que la valeur
d'une adresse.
Et si ce n'est pas un pointeur, vous aurez besoin d'une syntaxe spéciale.
Vous pouvez faire référence à un membre d'une structure en écrivant le nom de la variable suivi d'un point.
Il est généralement appelé comme l'opérateur point.
Et puis après cette période d'opérateur point,
vous suivez le nom de la variable membre à l'intérieur de cette structure.
Le point entre le nom de la
variable de structure et le nom du membre est appelé l'opérateur
de sélection de membre, également appelé opérateur point.
Il n'y a aucun espace autorisé entre le nom de la variable, le point et le nom du membre.
Pour définir la valeur du jour dans la variable d'aujourd'hui à 25, je
ferais simplement quelque chose comme ça. Le nom de la variable
qui est aujourd'hui, puis je dirais point, pas d'espaces entre les deux côtés.
Et puis je spécifierais le nom de l'élément dans la définition de la structure,
qui est le jour.
Et puis je l'attribuerais comme j'attribue n'importe quel autre entier.
J'utiliserais l'opérateur d'assignation égal,
une constante littérale ici et le point-virgule.
Très, très simple. Si je veux
attribuer l'année, je dirais aujourd'hui. année et je dirais égal 2015 par exemple.
Et quand je veux accéder aux valeurs des membres.
Par exemple, si je voulais accéder à la valeur de membre de month pour voir si elle est égale
à 12, j'utiliserais toujours cette syntaxe de point, cet opérateur de sélection de membre.
Vous pouvez donc utiliser l'opérateur de sélection de membres pour accéder aux valeurs des membres.
Et lorsque vous accédez à
ces variables membres, vous pouvez les utiliser comme vous utilisez d'autres variables.
Vous pouvez les utiliser dans des opérations arithmétiques s'ils sont des entiers.
Vous suivriez les règles de ce type de données.
Donc, dans ce cas, nous pouvons en fait comparer cela en 12 en
utilisant simplement les égaux égaux à l'intérieur d'une instruction if.
Et puis, par exemple, s'il était égal à 12, nous pourrions dire que le mois prochain est égal à 1.
Cela peut être une variable locale que nous attribuerions.
Alors regardons un exemple. Ici, nous définissons une structure appelée date.
Nous avons trois éléments, des entiers: mois, jour et année.
Nous savons que nous le définissons parce que nous avons le mot-clé struct et que nous avons ces accolades.
Et puis notez également que l'accolade droite a un point-virgule pour terminer la définition.
À ce stade, aucune mémoire n'est allouée pour cette structure.
Dans la ligne suivante, nous déclarons en fait une variable de
ce type, donc nous allouons maintenant de la mémoire pour un nom de
variable qui contient essentiellement trois éléments: mois, jour et année de type int.
Nous pouvons attribuer des données à ces trois éléments à l'intérieur de cette structure
aujourd'hui en utilisant simplement cet accès de membre point.
Donc aujourd'hui. le mois est égal à neuf, aujourd'hui. jour est égal à 25 et aujourd'hui. année 2015.
Si nous voulions ensuite l'imprimer ou accéder à ces données, nous y accédions de la même
manière après l'avoir attribué. Nous utiliserions simplement cette sélection de membres: aujourd'hui. mois, aujourd'hui. jour
après jour. an. Et encore une fois, nous pouvons effectuer des opérations arithmétiques dessus car il s'agit d'un int.
Nous utiliserions pour cent d ou si nous voulons le formater à 2,
nous pourrions dire pour cent 2I ou pour cent 2D.
Il s'agit donc d'une syntaxe assez simple, très
facile à créer et à définir des structures, puis à les utiliser, puis
à y accéder à l'aide de l'opérateur de sélection de membre point.
Qu'en est-il des structures et des expressions?
Eh bien, vous venez de voir que je pouvais accéder aux données et utiliser une expression arithmétique et
ce n'est pas différent.
En ce qui concerne l'évaluation de l'expression, les
membres de la structure suivent les mêmes règles que les variables ordinaires.
Si vous avez des membres à l'intérieur de cette structure qui sont des entiers, vous
pouvez appliquer les mêmes règles à tout autre entier.
Vous pouvez appliquer des additions, des soustractions, etc. S'il s'agit d'un tampon de caractères, vous ne pouvez
appliquer que les règles des tampons de caractères. Pouvez-vous ajouter et réduire les tampons de
caractères, des choses comme ça, généralement pas.
Donc flotte, double, tous les différents types de
données, vous suivrez simplement ces mêmes règles lorsque vous utilisez ces membres à l'intérieur d'expressions.
Voici donc un exemple.
Dis-je aujourd'hui. années divisées par cent plus un.
Parfaitement valide car year est un entier,
pas différent de l'utilisation d'une variable régulière de type int.
Vous y accédez simplement différemment en utilisant cet opérateur de sélection de membres.
Maintenant, il existe des variantes. Il existe différentes manières de définir les structures.
Le seul avantage de c est sa flexibilité et c vous
permet de définir une structure de différentes manières. Ainsi, vous pouvez voir
une syntaxe différente lorsque vous définissez une structure.
Le premier exemple que je vous ai montré est vraiment celui que vous devez suivre. Vous devriez toujours avoir un nom de
balise, et vous devez définir la structure à un endroit de votre code, puis en déclarer
les variables dans un autre. Mais c étant tel
quel, c est très flexible. Vous pouvez en fait définir des structures et déclarer des variables dans la même ligne.
Et vous pouvez également définir des structures anonymes ou aucune structure nommée.
Il y a donc beaucoup de flexibilité. Il est valide de déclarer une
variable comme faisant partie d'une structure particulière en même temps que vous définissez réellement la structure.
Vous pouvez mettre le nom de la variable en bas. Je vais vous montrer comment faire ça.
Incluez le ou les noms de variable avant le point-virgule de fin de la définition de structure.
Et vous pouvez également affecter et initialiser des valeurs à ces variables de la manière
normale que vous affectez à des variables. Alors regardons ça.
Une variante de la définition d'une structure en le faisant en même temps que vous la
définissez, vous pouvez déclarer une variable. Donc, dans ce cas, nous
avons défini notre date de structure, mais nous avons également créé une variable appelée aujourd'hui.
Parce qu'à la fin de l'accolade droite, c'est le nom avant le point-virgule, cela fait à
la fois la création de la variable de type date struct et la définition de la struct date.
Donc, dans cet exemple ci-dessus, vous créez une
variable de la structure.
Nous nous référons à cela également comme une instance de la structure. Il s'appelle aujourd'hui.
Il est déclaré en même temps que la structure est définie.
Donc, aujourd'hui, c'est une variable de type date, nous avons tout fait en un seul.
Et vous pouvez en fait juste après avoir
fait le aujourd'hui, vous pouvez en fait initialiser ces variables en
utilisant les crochets, puis en disant
que le mois est égal à cinq, le jour est égal à et ainsi de
suite, tout comme vous initialisez tous les autres nombres entiers.
Encore une fois, une autre façon de créer une structure est
de créer une structure sans nom. C'est un peu plus limité car vous
ne pouvez pas en faire grand-chose.
Mais vous n'êtes pas obligé de fournir un nom de tag.
N'oubliez pas que le nom de la balise est en haut, juste après le mot-clé struct.
Dans les exemples précédents, le nom de la balise était date.
Mais vous n'êtes pas obligé de fournir cette date.
Si toutes les variables d'un type de structure particulier sont définies lors de la définition de la
structure, le nom peut être omis.
Et ce que cela signifie vraiment, c'est que vous n'utiliserez la structure
qu'une seule fois et une seule fois.
Nous pourrions donc simplement dire
struct int day, int year, int month, puis
déclarer la variable de la même manière.
Mais vous remarquerez qu'il n'y a pas de nom de balise après le mot-clé struct.
Ceci est juste une structure. Nous allons utiliser une seule
fois, donc nous créons la variable aujourd'hui et ensuite nous n'allons plus jamais l'utiliser.
Et c'est vraiment son inconvénient et sa limitation.
Vous ne voulez vraiment jamais faire cela à moins que vous n'ayez une sorte de structure locale que vous utilisez une fois.
Mais vous ne pouvez pas définir d'autres instances de ceci si vous
définissez la structure de cette
façon comme une structure sans nom, une structure sans nom.
Toutes les variables de ce type de structure que vous voulez pour votre programme doivent être définies dans une seule instruction.
Vous pouvez créer plus d'une variable, vous pouvez faire la virgule du jour,
puis une autre variable afin de pouvoir créer plusieurs variables.
Vous pouvez initialiser plusieurs variables.
Mais cette manière est un peu limitée car après cette
déclaration de variable en bas, vous ne pouvez plus créer de variables.
Il y a donc trois façons de définir différentes structures.
Une façon consiste à définir la structure avec un nom de balise
et non à créer la variable. Vous créez la variable dans une instance distincte lorsque la mémoire est allouée.
Une autre façon est de créer la variable et
la structure et en même temps où vous auriez
un nom de balise et cela
vous permettrait de créer d'autres instances ou d'autres variables de ce type de structure plus
tard dans votre programme ou cette troisième option où vous pourriez créer
une structure sans nom sans
nom et juste la variable en bas. Et encore une fois, vous pouvez initialiser tout
cela chaque fois que vous créez les variables en utilisant simplement les accolades et ainsi de suite.
Alors maintenant, initialisation des structures.
L'initialisation des structures est très similaire à l'initialisation des tableaux.
Les éléments sont répertoriés à l'intérieur d'une paire d'accolades,
chaque élément étant séparé par une virgule.
Pas de nouvelles choses à apprendre ici vraiment.
Les valeurs initiales répertoriées à l'intérieur des accolades doivent être des expressions constantes. Vous ne
pouvez pas utiliser de variables, cela ressemble à un tableau.
Ici, nous créons une variable today de type struct
date, et nous disons que le premier membre est égal à sept,
le deuxième à deux et le troisième à 2015, ce qui correspond au mois jour
de l'année car c'est l'ordre de la façon dont
ils ont été définis dans la structure.
Ainsi, tout comme une initialisation de tableau,
moins de valeurs peuvent être répertoriées que celles contenues dans la structure.
Vous n'êtes pas obligé de fournir les trois, vous pouvez
simplement en fournir deux et cela initialiserait le mois et le jour
et cela n'initialiserait pas l'année.
Donc, cela fixerait la date. une. mois
à 12 date1. jour à 10, mais il ne donne aucune valeur initiale à ce jour. an.
Vous pouvez également spécifier les noms des membres dans la liste d'initialisation de cette
façon, vous n'avez pas besoin d'avoir un ordre.
Vous pouvez les mettre dans l'ordre de votre choix et vous n'en dépendez pas.
Vous pouvez donc faire quelque chose comme. membre est égal à
valeur et date de structure, date un. Vous pourriez dire que le mois du point est égal à 12.
Donc, la syntaxe initiale de ceci est de définir le membre
à l'intérieur des accolades avec le point, puis d'attribuer simplement la valeur, point mois
est égal à 12 virgule point date égale 10.
Vous avez besoin de ce point. Ce point est important, alors n'oubliez pas ce point.
Vous n'avez pas besoin de l'instance avant le point.
Donc, cela va simplement définir le membre de l'année de la
variable de structure de date aujourd'hui à 2015 dans
cet exemple suivant.
Donc, ici, nous disons simplement parce que rappelez-vous que vous pouvez
omettre certaines des autres variables membres. Et dans ce cas, nous admettons
le mois du jour, nous allons donc simplement définir l'année 2015.
Dans le cas précédent, nous avons en fait omis l'année
et simplement défini le mois et la date à 12 et 10 respectivement.
Nous pouvons également faire des affectations avec des littéraux composés.
Eh bien, qu'est-ce que c'est exactement un littéral composé.
Vous pouvez affecter une ou plusieurs valeurs à une structure dans une seule
instruction en utilisant ce que l'on appelle un littéral composé.
Je pense que cela pourrait être uniquement en C11.
Mais ici, nous avons
aujourd'hui, supposons que nous avons créé une variable struct date
today, puis nous mettons en fait entre parenthèses struct date.
Et à l'intérieur des accolades, nous disons 9 virgule 25 virgule 2015.
Et c'est un littéral composé.
Cette déclaration peut apparaître n'importe où dans le programme.
Ainsi, par opposition à l'initialisation ou à l'affectation de valeurs à l'aide du membre
dot, vous pouvez le placer n'importe où dans le programme après avoir réellement
initialisé la structure d'aujourd'hui. Ce n'est pas une déclaration.
Il s'agit d'une affectation littérale composée.
L'opérateur de transtypage est utilisé pour indiquer au compilateur le type de l'expression.
Donc, vous avez besoin de ces choses entre parenthèses qui sont une date de distribution et de struct.
La liste de valeurs suit la distribution
et doit être affectée aux membres de la structure dans cet ordre, elle dépend de l'ordre.
Il est donc répertorié de la même manière que si vous initialisez une variable de structure.
Encore une fois, l'avantage de ceci
est que vous n'avez pas à affecter chaque variable membre individuellement sur des lignes distinctes.
Vous pouvez tout faire en une seule ligne et dire d'accord, c'est la nouvelle
valeur de cette variable aujourd'hui.
Vous pouvez également spécifier des valeurs en utilisant la notation de membre point comme je l'ai mentionné.
Vous auriez juste à le faire en une seule ligne comme
celle-ci ou sur des lignes séparées. Et de cette façon, cela ressemble à l'initialisation,
mais vous faites toujours les littéraux composés.
L'avantage d'utiliser cette approche est que les arguments peuvent apparaître dans n'importe
quel ordre, donc comme précédemment.
Encore une fois, la clé et la différence de ces affectations est que
cela ne se produit pas lors de
l'initialisation, vous le faites ailleurs dans le programme pour attribuer de nouvelles valeurs à ce type.
Donc, beaucoup de bonnes informations dans cette conférence.
Nous avons parlé des structures et de leur puissance et de la manière dont nous
pouvons regrouper différents éléments ou différentes variables en un seul nom.
Nous définissons cette structure. Il existe différentes manières de définir une structure.
Et puis nous devons également déclarer une variable.
Une fois que nous avons cette variable, nous pouvons
accéder et affecter des données à cette structure à l'aide de l'opérateur de sélection de membre point.
Et puis nous discutons également de certaines des différentes notations
et des différentes manières de faire les choses ainsi que de l'initialisation.
Nous allons utiliser un peu les structures.
J'aurai quelques défis qui vous aideront à vous familiariser avec cette syntaxe.
Mais ce n'est que le début de la structure. Nous devons également parler
de structures imbriquées, comment vous pouvez utiliser des pointeurs et des
structures et des choses comme ça.
Alors bonne chance, ce sera une section amusante et excitante. Merci.