Bonjour et bienvenue à nouveau. Dans cette conférence, je veux fournir une
démonstration de
notre défi précédent, qui consistait à vous faire comprendre comment allouer de
la mémoire de manière dynamique à l'aide de malloc.
Nous allons simplement faire une lecture simple à partir du clavier,
puis afficher une chaîne, mais nous allons l'utiliser
avec des pointeurs alloués dynamiquement, des
pointeurs de caractère.
Alors faisons apparaître des blocs de code pour créer un nouveau projet.
Et nous allons simplement nommer cet exemple d'allocation de mémoire dynamique.
Et la première chose que vous devez faire
lorsque vous allez utiliser l'allocation de mémoire dynamique est de vous assurer que vous incluez la bibliothèque standard.
Heureusement, lorsque vous créez un projet dans des blocs de
code, il l'inclura automatiquement pour vous.
Mais la raison pour laquelle nous devons inclure la bibliothèque standard est que malloc,
la fonction malloc est là. Et malloc, rappelez-vous, est la fonction
principale d'allocation de mémoire. Vous avez également calloc.
Calloc est vraiment important car calloc effectuera
une partie du calcul agréable du nombre d'octets dont vous avez
besoin car ce sont deux paramètres.
Mais la vraie bonne chose à propos de calloc est qu'il initialise toutes les données à
des zéros si ce sont des entiers et ainsi de suite, fonction vraiment sympa.
Vous avez une réallocation. Realloc étendra la mémoire
déjà allouée. Donc, vous le passez dans un pointeur.
À partir de ce pointeur, il détermine la quantité de mémoire qui
lui est allouée et copie tout ce qui s'y trouvait dans un nouvel emplacement
de mémoire, puis vous spécifiez également le nombre d'octets
supplémentaires que vous souhaitez allouer, il l'ajoute simplement au nouvel emplacement de mémoire, vraiment belle fonctionnalité.
Mais rappelez-vous que lorsque vous allouez de la mémoire pour des entiers à l'aide de
malloc, vous devez déterminer la quantité de mémoire que vous souhaitez allouer des
octets, mais vous souhaitez généralement utiliser l'opérateur sizeof.
Alors, allons-y ici.
Dans ma méthode principale, je vais créer un entier, et je vais juste
dire que ce sera juste la taille. va entrer la taille du nombre d'octets
qu'ils veulent allouer au moment de l'exécution, donc cela va stocker la taille.
L'autre chose que je veux créer est que je veux créer un pointeur de caractère,
et ce sera juste du texte. Et je vais initialiser ceci
à null car il ne pointe vers rien dès le départ.
Maintenant, la première chose que je veux faire est de demander à l'utilisateur d'entrer la taille.
Je vais donc dire
printf, je vais dire entrer la limite du texte.
Et ils vont entrer un nombre pour combien d'octets veulent être alloués
réellement le nombre de caractères.
Et puis je vais lire cela en utilisant scanf.
Scanf, le premier paramètre est le type du spécificateur de format pour le type des données.
Cela va être pour cent d parce que je lis un entier.
Et puis rappelez-vous, scanf prend un pointeur.
Nous savons maintenant que les fonctions
qui prennent des pointeurs, vous avez besoin d'une adresse pour passer.
Donc si je vais passer en taille, la taille n'est pas une adresse à moins que j'utilise l'adresse de l'opérateur.
Je vais donc faire une esperluette et je
vais dire la taille, qui va se lire en nombre d'octets.
Une fois que j'ai le nombre d'octets, je peux maintenant lui allouer de la mémoire en utilisant la fonction malloc.
Et malloc va renvoyer un pointeur vide.
Et le pointeur sera la première adresse pour
cette mémoire nouvellement allouée. Vous pouvez donc l'attribuer directement au texte.
Parce que rappelez-vous, le texte est un pointeur.
Nous voulons pointer le texte vers cette nouvelle adresse qui est renvoyée.
Parce que malloc renvoie un pointeur vide, nous devons le lancer.
Le type de données que nous pointons est un caractère, nous voulons donc dire char
star, puis nous pouvons appeler la fonction malloc.
La fonction malloc prend le nombre d'octets.
Et donc le nombre d'octets, si vous venez de passer le nombre d'octets, cela
n'allouera que ce nombre d'octets. Mais selon le type de données,
le type de données peut être de deux ou quatre octets.
Donc, si vous souhaitez allouer 10 caractères, vous
voulez vous assurer de multiplier
10 caractères par la taille de char.
Alors maintenant, nous
allons dire n fois sizeof. L'opérateur sizeof est souvent utilisé dans la fonction
malloc car il est indépendant de
la machine, et il vous indiquera combien vous devez réellement allouer.
Maintenant, cela est plus pertinent lorsque vous avez des entiers. N'oubliez pas, les entiers, selon le
système sur lequel vous êtes, l'architecture que vous exécutez, les
entiers peuvent être représentés par quatre octets, deux octets, généralement
deux ou quatre octets.
Si vous deviez dire que je veux stocker un entier, donc je
vais juste créer quatre octets de mémoire, eh bien, ce n'est peut-être pas correct,
car que se passe-t-il si c'est deux octets.
Donc, vous voulez toujours
faire combien d'entiers ou combien de caractères vous voulez créer, puis multiplier cela par
la taille du caractère sur votre système. L'opérateur Sizeof vous donnera le nombre
d'octets qu'un caractère occupe. Donc, si vous voulez créer 10 caractères,
vous dites 10 fois la taille du caractère. Si vous voulez créer 10
entiers pour stocker 10
entiers, vous dites 10 fois la taille de int, c'est vraiment important.
Maintenant, avec la fonction calloc, vous n'avez pas à faire cela. Calloc prend
en fait deux paramètres. Et le premier paramètre
est le pointeur, je pense, puis le
deuxième paramètre est la taille des octets.
Donc, si vous dites 24 int, alors tout ce que vous faites est de passer
en seulement 24 et d'attribuer automatiquement pour vous.
Calloc est donc un très bon outil à utiliser car vous n'avez pas à faire cette multiplication.
Donc, pour calloc, le premier paramètre est la taille.
Donc, si vous vouliez créer 10 int, vous passeriez simplement 10.
Et puis le deuxième paramètre est
la taille de l'octet. Vous n'avez donc pas à faire la multiplication. Cela vous fait gagner un peu de temps.
Maintenant que nous avons alloué de la
mémoire, vous voulez vous assurer que le texte n'est pas nul avant d'essayer de dé-référencer le texte.
Donc, vous voulez toujours envelopper cela autour d'un texte non, et cela dira que ce
n'est pas nul ou vous pouvez simplement le faire explicitement et dire si
le texte n'est pas égal à null.
Je veux toujours faire cela parce qu'il est très,
très dangereux d'essayer de dé-référencer un pointeur.
Tout peut arriver. Vous pourrez peut-être y écrire des données.
dans ça. Il l'écrirait simplement ailleurs en mémoire. Donc, cela
gâcherait votre programme ou vous pourriez avoir une erreur de segmentation et le programme pourrait planter.
Mais tant que vous allouez réellement cette
mémoire, vous pouvez désormais lire certaines données.
Vous pouvez utiliser git s ou vous pouvez utiliser scanf ici.
Mais ce que vous voulez faire,
c'est que vous voulez imprimer, entrer du texte
et nous voulons également ajouter des sauts de ligne ici pour qu'ils soient faciles à lire.
Et nous utiliserons scanf puisque c'est ce que nous connaissons.
Et scanf va juste lire en
pourcentage.
En fait, je vais vous montrer un truc.
Je vais utiliser scanf pour lire le caractère suivant afin
qu'il s'arrête, puis je vais utiliser get s pour lire dans le texte.
Et gets est juste une autre fonction que vous pouvez généralement utiliser le f gets. Il vous suffit de le définir pour le
définir sur le flux d'entrée.
Mais obtient va lire à partir du flux d'entrée standard, qui est par défaut le clavier.
Et obtient va prendre un pointeur. Il suffit donc de passer du texte car
c'est déjà un pointeur, il n'est pas nécessaire de mettre l'adresse de l'opérateur.
Et ce qui est bien avec get demande, c'est que vous pouvez lire plusieurs chaînes séparées par des espaces.
Une fois que nous avons réellement lu dans
get, nous pouvons simplement l'imprimer. Ainsi, nous pouvons dire le texte entré
si l'entrée est un mot pour cent s antislash
n, puis du texte virgule. Le texte est un pointeur.
Printf prend un pointeur. Nous n'avons pas à le dé-référencer.
Parce que si vous affichez simplement
du texte, le texte affichera la valeur du pointeur qui sera une adresse.
Nous voulons en fait afficher la valeur de ce vers quoi le texte pointe.
Et puis nous avons terminé. Oh non, nous n'avons certainement pas fini. Nous voulons appeler notre libre.
Nous voulons libérer notre pointeur.
Même si lorsque nous quittons, la mémoire va être libre. Nous voulons toujours nous assurer que nous le
libérons, et ensuite nous voulons probablement aussi juste pour la garde, nous voulons définir le texte égal à null.
Alors allons-y, construisons ceci et voyons ce qui se passe.
Et j'ai un problème parce que je ne lis pas
la bonne variable.
donc ici je n'utilise pas la bonne variable. Je veux utiliser la taille, et
on dirait
que nous sommes bons.
Nous allons donc ici, la seule différence ici est que vous n'avez pas à
dé-référencer le texte car le texte est un pointeur de caractère.
Vous n'avez à dé-référencer que si dans le pointeur et ainsi de suite. Ainsi, lorsque vous utilisez
le pourcentage s, il sait automatiquement dé-référencer le pointeur
de caractère.
C'est une différence lorsque vous utilisez des pointeurs de caractère
par rapport à d'autres pointeurs. Les autres pointeurs que vous
devez dé-référencer pour obtenir la valeur car vous ne pouvez pas réellement
copier des chaînes dans des tableaux de chaînes, etc.
Vous ne seriez jamais en mesure de faire un texte
en étoile égal, vous devrez toujours utiliser la copie str si vous souhaitez copier du texte.
Parce que rappelez-vous des conférences, vous ne pouvez pas réellement
affecter des données à un tableau, et un pointeur de caractère est un tableau.
Donc, ici, cela semble correct. Aucune raison de le dé-référencer.
Nous voulons construire ceci, puis nous voulons l'exécuter.
Et vous remarquerez que nous avons mis la limite du texte.
Alors disons que nous mettons 5, 6 pour jason et
qu'il imprime l'entrée est jason.
Et vous pouvez jouer avec ce programme. Mais encore une fois, les
points à retenir incluent la bibliothèque standard lorsque vous utilisez malloc.
Initialisez vos pointeurs de caractère à null. Faites un scanf,
utilisez l'esperluette car la taille n'est pas un pointeur.
Lorsque vous mallocez, malloc renvoie un pointeur vide, vous devez donc lancer.
Vous voulez toujours entrer dans votre malloc. Choisissez l'opérateur sizeof
pour ce que vous souhaitez allouer. Times, combien de caractères réels
sont ou entiers. Ceci est plus applicable techniquement aux entiers
et aux types de données primitifs pour les caractères. Vous pouvez simplement faire la taille, cela devrait fonctionner correctement.
Vous voulez toujours vérifier la valeur null, assurez-vous qu'elle n'est pas nulle.
Lorsque vous utilisez une chaîne de caractères.
Et puis nous entrons simplement du texte, stocké dans nos get et l'imprimons.
Et puis last but not least, nous voulons toujours libérer nos pointeurs afin de pouvoir
les redonner au tas. J'espère que cela t'aides. Merci.