Bonjour et bienvenue à nouveau. La dernière chose dont je veux parler concernant
les structures est de savoir comment elles sont liées aux fonctions, comment
vous pouvez passer des structures en tant qu'argument à un paramètre et à une fonction et comment
cela est également plus efficace.
Donc les structures comme arguments de fonctions.
Après avoir déclaré une
structure nommée Family. Dans cet exemple, nous allons créer
une famille nommée, comment passer cette structure en tant qu'argument à une fonction.
Nous avons donc cette structure appelée Famille.
Nous avons un tas de tableaux de caractères
ici nom, père et mère et puis nous avons un âge int.
C'est notre définition de structure.
Nous savons que c'est une structure parce que le mot-clé struct est là, suivi du nom de la
balise, nous avons nos accolades et ainsi de suite.
Maintenant, comment passons-nous réellement cette structure à une
fonction appelée frères et sœurs?
Eh bien, vous le feriez comme vous déclarez la structure,
vous diriez le type comme nom de paramètre.
C'est vraiment simple. Donc, dans ce cas, nous avons des frères et sœurs booléens.
Siblings renvoie un booléen.
Et cela prend deux paramètres, deux paramètres struct.
Vous devez identifier le type struct qui est le type struct family.
Maintenant, dans un c plus avancé, vous pouvez en
fait faire un typedf sur cette structure et lui donner un autre nom et vous pouvez
raccourcir le nom ici, mais nous n'avons pas parlé de typeds.
Ce serait probablement mieux.
Mais c'est vraiment ainsi que vous auriez besoin de le faire. Vous devrez définir le type entier, qui
est la famille struct, puis le nom de la variable, comme tout autre paramètre.
Nous passons donc ici deux paramètres, le membre un et le membre deux.
Ils sont tous les deux de type struct family.
Ensuite, à l'intérieur de notre fonction, si nous voulons accéder aux membres, nous
accédons aux membres comme d'habitude.
Membre un et membre deux, ce ne sont pas des pointeurs, donc nous n'utilisons pas le tiret supérieur à, nous ne
le faisons que sur les pointeurs parce que nous devons les dé-référencer pour voir vers quoi ils pointent.
Parce qu'ils ne sont pas des pointeurs, nous pouvons simplement faire des points. Donc, le membre one dot mother, le membre two dot mother.
La mère à un point et la mère à deux
points sont des tableaux de caractères et les tableaux de caractères sont essentiellement des pointeurs.
Nous pouvons donc les transmettre au str compare. Str compare va retourner des égaux s'ils sont identiques, donc ce
que nous faisons ici, c'est que nous vérifions que le membre un
mère et le membre deux mère sont les mêmes. Et s'ils le sont, nous reviendrons vrai.
Parce que s'ils ont tous les deux le même nom et
que ce serait vraiment le nom de famille, ils sont frères et sœurs.
Assez simple.
Facile à passer des arguments
aux fonctions tant que la déclaration de fonction contient ce type struct.
Donc cette fonction, encore une fois, deux paramètres dont chacun est une structure
de type famille.
Et si nous voulons avoir des pointeurs vers des structures comme arguments de fonction.
Et je l'ai mentionné plus tôt, c'est mieux à faire parce que nous
faisons passer par valeur et c.
Lorsque vous passez par valeur, vous copiez.
Si vous avez une structure qui contient beaucoup de
données, beaucoup de grandes structures comme arguments, vous
devez copier tout ce qui se trouve dans cette
structure dans la fonction réelle.
Cela pourrait donc prendre un certain
temps pour copier ces grandes structures.
Eh bien, si vous avez un pointeur, tout ce que vous avez à faire est
de copier l'adresse qui est beaucoup plus rapide. Ainsi, des pointeurs vers des
structures sont utilisés comme paramètres et fonctions pour éviter la consommation
de mémoire et le temps nécessaire pour copier toutes les structures.
Maintenant, si vous avez une petite structure, ce n'est pas
grave, mais que vous voulez vraiment utiliser des pointeurs et des structures de grande taille.
Donc dans ce cas, que faites-vous, vous spécifiez toujours le nom des types de structure,
il vous suffit de mettre l'astérisque
au préalable, très simple. Et si vous ne souhaitez
pas que l'une des données à l'intérieur de la structure change, vous pouvez utiliser une constante avant le type de structure.
Si vous ne voulez pas que l'adresse change, vous placez la constante après le pointeur de la famille struct.
Mais ici, nous faisons la même chose. Mais maintenant, nous allons y
accéder différemment car maintenant qu'il s'agit d'un pointeur, nous pouvons utiliser le tiret
supérieur à, ce nouveau symbole pour accéder au lieu d'utiliser le point.
Nous n'avons pas besoin d'utiliser le point ici. Parce que rappelez-vous,
les pointeurs que vous devez d'abord dé-référencer donc vous devez les mettre entre parenthèses, c'est plus
une syntaxe pour dé-référencer le pointeur que vous devez mettre le point en dehors de la parenthèse car
il a une priorité plus élevée, beaucoup plus facile à utiliser le tiret que supérieur à.
Dash et plus grand que mère, dash et plus
grand que mère, ils sont tous les deux des pointeurs, ils peuvent être passés dans la comparaison de str.
S'ils sont identiques, renvoyez true. Sinon, retournez false, assez simple.
Vous pouvez également utiliser le modificateur const comme je l'ai
mentionné si vous ne souhaitez autoriser aucune modification des membres de la structure.
Sur quoi pointe la structure, vous placez le const avant le pointeur.
Vous pouvez également mettre le const avant la famille.
Dans ce cas, la famille a un typef.
Donc, ici, il s'agirait
vraiment de construire une famille ou de structurer un pointeur de famille de const.
Et puis à nouveau accéder de la même manière, vous ne modifiez rien. Alors vous êtes prêt à partir.
Le compilateur ne va pas se plaindre.
Vous pouvez également utiliser le modificateur constant si vous ne souhaitez autoriser
aucune modification de l'adresse elle-même.
Toute tentative de modification de ces structures provoquera un message d'erreur lors de la compilation.
Donc, ici, vous diriez étoile
de la famille et vous mettez la constante après l'étoile.
Et ce que cela signifie, c'est que vous ne
pouvez pas changer la valeur de p-member, la valeur du pointeur, qui est une adresse.
Mais encore une fois, ce n'est pas très utile
car lorsque vous passez par valeur, vous passez en fait une copie de l'adresse.
C'est donc redondant, vous n'avez pas besoin de le faire, mais vous le pouvez.
Et là encore, vous voulez pouvoir changer l'adresse de ce qu'est p membre.
Et dans ce cas, vous accédez de toute façon aux données pour voir si elles sont égales.
L'opérateur d'indirection dans chaque définition de paramètre est maintenant
devant le mot-clé constant.
Cet astérisque, ce n'est pas devant le nom du paramètre.
Vous ne pouvez pas modifier l'adresse stockée dans les pointeurs car elle se trouve après l'astérisque.
S'il se trouvait devant le type de nom de
paramètre, vous voulez pouvoir modifier le réel vers lequel il pointe.
Si nous avions cet opérateur d'indirection devant le nom du paramètre, ce que cela ferait dans la
constante qui le précède, cela voudrait dire
que vous voulez pouvoir modifier ce vers quoi il pointe. C'est juste dire l'adresse.
Vous ne pouvez donc pas modifier l'adresse stockée dans les pointeurs.
Ce sont les pointeurs qui sont protégés ici et non les
structures vers lesquelles ils pointent, tout comme les paramètres de pointeurs constants et autres, aucune différence avec les structures.
Si vous souhaitez renvoyer une structure à partir d'une fonction qui est
un pointeur, le prototype de fonction doit indiquer cette valeur de retour de la
manière normale dans la déclaration.
Donc, ici, vous devriez dire frappé à ce
jour mon pointeur amusant
ou non, ce n'est pas grave. Il s'agit d'un prototype de fonction ne prenant aucun argument qui retourne une
structure de type date, très simple pour renvoyer une structure à partir d'une fonction. Et quelle en est la valeur.
Eh bien, nous pouvons maintenant renvoyer plus
d'un élément ou un élément de données à partir d'une fonction.
Si vous retournez une structure, vous pouvez renvoyer 10 valeurs, 10 éléments de données différents.
À quel point cela est cool. La structure vous permet d'en renvoyer plusieurs à partir d'une fonction.
Très, très précieux.
Il est donc souvent plus pratique de renvoyer un pointeur vers une structure plutôt que vers la structure uniquement.
Lorsque vous renvoyez un pointeur sur la structure, il est créé sur le tas car
tous les pointeurs sont créés sur le tas.
Cela signifie que cela durera un peu plus longtemps.
Et cela signifie que vous pouvez le supprimer et le gérer à des moments arbitraires.
Donc, dans cet exemple, nous créons une structure nommée fonds.
Il contient un tableau
de caractères nommé banque, contient un double, un autre
caractère nommé sauvegardé d'une longueur particulière. La longueur du plaisir juste supposée est égale à 50.
Et puis il en a un double sauvé.
Nous avons une fonction appelée sum qui prend cette structure comme paramètre.
Et tout ce que nous faisons, c'est que nous retournons
un - le fonds bancaire de la première structure plus le fonds d'épargne, et
cela va retourner le montant qu'ils ont dans leur banque.
Dans cet exemple, la somme est juste un double.
Nous ne renvoyons pas de pointeur. Nous prenons simplement un pointeur comme paramètre.
Et donc dans notre fonction principale, nous créons une variable de
structure appelée stan de type struct funds.
Nous l'initialisons avec quelques valeurs, puis nous imprimons le total
de la somme d'appel. Et nous passons simplement cette structure comme nous passons n'importe quelle variable.
Nous n'avons pas à le dé-référencer, ce n'est pas un pointeur. Nous n'avons rien à faire de spécial.
Nous nous assurons simplement que dans la déclaration de fonction, nous avons ce type de structure,
mais tout le reste semble normal.
Quelques rappels.
J'ai mentionné plus tôt que vous devriez toujours utiliser des pointeurs lorsque vous passez des structures à une fonction.
Pourquoi? Parce que rappelez-vous, les anciennes versions
de c n'autorisent
pas le passage de structures, mais elles autorisent les pointeurs.
Ainsi, vous pouvez éviter toute sorte de compatibilité ascendante.
Si vous utilisez une ancienne version de c, votre programme fonctionnera.
Donc, le simple fait de passer cette adresse
unique est également plus efficace en raison de la copie temporelle.
Mais si vous faites cela, si vous passez un paramètre qui est un pointeur
vers une structure à l'intérieur d'une fonction, il a moins de protection pour vos données.
Ainsi, certaines opérations de la fonction appelée peuvent affecter par inadvertance les données
de la structure d'origine.
Et c'est là que vous souhaitez utiliser le qualificatif const.
Et vous utiliseriez le const avant le
type réel, pas après l'astérisque et avant le nom
du paramètre, avant le type.
L'avantage de passer des structures est des arguments, la
fonction fonctionne avec des copies des données d'origine.
C'est plus sûr que de travailler avec les données d'origine.
C'est donc vraiment la seule fois où vous voulez passer une structure comme argument qui n'est pas un pointeur.
Et le style de programmation a tendance à être un peu plus clair.
Les principaux inconvénients de la transmission de structures en tant qu'arguments par opposition à la transmission
d'un pointeur structuré en tant qu'argument sont que les
implémentations plus anciennes peuvent ne pas gérer le code, cela
fait perdre du temps et de l'espace
et c'est particulièrement inutile lorsque vous avez de grandes structures, nous devons faire beaucoup
de copie pour chaque membre. Alors gardez cela à l'esprit.
Pour la plupart, vous souhaitez passer des pointeurs vers
des structures, beaucoup plus efficaces et permettant de gagner du temps.
Les programmeurs utilisent des pointeurs de structure comme arguments de fonction pour des raisons d'efficacité
et ils utilisent constant si nécessaire. Et c'est la combinaison que vous voulez faire.
Si vous êtes inquiet pour la protection, utilisez simplement le pointeur
de fonction pour plus d'efficacité, puis utilisez
le const const pour que rien ne se fausse
dans la fonction, tout comme les pointeurs vraiment normaux
plus ou moins, mais avec les pointeurs, c'est encore plus important avec l'efficacité
car de grandes structures.
La transmission des structures par valeur se fait le plus souvent pour des structures de petite taille,
et ce sont les règles auxquelles vous voulez penser.
OK pour passer une structure qui n'est pas un pointeur tant qu'elle est petite.
Encore une fois, certains concepts importants liés aux structures
et au passage de pointeurs en tant que
paramètres, arguments et pointeurs de retour. Maintenant, nous pouvons réellement commencer à mettre en œuvre
certains de ces éléments. Nous fournissons de nombreux exemples. Nous comprenons les concepts. Nous comprenons la syntaxe.
Maintenant, je veux vous présenter quelques défis qui vous obligent à faire cela, avez-vous mémorisé dans la syntaxe
que maintenant, si vous voulez un jour créer une structure dans le programme, vous savez comment le
faire comme le dos de votre main.
Nous allons donc avoir quelques défis dans nos prochaines
conférences pour vous familiariser avec tout ce dont nous avons parlé concernant les structures.
Merci.