Bonjour et bienvenue à nouveau.
Je souhaite apporter une solution à défi précédent dans cette conférence.
Une démonstration de la façon dont vous peut avoir des pointeurs comme éléments à l'intérieur
de la structure et aussi faire passer des pointeurs deux fonctions
qui sont des structures.
Alors parlons du code blocs, créez un nouveau projet.
Ça va être une console application, et nous allons nommer
cet exemple de pointeurs de structure.
Et donc si vous vous souvenez de la exigences
pour cela, il s'agissait essentiellement d'un type de produit structure qui stockait un nom d'article, une quantité,
un prix et un montant.
Et le nom de l'élément allait être un pointeur de caractère.
Tu allais avoir un montant qui a simplement multiplié
la quantité en prix.
Et puis nous avons eu deux fonctions qui prendra comme paramètres
des pointeurs vers une structure.
Alors la première chose que nous va faire est
que nous allons créer notre structure.
Et je l'ai mentionné plus tôt, mais il est
bon de créer la structure globalement car si vous voulez utilisez-le dans plusieurs fonctions.
Créer la structure le définit vraiment.
Vous n'allouez aucune mémoire.
Donc il n'y a pas de mal en le mettant globalement.
Et ils vont généralement à l'intérieur le fichier d'en-tête de toute façon.
Alors pour créer une structure, nous disons simplement struct.
Nous allons appeler cet élément, et nous allons avoir quatre éléments.
Nous allons avoir un personnage pointeur, que nous allons simplement appeler
le nom de l'élément.
Nous allons avoir une quantité.
Nous allons avoir un flotteur pour le prix, et nous allons avoir
un flottant pour le montant.
Et c'est ainsi que nous pouvons définir notre structure, assez basique.
Maintenant à l'intérieur de notre fonction principale, nous souhaitez créer une variable pour le type de structure et
également un pointeur.
Alors la première chose que nous voulons faire est-ce que nous voulons juste dire struct item avec
le nom de la structure et alors nous appellerons simplement cet élément.
Et c'est juste créer un pointeur étrange.
Cela va allouer de la mémoire pour les quatre variables et éléments à
l'intérieur de la structure.
Et donc nous voulons créer notre pointeur maintenant, et nous pouvons simplement dire struct item.
Nous allons dire p élément car nous nommons généralement nos
pointeurs avec le préfixe p.
Alors on dit l'astérisque, et nous disons p item.
Et puis dans la ligne suivante,
nous voulons simplement attribuer à notre élément de pointeur, notre élément.
Nous devons donc utiliser le adresse de et nous disons article.
Et donc ici nous avons la mémoire alloué pour les éléments de notre structure
pour notre pointeur.
Nous n'avons pas de mémoire alloué pour notre pointeur de caractère
qui est le nom de notre élément, ce serait donc la prochaine étape.
Maintenant, vous pouvez demander pourquoi avons-nous besoin pour créer la structure d'élément.
Nous n'avons pas vraiment.
Nous pourrions simplement créer le pointeur, et le pointeur va uniquement créer de la mémoire pour
ce pointeur d'élément de structure.
Il allouera de la mémoire pour le int
et floats, mais nous devons encore faire l'allocation de nom d'élément.
J'aime juste faire ça parce que c'est généralement la bonne pratique.
Typiquement, ce que vous feriez avec le premier élément struct est que
vous l'initialisiez, et donc aurait une certaine initialisation.
Mais nous n'avons pas besoin de faire cela.
Donc, la première chose que nous voulons faire est allouer de la mémoire pour le nom de notre élément.
Nous pouvons donc utiliser un opérateur spécial pour accéder aux éléments s'il
s'agit d'un pointeur.
Rappelez-vous, pour les structures qui sont des pointeurs, vous avez le tiret alors plus grand
que le symbole que vous peut utiliser pour accéder aux éléments.
Sinon, vous devrez dé-référencer le pointeur pour accéder aux éléments.
On pourrait faire quelque chose comme ceci entre parenthèses.
On pourrait dé-référencer le pointeur, il
faudrait donc faire quelque chose comme l'élément star p, puis utiliser le point pour accéder aux éléments.
C'est parfaitement valable faire quelque chose comme ça.
Mais c'est une sorte de syntaxe supplémentaire dont vous n'avez pas vraiment besoin.
Donc c a une syntaxe spéciale qui vous pouvez utiliser chaque fois que votre structure
est un pointeur si vous veulent accéder aux éléments.
Vous pouvez simplement dire le nom du pointeur qui est p item puis utiliser
le tiret alors supérieur à.
Et dans ce cas, nous voulons allouer de la mémoire pour le nom de l'élément.
Nous allons donc lui attribuer ce qui est renvoyé par la fonction malloc.
Rappelez-vous, la fonction malloc renvoie un pointeur vide.
Alors nous devons le lancer à une étoile de caractère.
Mais on peut juste appeler malloc, juste dites malloc et ensuite la taille des
octets que nous voulons créer.
Dans ce cas, nous dirons simplement 30, et nous le multiplierons par la taille de char,
juste au cas où char serait un taille différente sur différents ordinateurs.
Et cela va allouer mémoire pour le nom de notre article.
Nous devons le faire car le nom de l'élément est un pointeur à l'intérieur de la structure.
Il n'a pas de mémoire qui lui est attribué
lorsque vous l’affectez à une autre structure.
Nous devons donc le faire.
Maintenant la première chose que tu veux à
faire après avoir alloué la mémoire est de vérifier le malloc.
nous voulons donc vérifier la valeur nulle ici.
Nous allons juste dire si p élément, si c'est nul qui dirait qu'il est nul.
Sinon, tu dirais que si non, tu pourrais dites simplement que le retour ou la sortie serait probablement mieux, quittez le programme si
nous n'ont pas été en mesure d'allouer de la mémoire et vous pourriez
la passer en négatif.
Sinon, nous voulons lire dans un item, nous voulons donc créer une fonction.
La fonction que nous allons créer est appelé élément lu.
Mettons en place une déclaration de fonction ici au-dessus de la structure.
Ça va juste lire des données dans la structure que nous lui avons passée.
Il ne renverra aucune donnée.
Donc nous pouvons simplement dire lire l'article et cela prend une structure, et ça va être un
pointeur.
C'est donc un élément struct, l'astérisque I.
Maintenant, nous pourrions en faire une constante donc les valeurs changent en quelque
sorte, mais nous changeons les valeurs.
Mais nous pourrions dire une structure constante, le les valeurs ne pourraient pas changer pour
ce pointeur vers lequel il pointe.
Si nous faisions la constante après l'astérisque, cela voudrait dire que l'adresse ne peut pas changer
ou corriger avant l'astérisque quelque chose comme ça après
le nom.
Cela voudrait dire que l'adresse ne peut pas change,
mais c'est redondant car nous passons par valeur de copie.
Nous avons notre article lu.
Et pendant que je suis ici, je pourrais ainsi faire mon article d'impression.
Ce sera juste la fonction déclaration, prototype de fonction.
Ici, ça va être très similaire, prenez également un pointeur.
Peut avoir un espace si tu veux après l'astérisque ou pas?
Maintenant, nous pouvons définir notre lecture article ci-dessous notre méthode principale.
Et cela va lire en valeurs de l'article, puis
calculez le montant total.
Donc on peut dire nul lire article, ayez notre pointeur.
Et à l'intérieur ici, nous voulons juste pour vraiment utiliser certains scanfs.
Nous allons imprimer quelques messages pour dire à l'utilisateur d'entrer des informations.
Alors nous allons dire entrer nom du produit, puis nous allons le
lire.
Alors on va dire scanf, et nous avons un pointeur vers une structure, donc nous pouvons y
accéder en utilisant le tiret alors supérieur à.
Nous voulons lire pour scanf, le le nom du produit est un tampon de caractères.
Nous voulons donc dire pour cent s et alors nous allons dire je, nous allons le stocker dans
le nom de l'élément.
Et nous pourrions revenir en arrière et utiliser le intellisense va simplement au nom de l'élément.
Nous n'avons pas besoin d'utiliser le adresse de l'opérateur car c'est
un pointeur de caractère.
Nous voulons ensuite imprimer et obtenir le prix,
vous voulez probablement ajouter des sauts de ligne ici, entrez le prix.
Nous allons stocker que dans la structure.
Encore une fois, le prix est un flottant.
Alors je vais dire pour cent f, mais nous allons également y accéder car c'est un pointeur, nous voulons
toujours utilisez le tiret alors supérieur à.
Sauf que cette fois, nous allons dire le prix, et nous devons obtenir l'adresse de celui-ci, alors nous allons
mettez une esperluette devant elle car le prix n'est
pas un indicateur.
Et puis nous allons faire le même chose pour la quantité.
La quantité est donc un entier.
Donc nous pouvons dire pour cent d, nous avons encore besoin pour obtenir l'adresse
de celui-ci, mais nous voulons le stocker dans un élément différent, nous voulons le stocker dans la quantité.
Maintenant que nous avons stocké ou demandé l'utilisateur pour entrer
trois éléments d'information, maintenant nous pouvons effectivement calculer le montant, stocké quelque chose
dans le montant.
Le montant est juste le quantité multipliée par le prix.
Nous voulons donc toujours accéder au structure utilisant notre syntaxe, nous voulons la
transtyper, nous voulons signer la quantité multipliée par le prix.
Et c'est la fonction de lecture d'élément.
Prend un pointeur de structure.
Et donc quand on modifie ce pointeur à l'intérieur de l'élément lu, il va
être modifié en dehors de la fonction.
Quelle que soit la structure que nous passer dans cette fonction, il
va être modifié.
Il va stocker tous les articles, le nom de l'article, le prix,
la quantité et le montant.
Cela lit les données.
À ce stade, vous voudriez test et vous voudrez probablement
compiler et tester avant cela.
Mais nous pouvons maintenant appeler l'élément lu méthode dans notre main et passez-la dans
notre structure que nous avons créée.
Nous pouvons donc dire lire l'article, et nous pouvons simplement dire p item.
Nous n'avons pas à passer dans le adresse parce que c'est un pointeur,
donc nous passons simplement dans notre structure.
Et puis la prochaine chose que nous peut faire est que nous pouvons l'imprimer.
Et ce que cela vous montrera est que les données sont sauvegardées, p élément est en cours
de modification à l'intérieur de la fonction et il est enregistré en dehors de la fonction, la
fonction principale a en fait enregistré ces valeurs.
Nous pouvons donc dire que l'article d'impression passe dans le pointeur à nouveau, puis nous pouvons définir la
fonction d'élément d'impression.
L'élément imprimé est assez basique.
Ça ne renvoie rien, nous disons donc void et nous
disons que l'élément d'impression prend un pointeur.
Donc nous disons simplement struct item star Moi, peu importe comment tu veux le nommer.
Et puis nous imprimons simplement les données pour la structure qui a été transmise.
Donc nous ferions quelque chose comme printf name pourcentage s, I nom de l'article, I
prix, I quantité et I montant, puis nous formaterons les données.
Quelle est la dernière chose que nous
avons à faire dans l'ensemble après avoir imprimé les données, le fonction gratuite vraiment importante.
Nous devons appeler gratuitement parce que nous veulent libérer la mémoire que nous avons allouée
pour le nom de l'élément.
Nous pouvons donc simplement dire p item gratuit puis accédez au nom de l'élément.
Nous ne voulons pas libérer le tout structure
car toute la structure sera supprimée sur le pile au retour de la fonction.
Nous voulons juste libérer ce que nous avons malmené.
Nous avons seulement mallocé pour l'article nom afin que nous libérons cela, puis
nous revenons de la principale.
Alors allons-y et essayez de construire cela.
Et nous avons une erreur.
Voyons cela dit étoile de l'élément struct.
Nous avons donc eu une erreur où les fonctions ont été définies au-dessus de
la structure.
Mais la fonction de prendre un paramètre en tant que type struct.
Nous devons donc avoir la structure défini ci-dessus où nous l'utilisons.
Alors je déplace les fonctions jusqu'aux lignes 12 et 13.
Maintenant, nous sommes en mesure de compiler.
Allons-y et exécutons ceci.
Et voyons ce que nous obtenons ici.
Nous avons encore une erreur.
Vous devez vous assurer que vous vérifier l'élément p pour null.
Si vous dites simplement si p élément pour vrai, ça va toujours être vrai.
Donc vous pouvez soit vérifier pour dire ce n'est pas vrai avec le
symbole non signifiant que ce n'est pas nul ou vous peut vérifier s'il est nul.
Je viens donc d'ajouter le nul là-bas.
Alors maintenant, nous le gérons, nous devrait être prêt à partir.
Nous pouvons entrer le nom du produit.
Nous dirons série, et nous disons que le prix est de 1. 99.
Et nous dirons que nous en avons cinq.
Et maintenant nous l'imprimons, et nous disons 99 dollars de série.
5, le montant total est de 9. 95.
Le prix même si je n'aime pas comment le prix est imprimé.
Alors corrigeons ça.
Dans notre article imprimé, nous pouvons simplement dire pour prix dor 2 f flotteurs, maintenant
nous allons regarder un peu mieux, et nous l'exécutons.
Nous aurons un peu un peu de meilleur format.
Quatre d'entre eux et maintenant il semble un peu mieux,
et tout va bien.
Encore une fois, programme de base utilisant structures et pointeurs.
Nous avons créé la structure au sommet.
Nous avons un membre qui contient un pointeur, c'est très efficace
de le faire car on peut juste copier et adresses par opposition
aux tableaux de caractères.
Nous avons nos deux déclarations func, lire l'élément d'impression d'élément qui
prend des destructions de pointeurs.
Et puis nous créons le pointeur et attribuez-le à une structure régulière à
l'intérieur de notre main.
Nous allouons de la mémoire à la ligne 22.
Nous nous assurons que la mémoire est alloué avec succès si ce n'est pas le
cas, nous quittons le programme.
Et puis nous appelons nos deux fonctions qui prennent des
pointeurs vers des structures, les transmettent.
Et puis last but not least, on libère la mémoire puis on
quitte le programme.
Et les fonctions sont assez simple.
Vous prenez ce pointeur.
Vous accédez au pointeur en utilisant le tiret alors supérieur à.
Et vous obtenez l'adresse de il pour les scanfs qui n'ont
pas de pointeurs comme éléments.
Et c'est fondamentalement ça.
Je vais sauvegarder ce programme, vous y jetez un œil.
Faites moi savoir si vous avez des questions. Merci.