Transcription
1. Intro de pointeurs: Bonjour à tous Dans ce
cours , nous avons
parlé des pointeurs en C.
Nous commençons donc par
comprendre les pointeurs en C, puis
par le point zéro. Il y a les
opérations médicales et plus tard, les pointeurs et les fonctions seront discutés. Et puis une combinaison de
chaînes et de pointeurs. Ensuite, il sera temps de savoir si
une annonce est une combinaison. Plus tard, nous parlerons pointeurs
doubles et des exemples
liés aux pointeurs doubles
et, enfin, gestion
dynamique de la mémoire à
l'aide de pointeurs. C'est donc la fin. Notre programme
portait sur les pointeurs. Et les pointeurs sont le sujet le plus
important du langage C. D'accord ? Utilisez donc ces pointeurs. Et cela vous
aidera
certainement à bien performer dans le cours de
structures de données. Si vous essayez de
l'implémenter en C.
2. Comprendre les pointeurs: Nous allons maintenant discuter
du concept de pointeurs. Alors, tout d'abord, qu'
entend-on par pointeur ? Donc, généralement, goin détermine une variable qui peut stocker l'adresse d'
une autre variable. Donc, il existe une variable qui peut stocker
l'adresse d'une autre variable. Les variables normales ne peuvent donc pas contenir l'adresse d'
une autre variable. C'est pourquoi nous avons
besoin du concept de pointeurs pour stocker l'adresse d'
une autre variable. Maintenant, je vais vous montrer
un exemple cette variable pointeur
et de sa représentation. Maintenant, considérons que la variable
n est égale à dix. D'accord ? Il s'agit donc d'une variable
normale. Maintenant, considérons qu'
une variable pointeur dans l'étoile d représente une variable
pointeur. Maintenant, je stocke l'adresse de n dans cette variable pointeur. D'accord ? Donc, si vous vous concentrez
sur cet exemple ici, et si je commence à imprimer une valeur n, la même valeur n peut être
obtenue de plusieurs manières. Ainsi, par exemple, si
j'écris des jours individuels DNH, je pourrai les
afficher et les évaluer. De même, je peux également utiliser une
étoile variable pointeur p afin d'afficher la valeur de n afin qu'elle soit basée sur la personne. L'étoile P peut être utilisée pour
imprimer la valeur de n. Donc, si vous considérez cela ici, n est une dette à taux variable. Donc n est une variable et sa valeur
correspondante est. Alors l'étoile p est égale à l'adresse. Souvent. Nous considérons souvent
Ibis comme un modèle des années 2000. Et puis p est une variable
pointeur, qui contient
l'adresse n et c'est 2000. Donc p est un pointeur
contenant l'un ou l'autre des deux. Maintenant, nous imprimons
la fin ici. Cela signifie donc que la sortie sera
affichée sous la forme de dix. Et nous utilisons l'étoile P pour imprimer, qui signifie comment cela
va être évalué. L'étoile p représente les abeilles
de départ contenant 2 000 abeilles. Commencez donc par les années 2000, c'
est-à-dire le contenu situé dans
l'emplacement mémoire des années 2000. Cette étoile indique donc un opérateur
d'indirection, ce qui signifie qu'il met à jour le contenu de
cet emplacement mémoire. Le contenu contenu à l'intérieur de cet emplacement
mémoire 2000 est donc de dix. Vous allez donc envoyer un ping au
résultat sous la forme de dix ici. Maintenant, nous pouvons écrire deux pointeurs
différents. Donc, tout en déclarant,
supposons que je considère des
points différents ici dans l'étoile. Il s'agit donc d'un pointeur. Je peux donc considérer
cela comme un pointeur, qui peut pointer et
à cet endroit. Il s'agit donc d'un pointeur vers un emplacement mémoire de
l'utilisateur final. De même, je
considère une étoile flottante b. Elle est
donc considérée
comme un pointeur vers une position
à virgule flottante. C'est donc un pointeur vers un flotteur. Puis car star c.
Il s'agit donc d'un pointeur vers le type de données du
caractère. D'accord ? Pointez donc vers un emplacement de mémoire. Donc, comme ça, vous pouvez écrire
deux pointeurs différents, d'accord ? Et vous ne devez utiliser dans le pointeur de
teaser que deux points
dans l'emplacement mémoire mérité. De même,
pointeur à
virgule flottante pour indiquer l'emplacement de la virgule flottante,
et ainsi de suite. Maintenant, écrivons un
programme afin identifier
essentiellement l'adresse
et d'afficher le contenu
à l'intérieur du pointeur. D'accord, donc d'abord, je vais
inclure le fichier d'en-tête ici. Voici stdio.h. Et dans la fonction principale, je considère une variable. À l'intérieur de la fonction principale. Nous considérons une
variable comme un nombre. Laissez-moi donc considérer que le nombre est
égal à une valeur comme 50. Nous pouvons maintenant considérer une
variable pointeur comme une étoile p. Il s'agit
donc d'une variable pointeur. Maintenant P est égal à l'
adresse du nombre, un pointeur contenant
l'adresse d'une autre variable. D'accord ? Nous pouvons maintenant imprimer l'adresse de cette
variable p. D'accord ? Permettez-moi donc d'imprimer cette adresse
de la variable ISA. Vous pouvez donc utiliser une représentation
int non signée. Non, d'accord, pourcentage. Vous imprimez cette adresse. Et vous pouvez également utiliser votre représentation des
valeurs. Donc c'est la valeur de b. Donc notre valeur est indiquée par p, d'accord ? Donc, cette valeur
pointée par le pointeur p
utilise des jours-personnes D, vous pouvez imprimer, qui est une étoile p. Donc, cela affichera la valeur
pointée par le point B. D'accord ? Ainsi, vous pouvez afficher l'adresse et la valeur
en utilisant le point a b. D'accord ? Voyons maintenant quels sont les avantages
de l'utilisation de ce pointeur. D'accord ? Tout d'abord, tu peux utiliser ce pointeur, d'accord ? Avec les autres concepts également. Avantages hors sujet. La première consiste à utiliser le pointeur. Tu peux réduire le code, d'accord ? Cela réduira donc le
code que nous écrivons. Et cela améliorera également
les performances. Cela améliorera les performances. Et vous constaterez cette
amélioration des performances, en particulier en langage C,
lors de la récupération. Les chaînes permettent de récupérer ou d'
accéder à des arbres. D'accord ? Encore une chose,
ces pointeurs sont utilisés avec d'autres concepts
tels que les structures et les fonctions. Donc, tous ces sujets, nous allons
donc utiliser
ces pointeurs, d'accord ? Cela signifie donc que chaque fois que vous souhaitez accéder aux
éléments d'un tableau, l'un des moyens consiste à y accéder
via son index. Autres moyens d'accès
à l'aide d' un pointeur pointant vers l'
adresse de base du tableau. D'accord ? Maintenant, un autre avantage est que l'instruction return
en C ne peut généralement renvoyer qu'
une seule valeur. Chaque fois que vous souhaitez renvoyer plusieurs valeurs à partir d'une fonction, vous pouvez utiliser un pointeur. Vous pouvez essentiellement renvoyer un pointeur et, en utilisant
ce point, vous pouvez accéder aux emplacements de
mémoire suivants. Je peux donc écrire ici
chaque fois que vous souhaitez renvoyer plusieurs valeurs ou plusieurs
valeurs à partir d'une fonction. D'accord ? Vous allez donc
utiliser le concept de pointeurs. Et aussi, chaque fois que vous
utilisez ce pointeur, il vous permettra d'accéder à n'importe quel emplacement mémoire de
l'ensemble de l'ordinateur. D'accord ? Cela nous
permettra donc d'accéder à n'importe quel emplacement de mémoire à
l'aide d'un pointeur. D'accord ? Alors maintenant, écrivons le programme I'm Bill
en utilisant des pointeurs. D'accord ? Donc, d'abord, je vais effectuer l'échange de deux nombres sans
utiliser de troisième variable, mais j'utiliserai ici le concept
de pointeurs. D'accord ? Alors d'abord, incluez
le fichier d'en-tête ici. À l'intérieur de la fonction principale. Nous pouvons d'abord considérer que
les variables sont égales à dix, b est égal à 20. Maintenant, nous allons considérer
les variables pointeur ici, étoile b1, qui peuvent contenir l'adresse de j,
n, étoile v2 pour trouver l'
adresse de B. D'accord ? Vous pouvez donc maintenant
afficher le contenu
avant cet emballage. Avant d'effectuer un
échange, vous pouvez afficher le
pointeur de contenu par P1 et P2. Cela peut donc être écrit
comme avant Swap. D'accord ? Étoile p1 égale à
l'utilisation du pourcentage d. D'accord ? Et je pense aussi à une étoile, v2 est égale à un
pourcentage de slashing. Je suis donc en train d'écrire du contenu de star
b1 et de star. Nous les condamnons. D'accord ?
Maintenant, effectuons l'échange, en utilisant, d'accord, sans
utiliser
directement aucune troisième variable , vous pouvez effectuer à
l'aide de ces pointeurs. Donc, l'étoile p1 est égale
à l'étoile, l'étoile p2. D'accord ? Et puis ici, nous pouvons
écrire que l'étoile p2 est égale à l'étoile p1 moins p2. De plus, l'étoile p1 est égale
à l'étoile p1 moins p2. Enfin, après l'échange, vous pouvez afficher le
contenu comme ceci, print f, le swapping. Vous pouvez donc maintenant afficher
ce contenu en étoile b1. Commencez également par le contenu
que vous pouvez afficher ici. Ce
sera donc l'étoile t1, l'étoile p2. D'accord ? Donc, après cette
séquence d'actions, il est clair que le contenu de UEN contenu de b seront échangés. Alors laissez-moi vous montrer comment cela
va fonctionner ici. Donc, d'abord, vous pouvez le montrer ici et il conserve
la valeur initiale. Ensuite, les abeilles et une autre variable, qui a initialement une valeur
de 20. Maintenant, P1 est un pointeur qui
contient soit Sophie. Supposons
que Sophia soit 2000 et que l'adresse de b soit 3 000. D'accord ? Donc, si tel est le cas, alors P1 sera un pointeur
contenant l'adresse Sophia, ce qui signifie 2000
emplacements mémoire. P1 pointera donc
vers cet emplacement de mémoire. Maintenant, P2 est un autre pointeur
appelant l'adresse B, qui correspond à 3 000 emplacements mémoire. Et P2 pointe du doigt celui-ci. Maintenant, l'étoile p1 est égale
à l'étoile p, l'étoile p deux, ce qui signifie que l'étoile t1 pointe essentiellement vers
cet endroit,
n'est-ce pas ? Maintenant, cela est mis à jour
en ajoutant l'étoile P1
contenue dans une étoile. Nous créons du contenu. Le contenu de l'étoile P1 est de dix et le contenu de l'
étoile P deux est de 20. Donc dix plus 20 feront 30. Et cela sera stocké
dans cet emplacement, qui est indiqué par P1. Alors l'étoile p2 est égale à l'
étoile p un moins p étoile p2. étoile P1 est donc contenue
à l'intérieur de cet emplacement, soit 30 moins une étoile P2, soit 20 à 30.
La valeur 20 sera dix, et elle sera stockée
dans cet emplacement mémoire
, pointé par P2. Enfin, l'étoile p1 est égale à l'étoile p un
moins p étoile p, étoile P1 est 30 et l'étoile p2 est 1030
moins dix sera 20. Et cela sera stocké
dans cet emplacement mémoire, qui est pointé par p un. Cela devrait donc être
modifié à 20. Enfin,
après l'échange, nous affichons le contenu P1, alors ajoutez le contenu P1 en favoris, puis
commencez par continuer. Donc, après avoir échangé l'étoile
p lorsque le contenu est notre 20 et le
contenu de l'étoile p2 est dix. Donc, mais avant d'échanger, vous pouvez voir que le contenu de l'étoile
P1 pointera vers EA et démarrer P2, ce qui signifie que le pointeur P2
pointera vers b, d'accord ? Il s'agit donc de 10,20 au départ. Mais après avoir effectué un échange, il est 20h10. D'accord ? Comme ça.
3. arithmétique: Nous allons maintenant travailler sur la façon dont l'opération d'incrémentation du
pointeur, l'opération point final ou
l'opération de décrémentation va fonctionner. D'accord ? Donc, considérez
d'abord une variable ici, puis sa valeur est 50. Et j'envisage
un autre point d'étoile variable p ici. Donc P est égal à l'adresse de x. D'accord ? Vous pouvez maintenant introduire ici l'
adresse correspondante pour x, qui n'est rien d'autre que P. Donc, imprimez f address off, soyez notre adresse dans IP, adresse, qui est
stockée dans B. D'accord ? Vous pouvez donc l'afficher. Mais je pense comme
ça, à R of X Caesar. Vous pouvez donc utiliser un
pourcentage pour afficher cette
adresse et la signer, d'accord. Donc B, vous pouvez afficher. Maintenant, allons-y et
voyons le résultat de l'asphalte. Vous pouvez voir que c'est l'adresse
actuelle de x. Voici donc le présent. J'appuie, OK. Maintenant, je veux augmenter ce
p d'un emplacement, d'accord ? Donc P égal à P plus un
représente l' incrémentation d'
un emplacement mémoire. D'accord ? L'adresse est donc égale à l'adresse plus l'incrémentation
d'un emplacement mémoire. Cet emplacement mémoire est
égal à la taille d'InDesign. D'accord ? P est donc incrémenté de sa taille dans un
teaser. D'accord ? Ou je peux dire que le fait de vouloir faire de la taille dans le désert est augmenté par un
côté sur deux de quelqu'un qui mérite quelqu'un. Si je prends p plus deux, alors cela représente le fait de faire
ces yeux d'InDesign, il sera incrémenté. Enfin, lorsque vous
souhaitez afficher ici, après l'
opération d'incrémentation, d'accord. L'augmentation de l'adresse est correcte. Donc, le fait d'utiliser une personne pour
vous payer, vous pouvez afficher
l'adresse ici. D'accord ? Et vous pouvez commencer à l'afficher. Maintenant, exécutons ce code
et voyons le réservé. D'accord. Donc, si vous le souhaitez, nous allons faire tourner
une seule ligne. Vous allez remarquer que c'
est l'adresse de x, n'est-ce pas ? D'accord. Et après avoir effectué
une opération d'incrémentation, j'appuie exactement de manière incrémentielle
de quatre, car le quatre représente la taille d'un
dans un emplacement mémoire diesel. C'est pourquoi il est
incrémenté de quatre. Maintenant, si vous considérez l'
incrémentation de quatre, par exemple
, cela représente que B doit être incrémenté de quatre dans
ces emplacements de mémoire, ce qui ne fait que quatre
dans la taille d'un teaser int, il est incrémenté de
quatre dans la taille de int. Ainsi, après incrémentation
des adresses, vous pouvez les imprimer ici. Exécutons donc ce code
et voyons la réserve. Donc, au début,
ces deux derniers chiffres, vous pouvez voir les deux derniers chiffres de l'argent
économisé, 80. Et ici, les
deux derniers chiffres sont 96 parce que la différence
est de 16. D'accord ? Cela indique clairement que nous
incrémentons l'adresse actuelle
de quatre emplacements de mémoire. Et chaque emplacement mémoire est
égal à cette taille de int. La taille de l'entier est de quatre octets. Quatre sur quatre est égal à 16. C'est pourquoi il est
incrémenté de 16. D'accord ? De même, nous allons envisager une
opération de décrémentation, d'accord ? Donc, si vous voulez envisager une opération de
décrémentation, d'accord. Modifions-nous donc ici
pour décrémenter l'opération. Et ici aussi, je vais exécuter
p égal à p moins un. Donc ici, P sera décrémenté d'une unité
en taille int. P est égal à p moins
un représente P sera décrémenté de un en
sizeof in deserve. Après l'incrémentation, l'
adresse sera la suivante. D'accord ? Exécutons donc ce
code et voyons la réserve. Vous pouvez observer que l'adresse
de x se compose des deux derniers caractères. Vous pouvez voir Haïti désormais
décrémenté d'une position, ce qui signifie un emplacement mémoire égal à la taille d'un entier, soit quatre octets. Cela devrait donc être
décrémenté de quatre. La valeur devient donc 76
comme ça. D'accord ? Alors, maintenant, par exemple si vous voulez décrémenter
de quatre emplacements mémoire, alors p est égal à P moins quatre, ce qui signifie que P sera décrémenté de quatre tailles
d'entrée de int. La taille de l'inducteur
sera de quatre octets. Quatre sur quatre est égal à 16. Donc p devrait être
décrémenté de 16. D'accord ? Alors voyons voir ici. Donc ça fait 80 et ça fait 64, les deux
derniers chiffres, d'accord ? Je rappelle que tout le monde est pareil. Il est donc clairement
décrémenté de 16. D'accord ? C'est ainsi que d'incrémentation et de décrémentation du
pointeur dérouleront les
opérations d'incrémentation et de décrémentation du
pointeur.
4. Pointeurs comme paramètres: Nous envisageons maintenant un appel
par implémentation de référence ou la transmission de l'adresse de la variable en tant que
paramètre à la fonction. Et vous pouvez l'utiliser pour conserver l'
adresse de la variable. D'accord ? Considérons donc de faire
la somme fictive de
deux nombres donnés. Supposons donc qu'une virgule
b soit les deux variables. Nous pouvons maintenant lire valeurs
correspondantes de
cette variable et les transmettre en tant que paramètre
à la fonction. D'accord ? Maintenant, je vais demander à l'utilisateur de
saisir deux valeurs quelconques. Et en utilisant la fonction scanner, nous pouvons lire ces valeurs,
comme les jours-personnes, la personne prend l'
adresse d'une virgule b. D'accord ? Maintenant, nous devons transmettre
ces variables en tant que paramètre à une fonction
afin qu'elle calcule la somme de
ces deux nombres. Je vais donc considérer find invoque
le nom de la fonction, en passant deux variables
et en préservant une adresse
virgule des paramètres S. Dans cette fonction, j'
utilise le type de retour le plus large possible afin de pouvoir afficher le résultat
dans cette fonction. À l'aide du pointeur. Nous exécutons
ici un PTR étoile,
une virgule en étoile PTR également. Ainsi, dans cette fonction, nous pouvons calculer un résultat en
ajoutant le contenu indiqué par PT R1 et R2. Parce que PTR 1
contiendra l'adresse de a et P DR2
contiendra l'adresse de B. D'accord ? Considérons maintenant une autre
variable appelée aureus, qui est une variable de résultat. Maintenant, aureus est égal à l'étoile
p d R1 plus l'étoile PTR deux. Enfin, vous pouvez
imprimer le résultat. Donc, le résultat de l'ajout dimanche de
Pâques est la barre oblique et vous pouvez afficher la valeur RES. D'accord ? Exécutons donc ce code
et les réserves d'argent entrent deux valeurs quelconques, 12,23. Et vous allez
observer le dessert après avoir ajouté 35 plus 23 secondes. Définissez. C'est ainsi que vous pouvez transmettre
l'adresse de la variable en paramètre à la fonction et calculer et
afficher le résultat. Le sous-calcul
est donc effectué à
l'aide de ces
variables pointeurs qui contiennent
actuellement l'
adresse des variables passives dans
la fonction principale. D'accord ? Il s'agit donc également d'un exemple d'implémentation d'appel
par référence. Et cela est également considéré comme l'utilisation de pointeurs comme
paramètre d'une fonction. D'accord ?
5. Pointer à une fonction: Examinons maintenant notre concept
de pointeur vers une fonction. D'accord ? Vous pouvez donc également utiliser un pointeur pour
pointer la fonction IF. Donc, tout comme nous avons utilisé
une variable pointeur vers pointeur, de la
même manière une variable pointeur vers pointeur, ,
vous pouvez également utiliser une fonction pointeur vers point
IF en C. D'accord ? Ainsi, la déclaration de
la variable pointeur est similaire à la déclaration de
fonction. Permettez-moi donc de vous montrer
un exemple ici. Je veux essentiellement implémenter la fonction
principale en ce moment. D'accord ? Donc, dans cette fonction principale, je vais considérer une variable
appelée variable réservée. Et ce point que je
veux pointer vers l'étoile PTR, je voulais pointer vers
une autre fonction. Supposons donc que la déclaration de fonction soit initialement
le
nom de la fonction, et qu'il s'agisse de la déclaration du
prototype de la fonction. OK, alors maintenant, comment déclarez-vous un pointeur qui
pointe vers une fonction ? Il doit donc être
déclaré de la même
manière que nous écrivons la fonction. D'accord ? Alors, mettez PTR en vedette, d'accord ? Comme ça. Maintenant, vous pouvez utiliser ce PDR à 2 points J'appuie sur une autre
fonction qui est VTR est égal à I dress ou le nom de la fonction
est un ajout. D'accord ? Maintenant, nous devons
extraire la réserve. La réserve est égale à, d'accord ? Donc, en gros, vous
appelez la fonction. En général, vous
appelez la fonction et résultats correspondants doivent être stockés dans un résultat variable. Mais pour le moment, vous
allez absorber un PDR, c'est le pointeur qui pointe vers la fonction
appelée addition. Donc, écrire ceci n'est
rien d'autre que l'appel d'une
fonction appelée édition. D'accord ? Cela équivaut donc à appeler une
fonction d'addition ici. Alors maintenant, une fois que vous aurez trouvé le désert, vous pourrez l'exposer préservé. D'accord ? Donc, cette somme doit être
basée sur la personne. Vous pouvez afficher le résultat. Implémentons maintenant
cette fonction d'addition. D'accord ? Donc, comme j'ai déjà déclaré le
prototype de fonction ou déclaration, je peux
implémenter ici. Maintenant, dans cette fonction, je vais essentiellement lire
les deux variables et les valeurs correspondantes. Je vais en jouer quelques unes. D'accord ? Donc ces deux variables
sont dans B, d'accord ? Et je vais clairement demander à l'
utilisateur de saisir deux valeurs quelconques. Et en utilisant la déclaration scan f, vous pouvez lire ceci. Les jours-personnes sont des jours-personnes. J'appuie sur Off, une virgule b. Et enfin, vous pouvez
renvoyer un plus b réservé. Enfin, vous pouvez retourner
un plus si vous le méritez. Nous allons donc exécuter et voir la réserve pour saisir les
deux valeurs que je suis en train de saisir. La première valeur est entrée, une valeur x est 20, et vous pouvez voir le
résultat, la somme est 30. façon dont cela est
obtenu est donc claire au lieu d'appeler directement cette fonction d'
addition, nous utilisons un pointeur pour contenir l'adresse de
la fonction d'addition. D'accord ? À l'aide d'un pointeur,
nous appelons cette fonction,
extrayons la réserve et la
stockons dans une variable
appelée résultat. Ensuite, nous l'affichons. D'accord ? C'est donc le concept du
pointeur vers une fonction en C. Et cela produira des réserves de
caractères. De cette façon, vous pouvez
entrer deux valeurs
quelconques, par exemple six,
et le résultat sera huit. D'accord ?
6. Accéder à la chaîne à l'aide de pointeurs: Dans cet exemple, nous allons voir comment accéder à
une chaîne à l'aide d'un pointeur. D'accord ? Considérons donc la fonction principale. Dans cette fonction principale, vous considérez un
caractère qui est une chaîne. Donc, STR off
est égal à bonjour. Bonjour, c'est ce string. Maintenant, considérez également Star PDR. Pdr est le pointeur pointant vers l'
adresse de base de la chaîne, ce qui signifie que always remember string name représente
l'adresse elle-même, notre adresse de base de la chaîne. Vous devez donc utiliser comme
ceci p d ou égal à USTR, ce qui signifie directement que USTR indique
l'adresse elle-même, donc PDR
contiendra cette adresse. Maintenant, en utilisant le PDR, vous pouvez afficher le contenu pointé par ce magnétoscope. D'accord ? Ainsi, en utilisant while loop, vous pouvez afficher ce contenu. Alors que le PTR de l'étoile n'est pas égal
à un caractère nul. Le PTR de l'étoile n'est pas égal
à un caractère nul. Dans ce cas, vous pouvez apporter du contenu PTR vedette. Donc, pourcentage d star PTR. Et vous pouvez utiliser le PDR
pour passer à la position suivante. Ce
sera donc le PTR plus des incréments d'une
position, le passage à l'emplacement
suivant, l'impression candidat et le passage à
l'emplacement suivant de cette manière. Exécutons donc ce code
et voyons la réserve. OK, ici, tu devrais
utiliser les jours par personne. Tu vois, sinon. Il affichera la valeur ASCII
correspondante. D'accord ? Les jours-personnes visent donc à
obtenir exactement le personnage. Donc, la même chaîne,
hello, s'affiche. Supposons que vous ayez une
chaîne comme Hello Space World. Vous pourrez accéder à Hello Space World à l'
aide de ce code. Vous pouvez voir la réserve Hello
Alice affichée. De cette façon. Vous pouvez accéder au contenu de la chaîne à l'aide
d'une variable pointeur.
7. Comparaison à chaînes à l'aide de pointeurs: Nous allons maintenant implémenter comparaison de
chaînes en utilisant
un concept de pointeurs. Supposons donc qu'un STR r1 contient hello et
STR contient void. Maintenant, je veux
effectuer une comparaison entre ces deux chaînes
avec des pointeurs. Permettez-moi donc de considérer une variable entière qui peut contenir la réserve comparative. Et je vais appeler la fonction, qui est ma fonction STR CMP, contournant les
paramètres STR one et STR QS vers cette fonction. Enfin, je vais afficher
ici, réserver cette chaîne. Comparaison. La réserve est une personne, c'est B. Nous allons
donc
afficher le résultat ici. D'accord ? Maintenant, implémentons
cette fonction qui est ma fonction STR CMP. Donc, en utilisant des pointeurs,
laissez-moi réfléchir. L'un est le pointeur
pointant vers la chaîne 1.2, tout comme le pointeur vers la chaîne
pointant vers la chaîne de points. D'accord ? Alors, comment allez-vous obtenir la comparaison des
cordes au Brésil ? C'est simple : vous
devez essentiellement comparer
deux chaînes et identifier la différence de
valeur ASCII entre le premier caractère
non correspondant. D'accord ? Donc, dans ce but, je compare les deux
chaînes
tant qu'elles sont égales à
l'aide de la boucle while. D'accord ? abord, supposons qu'une étoile est, S1 est égal à l'étoile est au départ, S1 est égal à l'étoile est deux. Et vous devez également vérifier ici. L'étoile est S1 ne doit
pas être égale à zéro. D'accord ? Ce n'est donc pas égal à zéro. Ou je peux dire caractère nul. Tout va bien. Donc, soit ce n'est pas nul. Notre étoile deux n'est pas
égale à zéro. D'accord ? La première condition est donc que le caractère situé dans les sites STR un est égal au caractère
situé dans STR deux, qui est pointeur par les pointeurs
S1 et S2. Et considérez également s1, quel que soit le point s1 qui
pointe, n'est pas égal à zéro. Ou le pointage S2
n'est pas égal à zéro. Dans ce cas seulement, nous
irons plus loin. D'accord ? Dans ce cas nous incrémenterons le S1 à la position suivante et également
de deux à la position suivante. S1 sera donc incrémenté
et S2 sera incrémenté. Maintenant, ici, je vais renvoyer la différence
entre S1 et S2. Donc ici, l'étoile de retour est
S1 moins une étoile est deux. Cela vous donnera donc
la différence entre l' étoile s1 et le début pour savoir quels sont uniquement des caractères qui
ne correspondent pas, différence
correspondante. D'accord ? Donc soit s1 n'est pas
nul, soit S2 n'est pas nul, alors seulement cela le sera,
cette boucle particulière est exécutée, en cours d'exécution, d'accord ? Donc, dans l'ensemble, vous pouvez voir quand
cette condition est vraie, alors elle seule fonctionnera, n'est-ce pas ? Cela doit donc être vrai et cela doit
également être vrai. Ce qui signifie que les caractères doivent correspondre
en même temps. Aucune de ces chaînes
n'atteint la valeur null. D'accord ? Alors pointez, vous pouvez voir S1, pointeur et le pointeur s'
incrémenter jusqu'aux positions suivantes. Et chaque fois que vous
constatez qu'il y a un caractère qui ne correspond pas ou
que les deux atteignent zéro. Dans de tels cas, vous
devez immédiatement trouver la différence entre
ces personnages, d'accord ? Donc, ces
personnages qui ne correspondent pas. Exécutons ce code
et voyons Reserved. Vous pouvez voir que le résultat de la
comparaison de chaînes est -15 parce que nous comparons
Hello à World. Les deux premiers personnages qui ne correspondent pas sont directement touchés par U et W eux-mêmes. D'accord ? Donc h moins w, la différence est clairement une différence de
15 caractères. Et ce H vient
en premier par rapport à w. C'est pourquoi h moins
w mènera à -15. Le résultat est donc affiché sous la forme -15. D'accord ? Supposons donc que
je veuille modifier cette chaîne comme x, y zed. Et cela indique également x, x, z. Maintenant, exécutons ce code et voyons que le y moins x réservé
va en produire un. D'accord ? Comme ça. Supposons que je
donne ceci sous la forme x, x ,
z et que c'est x, y, z. Dans ce cas, vous obtiendrez
un résultat de moins un. Supposons que les
chaînes modales soient égales, essentiellement x, y, z et x y, z. Dans ce cas, vous
obtiendrez un résultat nul. D'accord ?
8. Concaténation à chaînes à l'aide de pointeurs: Maintenant, dans cette vidéo, je vais vous montrer comment effectuer une opération de concaténation de chaînes
à l'aide de pointeurs. Je perds donc la notion de pointeurs pour effectuer cette opération de
concaténation de chaînes. Je vais également effectuer cette concaténation de
chaînes dans une fonction distincte. D'accord ? Permettez-moi donc d'écrire ici concaténation de
chaînes
à l'aide de pointeurs. Je vais donc d'abord inclure
le fichier d'en-tête. Oui, le TDI s'en chargerait. Maintenant, dans la fonction principale. Considérez quelques
chaînes ici. Considérez donc STR un égal à hello et STR égal à void. Considérez donc une taille plus grande pour STR 1 parce que je veux
concaténer dans STR 1. C'est donc exact. Nous allons considérer que
STR 1 est notre 20, par exemple ,
puis je concaténerai
le contenu de SGR, STR 1. Permettez-moi donc de l'appeler fonction ici, qui est ma fonction STR CAP. Et je vais transmettre un STR karma à STR en tant que paramètres
de cette fonction. Et plus tard, nous pourrons
afficher le contenu de STR One. D'accord ? Alors passez une journée avec des
gens sympas, oui. Vous pouvez afficher le contenu en tant que contenu DR1. Implémentons maintenant cette fonction
My STR CAD. Examinons donc l'implémentation de cette
fonction. Où je considère
quelques conseils de moins. Supposons que je
considère que l'étoile est deux et que l'étoile est S1 ici. Dans mon CAD STR. Maintenant, je veux passer à la fin de la chaîne que
vous pouvez observer pour STR 1 J'utilise un ragoût
comme pointeur. D'accord ? Donc, vous devez d'abord utiliser ce S22 que j'échange jusqu'à la
fin de cette chaîne. En utilisant while loop, vous pouvez hydrater cette étoile S2 n'est pas
égale à un caractère nul. Donc, dans ce cas, il vous suffit
de l'incrémenter deux par un. Et maintenant, vous devez vérifier
si celui-ci va bien. Alors d'abord, oui, quand il pointe déjà ces deux
cordes juste là. Vous devez donc accéder
caractère par caractère et l'ajouter à cette chaîne, STR une chaîne
pointée par S2. Cela peut donc être fait comme
ceci en utilisant while loop. Je vais vérifier comme ça. L'étoile est S1 n'est pas égale
à un caractère nul. Si cette condition est vraie, nous pouvons copier
et également incrémenter. Dans une seule déclaration. Je m'en sors comme ça. L'étoile S est deux plus plus
égale l'étoile s1 plus, plus. D'accord ? Enfin, une fois l'
adaptation complète terminée, il vous suffit de
placer explicitement un caractère nul. Donc, ce qui peut être une étoile
est égal à un caractère nul. D'accord ? Comme ça. Maintenant, exécutons ce code
et voyons le réservé. Et nous allons voir que la chaîne
mise à jour est Hello World. La première chaîne est un mot bonjour. Donc, au départ, la chaîne 1
contient uniquement Hello, chaîne deux contient le monde. Maintenant, après avoir effectué l'opération de
concaténation de chaînes, qui est implémentée à
l'aide de pointeurs chaîne 1 est pointée par le pointeur de
caractère S2, et la chaîne deux est le pointeur
par le pointeur de caractère S1. Pour nous, nous sommes passés au bout
de la première chaîne avec l'
aide de Stupendous. Plus tard, nous
avons commencé à utiliser l'assistant
pour 1 point
caractère par personnage vers l'emplacement alors que
deux pointaient. Enfin, nous attribuons un statut égal
à un caractère nul, ce qui signifie que nous indiquons le caractère nul à la fin de la chaîne
après la concaténation. Nous pouvons donc maintenant accéder
au contenu de STR one, qui contient le
résultat concaténé de STI R1 et R2. C'est ainsi que cela va fonctionner.
9. Trouver la longueur de la corde à l'aide de pointeurs: Calculons maintenant la longueur de cette chaîne en utilisant une variable
pointeur. Vous pouvez donc observer que j'ai pris un nom de chaîne comme
HelloWorld et star. Ptr est la variable
pointeur pointant vers l'
adresse de base, qui est STR. Maintenant, vous pouvez commencer à compter le nombre de caractères
à l'intérieur de cette chaîne, qui est la longueur
de cette chaîne. Vous pouvez considérer que n est égal à zéro et représente la
longueur de la chaîne. Maintenant, en utilisant while loop, vous pouvez soit traiter ici alors que le PTR de l'étoile n'est pas
égal à un caractère nul. Donc, si c'est le cas, vous pouvez augmenter la
longueur de la chaîne, d'accord ? Parce que vous
devez compter
chaque caractère
de la chaîne. Donc Alien Plus, Plus, et aussi Moody's PDR
à la position suivante. Après avoir compté le
premier caractère, il faut passer au
second caractère. D'accord ? Ainsi, une fois tous les
caractères comptés, vous pouvez afficher la longueur
de la chaîne ici. Donc longueur de ficelle, facilité. Les journées individuelles devraient être étrangères. En utilisant une variable alien, vous pouvez afficher la
longueur de la chaîne. Maintenant, exécutons ce code et voyons la longueur de la chaîne est de 11. Il est donc clair qu'il y a un total de 11 caractères
dans cette chaîne, espacement
compris, un total
de caractères citrons. C'est ainsi que vous pouvez trouver
la longueur de la chaîne. D'accord ? Vous pouvez également essayer de transmettre ce paramètre STRS à la fonction et d'identifier la longueur de la chaîne
et d'une autre fonction. Alors laissez-moi vous montrer ici. PTR est donc égal à STR. Et nous allons implémenter une fonction distincte pour trouver
la longueur de la chaîne. J'écrirais donc
ma propre fonction, qui est l'extraterrestre MISTRA. Et ici, je vais utiliser
la variable pointeur comme étoile, pointeur PTR. Et vous allez voir
si PDR est égal à STR. Ici. Puisque nous transmettons un pointeur de
caractère, il doit également
s'agir d'un
pointeur de caractère. D'accord ? L'idée est donc de simplement considérer une variable
appelée EN, d'accord ? Pour trouver la longueur
de la chaîne. Et cela équivaut à, appelez cette fonction My
STR alien function. Et passez cette STR en paramètre. D'accord ? Comme tout ce que
nous calculons dans l'autre fonction, vous n'avez pas du tout besoin de prendre ce pointeur
dans cette fonction. Encore une fois, c'est égal à mon allèle
STR et hors STR, je passe un paramètre STRS
à ma fonction STR Len. Enfin, vous pouvez afficher la longueur
de cette chaîne ici. Impression de la longueur de la chaîne. La longueur de la chaîne est indiquée ici. Vous pouvez afficher la longueur de la
chaîne à l'aide de la variable EN. Et vous devez implémenter
cette fonction MISTRA LEN. Donc, à l'aide de pointeurs, c'est un pointeur de caractère. Prenons donc un autre
pointeur de caractère, comme car star m. D'accord ? Et dans un premier temps, je considérerai que
temp est égal au mode PTR, ce PTR et ce temper pointant vers l'
adresse de base de la chaîne STR. Maintenant, je voudrais
uniquement parler du temple. Donc, bien que cette étoile m ne soit pas
égale à un caractère nul, nous pouvons traiter cela ici. Vous pouvez donc déplacer ce
pointeur temporaire vers la position suivante. D'accord ? Donc, comme il n'y a qu'une seule ligne, vous pouvez ignorer ce M
plus, plus. D'accord ? Une fois que la température de l'étoile
pointe vers un caractère nul , vous
pouvez enfin revenir ici. **** moins PTR. Comme nous le savons, l'emplacement des
caractères n'occupera qu'un seul octet. D'accord ? Ainsi, temp pointe maintenant vers le dernier emplacement de la chaîne, et PDR
pointe déjà vers le premier
emplacement de la chaîne. Cela vous fera donc
la différence, n'est-ce pas ? Et cela deviendra la
longueur de la chaîne. D'accord ? Exécutons donc ce code
et voyons le résultat. La longueur de la chaîne est inférieure à. Donc. C'est une chaîne, non ? Bonjour Space, World,
11 personnages au total sont là. Et nous sommes en mesure d'
obtenir le même résultat. D'accord ? Voici donc comment vous pouvez transmettre un nom de chaîne en tant que
paramètre à la fonction et utiliser le
pointeur de caractère pour pointer vers cette chaîne et calculer la
longueur de la chaîne ici. OK.
10. Pointer et matrices 1D: Nous allons maintenant parler des pointeurs et des adresses
d'ajout unidimensionnelles. Si vous observez ce concept de pointeurs et de tableaux
unidimensionnels. Je vais d'abord vous montrer comment
ce pointeur peut être utilisé pour accéder au contenu de
ce tableau unidimensionnel. D'accord ? Donc, chaque fois, écrivez-le plus clairement. Maintenant, supposons qu'
il ait cinq ans. D'accord ? Vous allez donc
observer qu'il y aura emplacements de mémoire
phi contigus. Vous pouvez donc voir qu'
il s'agit d'un ARN appelé yay. D'accord. Il s'agit d'intégrer la
toute première position, le genou hors de la zone. Voici votre 234 comme ça. À l'aide du pointeur, vous pouvez désormais accéder au contenu de
chacun de ces emplacements. D'accord ? Supposons que je veuille stocker
au
moment de la compilation la liste des valeurs
dans ce tableau. Supposons que je stocke comme
ça, 102-030-4050. Donc, dans ce cas, sont les valeurs qui sont stockées et seront stockées ici. 20 sont stockés ici, 30 sont stockés ici, 40 sont stockés ici et 50 seront stockés ici. Maintenant, considérez l'adresse de base. Supposons qu'il s' l'adresse de base du
tableau, soit 2000s. Et nous sommes en 2004, car in desert
occupe quatre octets. Nous sommes en 2008, nous sommes en 2012 et nous sommes en 2016. Voici les adresses
correspondantes. Maintenant, à l'aide d'un pointeur,
nous pouvons pointer vers l'
adresse de base de l'ensemble du tableau. Cela peut donc être indiqué, supposons en utilisant
une variable pointeur. Pensez donc à l'étoile PTR. PTR est donc la
variable pointeur que j'utilise. Ce PDR peut pointer vers l'adresse de
base du tableau, adresse a de zéro, par exemple vous pouvez stocker comme cette
adresse de a de zéro. Ou simplement EH, le selfie
représente l'adresse de base. D'accord ? Alors maintenant, lorsque vous
effectuez cette action, PDR égal à une adresse
off ici de zéro, il va prendre en compte cette variable de pointeur,
corridor, PTR. Et il stockera l'adresse
des principaux centres de
l'ensemble du réseau. Avez-vous une adresse
correspondante nulle, qui est une année 2000. Cela permettra d'en stocker 2000. Npr pointera vers
cet emplacement de mémoire. D'accord ? Maintenant, en utilisant PTR, vous pouvez accéder chaque
élément du tableau. Pour ce faire, je vais utiliser une autre variable de
boucle appelée i. Je vais
donc écrire un exemple
pour loop afin de créer un accès à
chaque élément de
ce tableau
à l'aide d'un pointeur. Donc I est égal à zéro. Et puis considérez I comme inférieur à cinq car il y a cinq éléments
à l'intérieur du tableau. Maintenant, à l'aide de l'instruction print f, nous pouvons afficher chacun
de ces éléments. Imprimer f, pourcentage d, barre oblique t. Maintenant, j'affiche que PTR
pointe vers cet emplacement. Comment puis-je obtenir l'élément ? Donc, quand je parle de PTR, j'obtiens les années 2000. Lorsque j'écris un PTR en étoile, j'obtiens du contenu dans 2000 emplacements mémoire
, soit dix. Et après cela, je veux
accéder à ce contenu appelé 20, puis 30, puis 40, puis 50, comme ceci. Donc, dans ce cas, j'apprécie,
nous allons utiliser cette valeur I
mise à jour, n'est-ce pas ? Commencez moins par PTR. Je commence par DR. Place. Donc, cette valeur I
sera traitée partant de I égal à zéro
jusqu'à I égal à quatre. Et c'est une star
de PTR Place I. Donc, quand je commence par PDR plus I, c'est en fait
équivalent à, d'accord. Vous allez donc observer une
étoile sur VTR inférieure à zéro. Cela équivaut à
écrire u de zéro. D'accord ? Si vous considérez
que I est égal à un, cela deviendra une étoile
du PTR plus un. Et ce sera
équivalent à un. D'accord ? Et écrire étoile de PTR L2, où I est égal à deux, dans ce cas, cela
signifie une énergie égale pour en éliminer deux et ainsi de suite. De même, vous pouvez voir ici l'
étoile du PTR plus quatre. Ce n'est que quatre, d'accord ? Comme ça. Et s'il y a n éléments
stockés dans le tableau. Dans ce cas, vous pouvez simplement écrire
Star Off VTR less. En est égal à e off. D'accord ? Ou ça peut être K simplement PDR plus k est égal à
a de k comme ça. D'accord ? Alors maintenant, laissez-moi lire l'intégralité du contenu
du tableau à l'aide des pointeurs lui-même et afficher le contenu du tableau
unidimensionnel. Alors d'abord, prenez le fichier d'en-tête. Et dans la fonction principale, je vais considérer
un tableau ici. D'accord ? Supposons donc une augmentation de
e sur 20, par exemple et j'utilise deux variables
non colorantes à l'intérieur et vous pouvez stocker le nombre d' éléments ou la longueur du tableau. À cette fin, vous pouvez
apporter à cette déclaration. Le nombre d'éléments est
simplement entré la taille. Ainsi, en utilisant l'instruction scan f, vous pouvez souvent lire cette taille
particulière en qualité
et en adresse variables. Maintenant, nous allons demander à
l'utilisateur avec Scully de nous
guider dans la saisie
de ces nombreux éléments. Ici, vous pouvez demander à Render : le
pourcentage correspond aux éléments, ce qui signifie n éléments. Nous demandons à l'utilisateur d'entrer. Maintenant, en utilisant pour la boucle, je passe à l'axe, d'accord ? Donc, directement ici,
cela ne me sert même à rien d'utiliser Airy, je
n'y accède qu'ici. I est égal à zéro, I inférieur à n I plus plus. Nous pouvons maintenant stocker à l'aide d'une instruction
scan f. Donc c'est un scan des
jours de l'année par personne et plus. D'accord ? Nous stockons donc
à l'intérieur du tableau. Maintenant, lorsque vous souhaitez afficher de la
même manière en utilisant print f, vous pouvez simplement dire afficher les
éléments d'un tableau. Et après cela, vous pouvez
simplement l'utiliser pour la boucle. I est égal à zéro I
inférieur à n I plus plus. Et en utilisant la déclaration print f, vous pouvez afficher comme si
cette personne était une étoile D d'un plus si le
contenu de cette
adresse particulière est obtenu. Vous pouvez fermer cette fonction
principale. Ce code est donc essentiellement destiné à la lecture avec le
concept de pointeurs. Et cela utilise le
concept de pointeurs. Nous affichons le contenu
d'un tableau unidimensionnel. Ou vous pouvez directement prendre
un autre pointeur et
pointer vers cette adresse de base du tableau et commencer le titrage. D'accord ? Donc, de toute façon, vous pouvez le faire. Permettez-moi donc de vous montrer
un exemple où je vais modifier et
vous montrer différentes manières. Cela est donc considéré comme un accès
au contenu du tableau. Ici. Dans la fonction principale. Je vais l'ajouter ici. Permettez-moi de supprimer 20
virgules sur virgule i.
Maintenant, je vais demander à l'utilisateur
de saisir une valeur n en gros. Ainsi, une fois que vous avez saisi des valeurs à
l'aide d'une instruction du scanner, vous pouvez les lire
dans une variable dans. D'accord. Plus tard, vous pourrez
demander à l'utilisateur
d' indiquer les valeurs de la personne D. Et exactement, vous devez
obtenir un nombre pair de valeurs. D'accord ? Ensuite, en utilisant for loop, vous pouvez commencer à stocker
ces valeurs dans ce tableau avec la notation
de pointeur. Donc, en utilisant le relevé scan f, vous pouvez écrire comme
cette personne jours de
congé. Simplement un plus I. Cela indique ici un
plus I n'est
rien Simplement un plus I.
Cela indique ici un
plus I n'est
rien d'autre qu'une adresse figurant dans votre dossier. Vous pouvez donc voir qu'un plus cy
équivaut à phi. D'accord ? Juste comme ça. Maintenant, ici. De même, je souhaite
afficher ce contenu. Ainsi, en utilisant une imprimante, vous pouvez
simplement afficher les éléments du tableau. Et encore une fois, en utilisant for loop ici. Et au lieu d'un scanner, vous devez utiliser l'instruction printf
pour afficher le contenu. jours des personnes sourdes, l'
étoile d'un plus I. Cela vous donnera le contenu contenu dans cet emplacement de mémoire. Et si j'écris comme ça,
cela représente EOF, cela signifie que c'est équivalent à une
étoile de plus I. Commencer par un plus à droite, c'est équivalent à a ou PHI. Exécutons donc ce code
et voyons le résultat. D'accord ? Nous devons donc
utiliser ici un point-virgule. Entrez une valeur n, je
saisis une valeur cinq. Il vous sera maintenant demandé
de saisir cinq valeurs. Supposons que 1020304050
soient les valeurs que j'ai données. Vous pouvez voir que les mêmes valeurs
sont imprimées, d'accord ? Je vais donc utiliser ici une personne par jour, quatre jours pour qu'il y ait un
peu d' espace lors de l'
affichage des éléments. Donc, cette fois, j'ai
saisi une valeur de 6 000. Considérez donc différentes
valeurs comme 12, 304-203-5663 pour P2. D'accord, voici les six
éléments que j'ai donnés. Vous pouvez maintenant voir l'
affichage de nos éléments 1234, 2035, 0660, 3402. Pareil. Donc, au lieu d'écrire l'
étoile d'un plus i, d'
accord, vous pouvez directement
écrire e de I. C'est une
notation générale que nous avons utilisée en travaillant
avec qui est correcte, donc adresse désactivée, vous êtes parti. Permettez-moi de vous montrer ici, lors d'une course, que
c'est la notation
que nous avons utilisée. Supposons des valeurs n pour 122 345,56, voyez la même valeur,
donc l'écart. D'accord ? Désormais, au lieu d'utiliser directement
l'acronyme, vous pouvez également utiliser des pointeurs. Un bon point,
un pointeur entier. D'accord ? Vous pouvez utiliser ce PTR pour pointer. Je m'habille de façon décontractée. Maintenant, en utilisant le pointeur, vous pouvez
accéder à tout ici. Écrivez simplement PTR plus I. Et ici, au lieu d'
écrire votre fichier, vous pouvez écrire le PDR de
départ. Bénis. D'accord. Cela fonctionnera donc également. Cette fois, j'ai donné la valeur
n égale à cinq. Les éléments sont n 2030, 40,50. Encore une fois, consultez l'affichage de
nos éléments 102-030-4050, comme ceci. D'accord ?
11. Pointer et matrices 2D: Dans cette vidéo, nous
verrons comment accéder à un tableau bidimensionnel à
l'aide du concept de pointeurs. Il s'agit donc de pointeurs
et de tableaux 2D. Il s'agit de tableaux bidimensionnels. D'accord ? Maintenant, si vous considérez
ici, en général, la NRA. Supposons que je
considère un tableau bidimensionnel
, comme 23. Cela indique la mescaline Eric, ou laquelle contient combien de Rosa ? Il y a donc deux lignes
et trois colonnes. Il s'agit de deux lignes
et de trois colonnes. Donc, le numéro de ligne, et puis ce sont tous des numéros de
colonne, non ? D'accord ? Donc, si vous regardez
ces emplacements, cela représente zéro pour votre
bureau, d'accord ? Et cela
représente votre 01. C'est aussi le zéro absolu. Cela représente un 0 sur 10, et c'est votre 11. C'est l'ancien 12, comme ça. Maintenant, lorsque je veux stocker une valeur à cet endroit
précis, nous écrivons généralement l'adresse, donc vous pouvez tous écrire zéro. D'accord ? Cela
équivaut clairement à écrire l' année de
début plus zéro plus
zéro en utilisant des pointeurs, d'accord ? Supposons que si vous souhaitez
afficher ce concurrent, c'est le contenu désactivé avec des zéros, zéro que vous souhaitez
afficher à l'aide de l'instruction printf. Alors son équivalent
est en pointeurs. C'est une étoile,
commencez EA plus
zéro plus zéro. D'accord ? Ces deux sont donc équivalentes. De même, ces
deux éléments sont équivalents. Maintenant, laissez-moi
vous montrer clairement ici. Quand je parle de la représentation supposée être l'Adi, d'accord ? Dans le même grenier, moins
de trois heures. Ou est-ce que cette année
représente une bonne chose ? Donc, je veux dire ici, cela représente en fait un
pointeur vers la première ligne. D'accord ? Cela
représente donc directement le pointeur
vers la première ligne. Donc, quand j'écris k plus i, cela représente un pointeur
vers l'IEP, d'accord ? Pointeur vers Je sais, par exemple si j'écris étoile ici plus I. Et cela
représente le pointeur vers le premier élément dans l'
œil et à travers, d'accord ? Tout premier élément de I, lancez quelqu'un si j'écris, commencez ici, plus I et j. Cela représente
donc un pointeur
vers le I délivré dans les yeux. D'accord ? Pointeur vers l'élément. D'accord ? Donc je sais quand je veux dire, commencez, commencez
plus I plus j. Cela représente la
valeur qui est stockée dans l'emplacement IJ, d'accord ? Alors, qui n'est rien d'autre
que la valeur stockée, d'accord ? Dans la représentation ajoutée,
vous pouvez voir la valeur stockée à un emplacement
de I j. C'est le sens ici. D'accord ? Alors maintenant, chaque fois que nous
voulons essentiellement lire les éléments dans un tableau
bidimensionnel, d'accord ? Et affichez également les éléments du tableau bidimensionnel. On peut donc écrire comme ça. Tout d'abord, je vais inclure le fichier d'en-tête
correspondant stdio.h. Maintenant, en utilisant cette
fonction principale, d'accord. Jusqu'à présent, vous pouvez donc
voir qu'il y en a et ajouter huit x trimestriels et que sa
taille est de cinq sur cinq. D'accord ? Et je considère également p, q pour indiquer
la taille de la ligne et colonne Sicer INJ pour les variables de
boucle ici. Maintenant, nous allons d'abord imprimer ou afficher l'utilisateur pour entrer l'ordre de la matrice et
l'ordre de la matrice. Vous devez donc lire cet
ordre de la matrice. Personne, essentiellement des jours-personnes, l'adresse de p
et l'adresse de q, car p représente
la taille des lignes et q représente
la taille de la colonne ici. Ensuite, vous pouvez demander à
l'utilisateur de saisir ordre de la matrice selon lequel les éléments
correspondants, nombre d'éléments est
égal à l'épingle à Q, n'est-ce pas ? Je peux donc écrire des
éléments interpersonnels ici. Et le nombre d'
éléments doit être compris entre deux
nombres Q. D'accord ? Ainsi, une fois que les utilisateurs ont commencé à saisir
ces nombreux aluminiums, vous pouvez les lire
dans le tableau. À l'aide d'une boucle en forme de forme. Je suis égal à zéro pour
parcourir toute la ligne. Donc si inférieur à p I plus, plus. Et de même, pour
j égal à zéro, j inférieur à Q, j plus plus. Maintenant, en utilisant ce
scan de la déclaration, nous pouvons lire en écrivant
ce pourcentage d. Donc, en général, de nos jours, vous
radiez votre adresse ou tout nom que
j'ai considéré comme étant dans MS Excel, vous devez donc
radier notre robe. Désactivé. Je suis. Nous en avons déjà discuté ici. Je m'habille EX Saw Phi J n'
est rien mais tu
dois écrire comme ça, d'accord ? C'est une étoile de
x plus I plus j. Donc, en utilisant des pointeurs, cela
équivaut à
commencer par x plus I plus G. Comme ceci. Maintenant, cela utilise une
instruction scan f que nous sommes en train de lire. Et plus tard, nous allons
afficher le contenu ici. Donc, sous la forme d'une matrice, qui est un tableau
bidimensionnel, c'est du contenu matriciel que
vous pouvez afficher comme ceci. Ainsi, lors de l'affichage, encore une fois, vous pouvez l'utiliser
pour la boucle I égale à zéro I inférieur à p I plus, plus. Cela indique la ligne. Et puis en colonne,
pour j égal à zéro, j inférieur à Q j plus plus plus. Maintenant, nous pouvons imprimer comme ça, imprimer la personne qui devrait être là. C'est à des fins d'impression. Tu dois écrire
Star of Star à partir de we plus j, d'accord ? Parce que cela équivaut
à écrire simplement X de IJ. D'accord ? Ainsi, pour un emplacement en deux dimensions,
vous avez besoin deux étoiles pour accéder au
contenu de cet emplacement. Ensuite, vous devez utiliser une
nouvelle ligne pour qu'après chaque ligne, elle passe
à la nouvelle ligne pour imprimer la ligne suivante
, puis la fermer. C'est donc le
format que nous utilisons ici pour essentiellement lire et écrire le contenu
du tableau bidimensionnel à l'
aide de pointeurs. D'accord ? Maintenant, mettons-le
en œuvre et voyons
si des modifications sont nécessaires. Voici donc
le style du fichier
d'en-tête Respect you stdio.h. Et dans cette fonction principale, considérez un exemple de tableau, qui est un tableau
bidimensionnel. D'accord ? Considérez qu'il y a deux
lignes et trois colonnes. Et je vais les compiler
pour la première fois, d'accord. 456. Et je vais simplement afficher
ces éléments à l'aide de pointeurs. D'accord ? I est une variable de boucle et une variable de boucle
Jason. Maintenant, en utilisant for loop, nous pouvons traiter comme ceci I est égal à zéro, I inférieur à deux, I plus, plus. D'accord ? Parce qu'il représente
la taille des lignes. Maintenant, considérez la taille de colonne 3. Donc J est égal à zéro, j inférieur à trois, j plus, plus. Vous pouvez l'imprimer ici. Imprimer f. Habituellement, nous écrivons à
la personne, elle devrait l'être. D'accord. Notation I, J. Afin d'afficher le contenu
sous forme de matrice. Donc ligne par ligne. D'accord ? Donc, si tu veux, je
peux t'écrire un message. Trucs. Vous pouvez afficher le contenu
des statistiques. Maintenant,
exécutons-les et voyons-les. Donc, pour afficher essentiellement des éléments suivis d'
un espace, vous devez écrire le format WD
en jours personnels, où w représente
la victime. J'ai donc utilisé
trois personnages. Un caractère sera
imprimé et les
deux caractères restants feront
office d'espaces. C'est ainsi que nous imprimons généralement un Adi
bidimensionnel. Maintenant, je vais la remplacer par notation correspondante en utilisant des pointeurs, c'
est-à-dire une étoile, commençant par E a plus I plus j. D'accord ? Maintenant, exécutons ce code
et voyons le résultat. Vous pouvez voir des matrices, il y a
donc deux lignes
et trois colonnes. D'accord ? La même matrice est affichée
dans cette leçon. Donc, comme je l'ai dit, il y a deux indices, car il s'agit d'un tableau
bidimensionnel. Pour accéder au contenu, vous devrez utiliser
une étoile double ici, c'
est-à-dire une étoile et une autre étoile sous l. Si vous n'
écrivez qu'une seule étoile, je vais vous montrer
ce qui se passe ici. Si vous n'écrivez pas à étoiles et que vous n'écrivez pas une
seule étoile comme celle-ci, vous finirez par imprimer
toutes les adresses, d'accord ? Supposons qu'il y en ait un,
puisqu'il s'agit d'un pinceau artistique, vous pouvez voir que le
résultat est celui-ci. Ce sont toutes des adresses
qui sont attribuées à cette matrice particulière. D'accord ? Donc, si vous souhaitez accéder
au contenu qu'il contient, vous devez utiliser
une autre étoile ici. D'accord ? C'est donc un taux tout à fait proche. Maintenant, courons et voyons si vous pouvez voir
ce que vous allez obtenir. Maintenant, supposons que si je
voulais essentiellement lire le
contenu de la matrice,
alors dans ce cas, alors dans ce cas au moment de l'exécution, vous puissiez
stocker comme ceci, par exemple, cela fait
environ dix ici, d'accord ? Et c'est aussi une autre Mary
bidimensionnelle 1010 x dix que je prends. Mais vous pouvez demander à l'utilisateur de saisir
essentiellement l'
ordre de la matrice. D'accord ? Les imprimantes commandent donc souvent des ruptures. D'accord ? Vous devez maintenant lire cette matrice particulière
qui est la DSD de la personne, basée sur la personne, l'adresse p,
la virgule, l'adresse q. D' accord ? Plus tard, vous devrez demander à l'utilisateur de saisir
ces nombreux éléments, exemple le pourcentage d'endos,
c'est-à-dire les éléments. D'accord ? Donc, ce qui signifie exactement
en q éléments. Une fois que l'utilisateur commence à
saisir les éléments de Boltzmann, vous pouvez commencer à les lire. I est inférieur à p, car p représente
la taille de la ligne. Et j est égal à zéro, j inférieur à Q, j inférieur à Q,
j plus, plus parce que j représente la
colonne qui est a. D'accord ? Q représente donc
cette taille de colonne. Maintenant, j'utilise cette instruction du scanner
pour lire ces éléments. Donc, les jours-personnes, c'est bien. Comme l'adresse que je vous ai
déjà montrée, elle représente
clairement l'adresse, n'est-ce pas ? Vous devez donc stocker l'élément à l'intérieur de cette adresse pour pouvoir y accéder. Encore une fois, puisque nous avons
pris p par q comme ordre, vous devez utiliser cet
ordre p par q pour
afficher ces éléments. Exécutons donc ce code
et voyons le résultat. Entrez l'ordre de la matrice, par exemple, ordre de la matrice
est trois par trois. Il vous sera demandé de
saisir neuf éléments. Les éléments sont
123-45-6789, d'accord ? Et vous pouvez maintenant voir que la matrice
est 123-45-6789, comme ceci. D'accord ? Voici donc comment vous pouvez utiliser le
concept de pointeurs pour accéder et le stocker dans le tableau
bidimensionnel. D'accord ?
12. Double pointage: suivant est le double pointeur, ou un pointeur vers un pointeur en C. D'accord ? Donc, vous allez, euh, voici un pointeur vers un
pointeur ou un double pointeur. Donc, la définition générale
d'un pointeur vers un pointeur ou d'un double pointeur est un pointeur pointant
vers l'adresse d'un autre
pointeur, d'accord. Il est donc considéré comme un point directement sur le classeur
ou un pointeur double. Permettez-moi donc d'écrire ici l'adresse rafraîchissante de
Winder un autre
pointeur annulant notre robe. Et l'autre pointeur
est appelé point. Nous pointons du doigt. Vous avez marqué pointeur vers un pointeur
ou un double pointeur. Alors, quelle est la syntaxe générale
d'un tel double pointeur ? Un pointeur vers un pointeur ? Permettez-moi donc de désigner
cet indice de sulfate. La syntaxe générale
sera donc de prendre en compte n'importe quel type de données, mais cela peut signifier désert ou caractère, flotter
ou doubler n'importe quoi. Donc un type de données mais une étoile, étoile, un pointeur vers un pointeur. Ce nom de variable
peut donc être n'importe quoi, mais vous devez
considérer deux étoiles, qui représentent
un double pointeur, pointeur vers un pointeur. Voyons maintenant un exemple de
travail avec des variables. Alors, d'accord, pointez vers un pointeur
à l'intérieur de la fonction principale. D'accord ? Donc d'abord, après avoir
inclus le fichier d'en-tête. Et dans la fonction principale, je considère que celle-ci est
disponible, c'est-à-dire tenir. Et j'envisage également un pointeur unique
ou un classeur normal. Et il s'agit d'un double pointeur
ou d'un pointeur vers un pointeur. D'accord ? Je vais donc d'abord
stocker l'adresse de a au point B et
l'adresse de b dans le pointeur pb. D'accord ? Vous pouvez désormais afficher le contenu à l'aide de Star KPI
ou d'une étoile double ici. Je vais donc vous montrer chaque fois que vous voulez afficher la valeur de k, vous pouvez écrire comme ceci. Vous pouvez également utiliser
une variable pointeur, qui est une étoile p. Vous avez un autre moyen d'
accéder au même contenu. Les deux pointeurs
pointant vers un pointeur présent sont d, étoile double p. D'accord ? Vous pouvez donc accéder au contenu contenu dans
l'emplacement mémoire. Oui. D'accord. Voyons donc ici comment
cela va fonctionner. Tout d'abord, c'est une variable qui contient
la valeur dix. D'accord ? Et P est un point. La décision Agisoft, qui signifie « considérez la
présence de Sophia », est un emplacement de mémoire de 2000 et les frais si le pointeur
contenant l'adresse Sophie Sofia est un 2000 et que p pointe
vers cet emplacement mémoire. D'accord ? Non, chaque
pointeur aura également un taux d'intérêt car celui-ci sera stocké dans
un emplacement mémoire. Et l'emplacement de mémoire
aura une adresse. Supposons que 3 000 soit l'adresse de la variable
pointeur p. Maintenant, l'adresse
correspondante de cette variable pointeur sera stockée à l'intérieur d'
un autre point, qui est un pointeur vers un pointeur. Cela représente donc un
pointeur vers un pointeur et nous
conserverons l'adresse p. Donc 3 000. Vous pouvez voir que le pointeur BB indique qu'un pointeur
contient l'adresse p. D'accord ? Maintenant, lorsque vous commencez à
imprimer la valeur de E, cela
vous donnera un résultat de dix. D'accord ? Ensuite, lorsque vous commencerez à
imprimer l'étoile p., voyons comment cela
va être évalué. L'étoile p représente une étoile. B signifie années 2000. Le contenu contenu dans l'emplacement de Pluton et dans sa
mémoire
sera affiché, qui est à nouveau dix. D'accord. Voyons maintenant comment ce pointeur vers un pointeur
sera évalué. imprimons donc ici
clairement une étoile double BP, qui peut être considérée
comme une étoile. Étoile. La teneur en plomb est de 3 000. D'ici à ici, contenu se trouve dans 3 000
emplacements de mémoire. Alors, quel est le contenu contenu dans
3 000 emplacements de mémoire ici ? Ainsi, le contenu contenu dans 3 000
emplacements de mémoire correspond clairement aux années 2000. Commencez donc par les années 2000, ce qui signifie que le contenu
se trouve dans la mémoire La réponse est dix. Donc, pour afficher la même chose, vous pouvez effectuer
ces actions. Ce sont donc les multiples façons d'accéder au même contenu. Cela signifie que le même contenu
peut être modifié soit directement à l'aide de la variable,
soit à l'aide d'une variable pointeur, l'aide d'un double pointeur
ou d'un pointeur vers un pointeur. Comme ça. Vous pouvez écrire un programme
qui utilise un pointeur vers un pointeur et
également un pointeur unique. Alors maintenant, laissez-moi
vous montrer un exemple, accord, pour ce
pointeur vers un pointeur. Jusqu'à reconsidérer
le fichier d'en-tête. Puis à l'intérieur de la fonction principale. Supposons donc qu'
une variable comme E est égale à dix et que l'étoile, l'étoile double est un
pointeur vers un pointeur. Maintenant, j'utilise P, c'est égal
à je m'habille. Et un autre est
Pb juste là. Donc Pb détient l'
adresse de p. Maintenant, pour
afficher la valeur de Yi, vous pouvez y accéder de plusieurs manières. Ici. J'utilise une nouvelle ligne, d'accord ? Directement, vous pouvez
déjà utiliser une variable. D'accord ? Donc, ici, je vais écrire
que a est égal à. De même, je souhaite
accéder à l'aide
d'un seul pointeur, qui est un contenu correspondant à une étoile
p, à une étoile p. Je vais l'afficher ici. Ensuite, nous
devons imprimer l'étoile double
p. L' étoile p est égale au
pourcentage. L'étoile
double pointue p. D'accord ? Alors maintenant, exécutons ce
code et voyons la réserve. Donc, ici, l'argument de type
invalide de l'opérateur unitaire
star est approfondi. Alors déclarons-nous ainsi. D'accord ? Alors considérez une étoile
double B, d'accord ? Et c'est une étoile p. Cela signifie
que la valeur est
stockée à l'intérieur, n'est-ce pas ? D'accord ? Et il apparaît juste
en neuf lignes ici. D'accord ? Donc, une chose que je fais ici, c'est que l'étoile int p est égale à, et c'est e1 étoile, étoile p égale à. Invalidez un type d'
argument ou d'étoile funéraire. D'accord ? Désolée, ici.
Le problème, c'est qu' ici, nous avons déjà
pris le PSD à point unique. Ils se trouvent sous l'
étoile double P. L'étoile double p, qui est le nom
du double pointeur. Nous avons donc écrit une seule page. C'est exact. Cela montre qu'il s'agit
essentiellement d' un PPE. C'est le nom du double pointeur
que nous avons choisi. Nous devons utiliser le même nom. Vous pouvez voir qu'il
gagne a est égal à dix étoiles p est égal à dix. L'étoile double p est égale à dix. D'accord ? Donc, comme ça, vous pouvez afficher
le contenu, d'accord ?
13. Programme d'exemple dans les doubles: Prenons un exemple qui
implique un pointeur simple
et un pointeur double. D'accord ? Supposons donc que
X est égal à dix. Et je vais considérer nos différentes
variables, comme l'étoile p est un pointeur unique et étoile
double PTR est un
pointeur vers un pointeur. D'accord ? Donc, ici, je considère que p est
égal à Sophie Excel. Nper est égal à
l'adresse de p. D'accord ? Cela signifie donc si vous
effectuez une action via le pointeur p ou
via le double pointeur PTR. Cela affectera donc l'emplacement mémoire alloué aux
variables
, sauf que le contenu de la variable
x est variables
, sauf que le contenu de la mis à jour. Supposons donc que
je fasse PDR à
deux étoiles soit
égale à deux, d'accord ? Une étoile, p plus 25. D'accord ? Enfin, lorsque vous
imprimez la valeur de x, cela affectera la valeur
de x ou la valeur nulle de x. D'accord ? Alors laissez-moi
vous montrer le résultat. Le résultat devrait être 35, d'accord ? Alors pourquoi 35 est la solution ? Comme vous pouvez
observer que l'étoile double PTR représente en fait le contenu de la variable X. Maintenant, ce sera ici, étoile p plus 25. Donc p pointe vers un emplacement mémoire x et
contient la valeur dix. Donc, dix plus 2510 plus
25, la valeur sera 35. PTR est donc le pointeur
qui pointe vers
cet emplacement mémoire et sa
valeur est mise à jour à 35. Et plus tard, nous
afficherons la valeur x. Donc, à l'heure actuelle, la
valeur x est mise à jour à 35, ce
qui signifie qu'il s'agit du
même endroit où nous faisons référence à x et
également égal à l'étoile p. Donc,
toutes ces valeurs sont égales à 35, x est égal à 35. Le démarrage, c'est que si je
double étoile, le PDR est de 35. Voici donc comment vous pouvez
manipuler le contenu d'
un emplacement mémoire à l'aide un pointeur simple ou d'un
pointeur double. Comme ça.
14. Mémoire et fonctions dynamiques: Dans cette session, nous
aborderons la gestion dynamique de la mémoire. D'accord ? C'est ce que l'on appelle également allocation
dynamique de mémoire. Alors, en général, quel est le problème avec cette allocation de mémoire
statique ? D'accord ? Donc, si vous considérez qu'
en langage C, nous utilisons souvent cet emplacement de mémoire
statique. Un exemple de notre emplacement mémoire statique ou
fixe est le suivant supposons que vous
ayez déclaré un d sur cinq, puis un point-virgule. Donc, cela représente en fait qu'il va allouer cinq emplacements de mémoire
contigus. Vous allez allouer cinq emplacements de mémoire
contigus comme suit, 1 234,5. Maintenant, cet emplacement
représente une valeur de zéro. Voici donc votre F1. C'est parti pour trois heures. Et c'est là pour cela
qu'il y aura cinq emplacements de mémoire
contigus. Maintenant, le problème avec l'emplacement de la mémoire
statique est
donc considéré
comme statique ou fixe quant à la manière
d'allouer la mémoire. Le problème ici est donc que si vous
voulez stocker dix éléments, vous ne pouvez pas stocker
car la mémoire ne dispose que de quatre ou
cinq éléments contigus. Si vous
n'utilisez que deux éléments, rappel de l'emplacement de la mémoire, soit cinq moins deux trois emplacements,
sera clairement inutile. La mémoire est viscérale
à trois endroits. D'accord ? Il s'agit donc d'un problème d' emplacement de mémoire
statique ou fixe. D'accord ? Maintenant, pour surmonter ce problème, en C, nous avons un emplacement de mémoire dynamique où vous fournissez de
la valeur de manière dynamique. Et la mémoire est allouée en fonction de la valeur que
vous avez fournie. D'accord ? Ainsi, par exemple, vous prenez une valeur
n au moment de l'exécution et cela peut créer les n emplacements de mémoire
contigus selon vos besoins. D'accord ? Cela est donc considéré comme notre allocation de mémoire
dynamique. Ici. Différentes
fonctions d'allocation dynamique
de mémoire sont disponibles dans C. D'accord ? Ces fonctions sont donc la
première est la fonction malloc. Il s'agit donc d'une fonction malloc. Et en utilisant malloc, nous
attribuons généralement la taille de blancs demandée par l'utilisateur. Ces nombreux octets de mémoire
seront alloués et le pointeur pointera
vers le premier octet de la mémoire, dont nous parlerons
bientôt en détail. Nixon, l'autre est un catalogue. s'agit donc d'une autre fonction de gestion dynamique de la
mémoire laquelle elle va
allouer de l'espace pour une zone d'éléments. Et il
initialisera également tous ces
éléments à zéro. Et il renverra le pointeur
du premier emplacement. D'accord ? Ensuite, il est temps de se libérer. Ceci est utile pour essentiellement désallouer l'
espace mémoire alloué. Précédemment. Vous avez peut-être déjà
alloué de l'espace mémoire en utilisant malloc ou calloc,
mais en utilisant free, vous allez désallouer
la mémoire allouée à l'aide de
malloc calloc, d'
accord, la prochaine étape
consiste à vraiment verrouiller. Ainsi, selon Real Lock, chaque fois que l'espace
mémoire alloué
dynamiquement n'est pas suffisant, vous avez la
possibilité de le déplacer. À quel point tu te demandes. D'accord ? Donc, à cette fin, la fonction de
relocalisation
sera utile, c'
est-à-dire la fonction realloc. Cela vous
aidera donc essentiellement à modifier la taille de l'espace
alloué que vous avez déjà fait. D'accord ? Ces quatre fonctions sont donc les fonctions de
gestion dynamique de la mémoire. D'accord ? Discutons donc en
détail de la toute première fonction, qui est la fonction malloc. D'accord ? Ainsi, comme cette fonction malloc va allouer
le bloc de mémoire, elle l'attribuera
quel que soit le bloc
que vous spécifiez, nombre de blocs que vous souhaitez. OK, donc ces nombreux blocs
de mémoire qu'il va allouer. Et réfléchissez à la manière dont vous
allez l'attribuer
et à la manière dont le pointeur vers le
premier emplacement. La syntaxe générale
du malloc est donc que PTR est égal à
l'étoile de type point. Vous devez spécifier comme
ce type de données une étoile
, puis malloc off en fonction de sa taille. Voici donc la
syntaxe générale de l'utilisation de malloc. D'accord ? Examinons maintenant
un exemple ici. Je vais donc
considérer ici une variable pointeur
appelée int star p. Maintenant p est égal à into star. D'accord ? J'applique Malloc ici dans
Star Malloc Off Bite Size. D'accord, supposons que j'
écrive comme cette fenêtre phi, de
taille cinq dans sizeof int. Cela va donc essentiellement
attribuer cinq à la
taille de l'inducteur, nombre d'octets qu'il
renverra en tant qu'écrivain. La taille de l'entier est donc
essentiellement de quatre octets. Alors cinq sur quatre
est égal à 20. Cela allouera donc 20
octets d'espace mémoire. Et cela sera indiqué
par le pointeur p. D'accord ? Les points a, b
indiqueront ce tout premier emplacement. Alors laissez-moi vous montrer comment
cela va être fait. D'accord ? Donc, tout d'abord, il crée des phi contigus
dans des emplacements de mémoire. Donc phi contigu dans des emplacements
de mémoire. Donc c'est 12345, comme ça. D'accord ? Et considérez que le tout premier
est un endroit appelé
mille, par exemple ce sera mille quatre. C'est mille huit. D'accord ? C'est 1012 et c'est 101,6. Ainsi, des emplacements de
mémoire adjacents phi seront créés. Et p sera un pointeur contenant l'adresse
de base de cet Adi particulier. Donc p est un pointeur. Et cela pointe vers l'adresse
de base comme ceci. D'accord ? Vous allez maintenant observer la création de
cinq
emplacements de mémoire contigus. Et p est un pointeur qui pointe vers l'adresse
de base de l'ensemble du tableau. D'accord ? Cela se fait donc avec
l'aide de Melaka. Supposons que si la mémoire n'
est pas allouée, dans ce cas, p pointe vers null. D'accord ? Supposons qu'il n'y ait pas
d'espace mémoire d'emplacements de
mémoire contigus phi. Dans ce cas, il doit
renvoyer une valeur nulle. Donc, en général, d'accord, si j' utilise un petit nombre,
il sera alloué. Mais supposons que vous
receviez un très grand nombre, d'accord ? Et cet espace
mémoire contigu, d'accord ? Il n'a donc pas
beaucoup d'espace mémoire. Dans ce cas, la valeur Null
sera renvoyée. D'accord ? Il s'agit donc de Malloc. Maintenant, rapidement, nous allons
voir une autre fonction. Pour écrire, n'importe quel
programme peut nécessiter une autre fonction qui
est une fonction libre. D'accord ? Je vais donc d'abord
parler de la fonction libre. Pourquoi ? Parce que vous
devez vous désaffecter à la mémoire qui vous est
allouée, n'est-ce pas ? Il est donc utilisé pour
désallouer la mémoire, qui est localisée à l'aide d'un
pointeur de désallocation de la mémoire. Si vous regardez la
syntaxe générale gratuitement ici. Vous pouvez donc l'écrire
gratuitement sur PDR, écrivant gratuitement sur PTR. Cela libérera donc la mémoire
allouée par le pointeur PTR. D'accord ? Examinons maintenant le même exemple que celui que nous
avons déjà considéré. Il y a une étoile int p. P est égale à une étoile int malloc
de cinq dans une taille de int. Maintenant, après cela, vous
souhaitez désallouer
la mémoire allouée. Vous pouvez donc le faire à l'
aide de écriture
libre, sans p. D' accord, cela va donc désallouer
la mémoire qui est allouée en utilisant le
pointeur p ici, d'accord ? Et pour utiliser ces fonctions,
d'accord, quelle que soit la partie de la gestion dynamique de la
mémoire, vous devez inclure le fichier d'en-tête
correspondant, qui est malloc point hij share. D'accord ? Vous allez donc inclure
Malloc Dotted Share. Envisageons donc
d'écrire un programme ici. Alors, où
allez-vous allouer de la mémoire à l'aide de malloc. D'accord ? Incluez donc d'abord le fichier d'en-tête
standard, qui est un stdio.h. Vous souhaitez
maintenant utiliser cette fonctionnalité
malloc. Donc, à cette fin, incluez Malloc Dot Hijj. Il s'agit d'un dosage malloc. Maintenant, en utilisant la fonction principale. D'accord ? première fois que vous prenez
un pointeur parce que vous avez besoin d'un pointeur pointant
vers l'adresse de base de la mémoire allouée à l'adresse IP
en étoile, DR. D'accord. Et n est une variable et une
autre variable. J' utilise l'IA essentiellement à des fins
d'hydratation. Et n représente nombre d'éléments que
vous souhaitez stocker. D'accord ? Allouons donc de la mémoire
en fonction d'une valeur n en utilisant malloc. Nous pouvons donc d'abord demander à l'
utilisateur de saisir une valeur n ou lui demander de
saisir un certain nombre d'éléments. Alors, combien d'éléments
y a-t-il ? Tu dois entrer. Ainsi, après avoir saisi le
nombre d'éléments, puis en utilisant l'instruction scanner if, nous pouvons lire cette valeur
dans une variable. Il s'agit donc du pourcentage d
d'adresses des jours-personnes dans
lesquels ils sont dissous. D'accord ? Donc, en utilisant cette valeur
n, d'accord ? Nous pouvons donc allouer en utilisant malloc où I PDR pointe vers l'adresse de base de la
mémoire. Ici est égal à. Maintenant, il faut typecast en utilisant Desert Pointer parce que
nous essayons de stocker toutes les
valeurs entières ici, d'accord ? Et attribuez en utilisant malloc la
quantité d'octets
que vous allouez. Donc, ce n'est rien d'autre
que le yen en taille int, taille off en mode occupé. Cela permettra donc d'allouer de la mémoire
aux desserts E&M, n'est-ce pas ? D'accord. Et après cela, en utilisant une valeur n, vous pouvez commencer à stocker des éléments à l'aide d'une instruction
scan f qui convient. Voyons donc comment
cela peut être fait. Tout d'abord, je vais demander à l'utilisateur de
saisir ces nombreux éléments car vous avez
déjà pris la valeur n. Vous devez donc jouer un
certain nombre d'éléments. J'écris entrer les
jours de la personne, c'est d éléments. Ensuite, l'utilisateur commence à entrer
ces nombreuses limites, d'accord ? Et une fois ces
éléments saisis, accord, vous devez commencer
à les
stocker dans la mémoire
allouée à l'aide de malloc. Cela peut donc être
fait à l'aide d'une variable de boucle
i égale à zéro, I inférieur à n i plus, plus. D'accord ? En utilisant le scan d'un relevé,
vous pouvez stocker, n'est-ce pas ? Il s'agit donc d'un scanner. pourcentage devrait être un DR plus I plus I. Donc l'adresse de base est
indiquée par le magnétoscope, d'accord ? Lorsque la valeur I est égale à zéro, forcez-la à stocker l'
élément à cet emplacement. Ensuite, il est incrémenté à l'œil nu. Cela signifie qu'il ira
à l'emplacement suivant et stockera l'élément suivant. C'est ainsi que scanf fonctionne ici. Nous voulons maintenant afficher tous les éléments qui sont
stockés ici en ce moment. Vous pouvez donc écrire une déclaration print f indiquant
la liste des éléments. D'accord ? La liste des éléments. D'accord ? Maintenant, en utilisant for loop, vous pouvez itérer et afficher tous ces éléments
comme I égal à zéro, I inférieur à n i plus plus. Commencez maintenant à afficher
ces éléments à l'aide de l'instruction
fprintf. D'accord ? Alors, où voulez-vous que le contenu se
trouve dans l'emplacement de mémoire ? Utilisez donc une étoile car vous
essayez d'accéder à l'aide
de la variable pointeur IV TR. Donc, étoile de ICTR plus I, à l'aide de laquelle vous pouvez accéder au contenu
de chacun de ces emplacements mémoire, qui est pointé par IPT. D'accord ? Ainsi, une fois l'accès effectué, il
suffit de
désallouer la mémoire déjà
allouée à l'aide de malloc. Pour cela, vous devez
utiliser un code PIN I PTR gratuit. Nous désallouons de la mémoire
qui est allouée en utilisant IP, c'
est-à-dire en utilisant malloc. D'accord ? Voici donc le programme complet. D'accord ? Voyons comment ce programme va fonctionner pour que nous tombions. Dans l'écran de sortie. En général. Il vous sera demandé de
saisir d'abord un certain nombre d'éléments, car l'exécution du
programme commence
lorsque la fonction principale commence, et le tour est
joué, en imprimant cette
instruction, qui se trouve dans le
nombre d'éléments. Supposons donc que
vous ayez saisi un certain nombre d'éléments sous forme de fibre. D'accord ? Alors que se passe-t-il ici ? Cela créera des emplacements de mémoire phi
contigus. D'accord ? Alors considérez ici. Cette création se
fait en utilisant IP TR, d'accord ? I PDR sera le pointeur
qui pointera vers la mémoire
allouée à l'aide de malloc. D'accord ? Ici, nous allons
dire que N est égal à cinq, ce qui signifie que cela créera un phi d'
emplacements contigus comme celui-ci. D'accord ? Non. Malloc doit
dactylographier. Après ça. Nous effectuons une
typecasting dans le désert. Par défaut, ce sera un pointeur large qui est un pointeur
générique. C'est donc là que vous devez taper converti dans le type de données
correspondant, mais sous forme d'IBD ou sous forme de pointeur
entier. OK, vous devez taper
Converted Doing Desert. Une fois
les mémoires situées
ainsi pour une valeur n égale à cinq. D'accord ? Ensuite, si vous regardez l'instruction
suivante ici, entrez le pourcentage d éléments, ce qui signifie que
l'écran de sortie vous demandera que
l'écran de sortie saisir cinq éléments car la valeur
n est cinq ici. D'accord ? Vous pouvez maintenant commencer à saisir
ces cinq éléments. Supposons que vous
ayez saisi 1020304050. Ces éléments sont saisis. Ces éléments
seront donc stockés les uns après les autres ici, 1020304050. Alors pourquoi ? Parce que puisque ma
valeur est zéro, d'accord ? Donc, I PTR plus zéro
représentera cet emplacement. D'accord ? Alors considérez que c'est
notre mille robes. Ce sera mille, 4 008. C'est 1012, c'
est 1016, d'accord ? Maintenant, en utilisant IP TRE,
vous pointez vers l'adresse de base, d'accord ? Nous allons maintenant afficher
la liste des éléments ici. D'accord ? Enfin, il
va afficher la liste des éliminations. La liste des éléments. Les éléments
que vous
affichez utilisent une étoile. Vous essayez d'accéder
à chaque élément ici. Ainsi, les mêmes éléments seront affichés lorsque I sera égal à zéro. Cet élément sera affiché lors de la prochaine itération
lorsque i sera égal à un.
D'accord, le PDR sera
incrémenté d'un emplacement mémoire. Donc, cet élément de 20 sera affiché et ainsi de suite, vous pouvez afficher
tous ces éléments, d'accord ? Et enfin, un
magnétoscope gratuit ou cinq, d'accord ? Cela signifie donc qu'il va
essentiellement désallouer la mémoire allouée à l'aide de l'ICTR. Vous ne
pourrez donc plus accéder à ce contenu. D'accord ? C'est ainsi que fonctionne le malloc et
fonctionne également gratuitement. D'accord ? Voici donc comment vous pouvez
allouer de la mémoire en utilisant malloc et désallouer la
mémoire en utilisant free. Dans la gestion dynamique de la mémoire.
15. Malloc() Exemple: Maintenant, dans ce programme, je vais vous
montrer comment utiliser
ce malloc afin d'
allouer de la mémoire de manière dynamique. Alors, premier fichier d'en-tête en anglais ou en
D, d'accord ? Et incluez également un fichier d'en-tête malloc
point h. D'accord ? Dans la fonction principale,
considérez d'abord le pointeur
appelé étoile I VTR, d'accord ? Et puis I est la variable de boucle. Alors n représente un certain nombre d'éléments
que vous souhaitez stocker. D'accord ? Je vais donc simplement demander
à l'utilisateur de saisir les éléments. Donc nombre d'éléments. D'accord ? Et en utilisant une instruction
scannée, nous pouvons lire une valeur n
ici, soit adoucie. Maintenant, en utilisant cette instruction
print f, nous pouvons demander comme ceci saisir un pourcentage d éléments. D'accord ? Il s'agit donc d'un nombre n d'
éléments que vous devez saisir. D'accord ? Maintenant, en utilisant une boucle à quatre, vous pouvez lire ces éléments
comme I égal à zéro, I inférieur à n i plus plus. Et en utilisant cette déclaration, d'accord. Donc, une fois que vous voulez essentiellement
entrer et stocker, d'accord. Donc, ce qu'il faut, c'est allouer de la mémoire, n'est-ce pas ? Donc, une fois que
l'utilisateur commence à saisir le nombre d'éléments, vous devez allouer de la mémoire, c'
est-à-dire en utilisant malloc,
vous allouez ici l'IPR est égal à, d'accord. J'ai donc presque exaucé un souhait. Ensuite, en désactivant le malloc, je répartis par emplacements. Et chaque lieu est
souvent dissident, n'est-ce pas ? C'est donc la taille d'InDesign. D'accord ? Donc, honnêtement,
les souvenirs sont localisés maintenant. Nous allons stocker ici. Donc c'est un IP DR plus i. OK ? Voici donc comment
vous pouvez stocker ici. Et puis maintenant, nous voulions afficher ces éléments
qui sont stockés ici. Je peux donc simplement
imprimer la déclaration indiquant l'affichage des éléments. Donc, pour afficher des éléments, vous avez besoin, encore une fois, de cette
boucle à échanger. D'accord ? Mais imprimez une déclaration
pour afficher le contenu. Donc, pourcentage d. D'accord. Pour accéder au contenu qu'il
contient en utilisant Star, vous pouvez accéder
ici à I PTR plus I. Et enfin, nous allons désallouer la mémoire qui est
allouée en utilisant IP DR. D'accord ? Exécutons donc ce code
et voyons le réservé. Vous pouvez voir qu'il vous demande
de saisir un certain nombre d'éléments. Je saisis la valeur cinq. Maintenant. Je saisis le 102-030-4050. D'accord ? Donc, les mêmes éléments qui
sont affichés ici. Si vous voulez qu'ils soient
affichés dans un certain format, d'accord, alors vous pouvez utiliser
cette personne, cette 40. Alors, entrons cette fois. Trois éléments seulement, d'accord ? Ces trois éléments
sont comme 102030. Nous pouvons donc observer
ici l'affichage ces trois éléments, 102030. Quelle que soit la valeur n
que vous donnez. Ces nombreuses mémoires
allouées de manière contiguë sont créées. À l'aide de la fonction de
gestion dynamique de la mémoire ,
qui est malloc. Le pointeur
pointera vers le premier emplacement. D'accord ? C'est ainsi que cette fois je saisis un nombre d'
éléments égal à dix. Supposons donc que ces dix
éléments soient comme ça. D'accord ? Vous pouvez maintenant voir ici afficher
les éléments 1234 à dix. Tous ces éléments
sont affichés ici. D'accord ? Maintenant, que se passe-t-il
lorsque vous essayez d'abord de désallouer
, puis d'
accéder au contenu ? Superposons que je remplace
la déclaration que je supprime ici et que je place ici. D'accord ? Ensuite,
vous n' êtes pas en mesure d'
accéder à ce contenu. Vous pouvez le voir parce que les
souvenirs sont localisés. Mais plus tard, vous avez désaffecté
la mémoire, n'est-ce pas ? Ainsi, quel que soit le contenu, certaines valeurs
inutiles stockées dans ces emplacements
seront imprimées ici. D'accord ? Parce que vous avez alloué de
la mémoire en utilisant malloc ici. Et stockez ensuite le contenu
à l'aide du pointeur que vous avez enregistré. Et plus tard, vous
avez immédiatement perdu de la mémoire. Maintenant, vous essayez d'
afficher le contenu, d'accord ? Alors, dans ce cas, que se passe-t-il puisqu'il est
déjà attribué ? D'accord ? Vous essayez maintenant d'afficher
à ces emplacements des valeurs inutiles, seront
donc imprimées. D'accord ? Le bac, vous
devez le faire via la
localisation de vos
utilisations, est donc terminé. D'accord ? Comme ça.
16. Calloc(): Nous allons maintenant discuter de l'évolution. Fonction suivante, qui est une fonction de
gestion dynamique de la mémoire appelée catalogue. Donc, en général, dans cette fonction de
catalogue, elle allouera réellement. Tout comme Malloc. Il allouera également de la mémoire. Mais ici, nous allons
allouer principalement ces
blocs de mémoire. Malloc. Vous pouvez dire ce type d' octets de mémoire que
vous déplacez. Mais dans le catalogue, vous
allouez des blocs de mémoire, comme le nombre N de blocs que vous souhaitez déléguer,
vous pouvez les allouer. Il alloue donc des
blocs de mémoire. D'accord ? Examinons maintenant
cette syntaxe. Donc, Kellogg, la
syntaxe de Kellogg peut être PTR
égale au type de données star. D'accord ? Vous devez donc rédiger un catalogue. Donc, en général, en malloc, vous
écrirez et signifiez deux
tailles de type de données. Mais ici, il s'agit de la taille N de
virgule du type de données. Il y aura deux arguments
pour la fonction Kellogg. Le premier est le nombre de blocs
suivi de la taille de chaque bloc. D'accord ? Vous devez donc
fournir ici la taille du type de données. D'accord ? Voici donc la syntaxe
générale ici. D'accord ? Maintenant, une fois que vous avez alloué de
la mémoire à l'aide du catalogue, la mémoire
contiendra différents emplacements, d'accord ? Ils l'
initialiseront donc automatiquement à zéro, d'accord ? Chacun des blocs de mémoire
sera rempli de zéro. Laissez-moi donc vous montrer ici
comment cela va fonctionner. Prenons donc un exemple. Comme dans l'étoile p.
Donc p est le pointeur. Maintenant, B est égal à. Donc, en utilisant le catalogue, nous
allouons de la mémoire ici. Alors, la star Galois, tousse. Supposons que j'écrive
dix virgules dans desert. Donc, ici, il va
allouer de la mémoire, qui est une mince quantité
de mémoire, d'accord ? Et chaque emplacement ou bloc est de taille différente, de type désertique. Et il remplira
automatiquement chaque bloc contenant des
données sous la forme de zéro. D'accord ? Examinons donc ici. B est le pointeur, d'accord ? Pointer vers l'adresse
de base de la mémoire,
qui est localisée. Donc, c'est le premier, premier, et ainsi de suite, comme ça. D'accord ? Supposons que vous considériez la
dislocation comme dans les années 2000. Et la taille de l'entier
est de quatre octets. D'accord ? Vous allez donc voir comme
ceci et ainsi de suite. Maintenant, nous allons conserver l'adresse de
base de cette mémoire. Et chaque emplacement
sera automatiquement
rempli de zéros dans un premier temps,
selon le catalogue. La principale différence
entre Carlo Can Malloc réside dans le catalogue. Nous faisons valoir deux arguments. D'accord ? Alors que dans le cas de Malloc, nous ne faisons passer qu'un seul argument. Dans le cas du pétoncle, nous allouons des
blocs de mémoire. Ce malloc, nous
allouons des octets de mémoire. Voici donc comment se trouve l'
ensemble de la mémoire et les différences dans le catalogue chacun de ces emplacements
seront initialisées à zéro. Alors que dans le cas de Malloc. Il y aura des
valeurs nulles, d'accord ? Il y aura des valeurs nulles. Écrivons donc un programme qui utilise cette fonction
calloc
afin de créer de
la mémoire de manière dynamique. D'accord ? Alors commençons par inclure
le fichier d'en-tête, qui est stdio.h, d'accord ? Et incluez également le fichier d'en-tête malloc
dot h. D'accord ? Considérons maintenant la fonction principale. D'accord ? Donc, dans le cadre de cette fonction principale, je comprends votre point de vue. Une variable similaire à celle que nous avons précédemment
considérée comme IBD est similaire
ici . Je considère également une étoile variable
pointeur I PTR. Maintenant, nous devons
demander à l'utilisateur de saisir
un certain nombre d'éléments. Voici donc le nombre d'éléments. D'accord ? Ainsi, une fois que l'utilisateur a saisi un certain nombre d'éléments au lieu d'utiliser scan f, nous pouvons souvent lire ce
nombre d'éléments ,
comme le pinceau d'identification des jours de personne. D'accord ? Maintenant, en utilisant IV TR, nous pouvons attribuer des
emplacements, d'accord ? Nous l'appelons donc car n
blocs de mémoire peuvent être alloués à l'aide de calloc, tous dans des blocs désertiques que j'utilise ici. Donc, dans Star Catalog off à Goma, taille de, dans le désert,
entre virgules. D'accord. Nous devons maintenant demander à l'utilisateur de saisir
ces nombreux éléments. D'accord ? Ce sont donc les
goûts interpersonnels, les éléments. D'accord ? Donc, une fois que vous avez saisi
ces nombreux éléments, ils doivent être stockés, n'est-ce pas ? Donc, quelle que soit la mémoire
allouée à l'aide du catalogue, à l'aide de laquelle vous pouvez
stocker ces éléments. I est égal à zéro I
inférieur à n I plus plus et en utilisant un scanner, d'accord, vous pouvez stocker ici, c'
est-à-dire une personne, les jours
de l'IBT sont inférieurs. D'accord ? Vous pouvez donc stocker
les éléments ici. Maintenant. Vous pouvez afficher les
éléments de cette manière. Imprime f, la liste des éléments. D'accord ? Vous pouvez donc écrire ainsi
la liste des éléments. D'accord ? Maintenant, vous pouvez observer
ici i égal à zéro, I inférieur à I, moins Appuyez sur. D'accord. Imprimons maintenant ces éléments l'aide du pointeur auquel nous pouvons accéder. D'accord ? Comme démarrer l'IPT ou l'augmenter, d'accord ? Vous pouvez y accéder. Enfin, vous
pouvez essentiellement y
lire les éléments et
les afficher. Nous pouvons maintenant désallouer la
mémoire qui est localisée. Encore une fois, écrivez sans IP DR, afin que toutes les mémoires localisées soient libérées. D'accord ? Donc, si vous regardez ce programme, d'accord, comparez-le
au programme Malloc. C'est assez similaire, sauf que cette
ligne particulière varie, où vous avez alloué de
la mémoire à l'aide du catalogue ici. Et la syntaxe du Kellogg. Kellogg off en virgules (
taille du type de données). D'accord ? C'est donc le seul changement. D'accord ? Travaillons donc dessus et
affichons le contenu. Tout ce qui est pris. Non, ici. Lisons ce pointeur en I, d'accord ? À la fin aussi. Donc, ici, nous allons inviter
l'utilisateur à entrer. Nombre d'éléments Nombre d'éléments D'accord ? Donc, en utilisant le scan de la déclaration
, nous pouvons la lire. Donc, le pourcentage devrait être correct. Maintenant, en utilisant IP TR, nous allons allouer de la
mémoire à l'aide de calloc. Donc, ici, dans Star, Catalog off souvent en taille de karma. D'accord. Passons maintenant à
ces nombreux éléments. Nous pouvons donc demander à l'utilisateur de
saisir ces nombreux éléments, soit un nombre n d'éléments. D'accord ? Ainsi, une fois que vous commencez à saisir ces nombreux éléments en utilisant
for loop, vous pouvez le lire. I est égal à zéro, I inférieur à n I plus plus. En utilisant l'instruction scanf, nous pouvons
lire le pourcentage d, d'accord ? Un magnétoscope et un autre,
d'accord. d'accord. Nous pouvons maintenant commencer à afficher
ces éléments ici. Imprime f, d'accord ? La liste des éléments
que vous pouvez afficher. D'accord ? Donc, en utilisant
for loop pour I égal à zéro, I inférieur à I plus, plus. D'accord ? En utilisant l'impression d'une déclaration, nous pouvons afficher le goût de
l'imprimante, de la personne. Sois. D'accord. Supposons que je veuille des
espaces lors de l'affichage. Tu peux commencer par I PTR plus i. OK. Enfin, vous pouvez désallouer
la mémoire
allouée à l'aide du
pointeur IBD. D'accord, à l'aide du
catalogue que vous avez alloué. D'accord ? Exécutons donc ce code
et voyons le résultat. Entrez le nombre d'éléments. J'ai saisi le nombre d'
éléments comme cinq ici. D'accord ? Les éléments
sont donc 102-030-4050. D'accord ? Vous pouvez voir qu'ils affichent exactement
ces éléments. Que se passe-t-il lorsque je supprime
ce DR gratuit ici et que je l'utilise ici. D'accord ? Alors, exécutons-le
et voyons la réserve. Cinq éléments et 2030, 40, 50. D'accord ? Encore une fois, vous pouvez voir ici que
vous désallouez de la mémoire, d'accord ? Donc, après avoir désalloué
la mémoire à laquelle vous
essayez d'accéder au débit,
c'est un problème. D'accord ? Dans ce cas, vous
obtiendrez des valeurs nulles. D'accord ? C'est pourquoi vous devez
toujours l'utiliser sans IBD après avoir
alloué la mémoire. C'est-à-dire après avoir accédé à tous les éléments, puis
commencé à déallouer de la mémoire. Encore une chose, supposons que
vous n'utilisiez pas
ces lignes pour saisir des éléments, d'accord ? Et stocker ces éléments
dans cette mémoire. Dans ce cas, quelle
sera la réserve ? D'accord ? Supposons donc que j'aie
saisi les valeurs cinq. Et vous pouvez voir que la
liste des éléments composée de zéros, de zéros, de zéros 00. Pourquoi ? Parce que selon le catalogue, une fois
les mémoires localisées, d'accord, tous les zéros de
ces
emplacements de mémoire seront remplacés par défaut. C'est pourquoi vous obtenez des valeurs
par défaut sous forme de zéros. D'accord ? C'est ainsi que fonctionne le catalogue.
17. Réallocation(): Donc, le prochain est un vrai verrou. D'accord ? Donc, en cas de droit réel, nous allons déplacer la mémoire si la
mémoire actuellement allouée est insuffisante. Ainsi, l'allocation d'un peu de
mémoire peut être effectuée à l'aide de
malloc ou de calloc. Vous commencerez à
allouer de la mémoire ultérieurement. Tu veux augmenter la mémoire, d'accord ? Vous pouvez donc commencer à utiliser Real OK. OK, en utilisant le journal, vous pouvez réallouer de la mémoire. Syntaxe générale pour cela. Le vrai verrouillage sera, vous pouvez écrire comme si
ce nouveau PDR était égal au type de données étoile. Véritable verrouillage du type de données Star, oui, verrouillez toutes les virgules
PDR, la nouvelle taille ou la taille commune du PDR. D'accord ? Il s'agit donc d'une véritable syntaxe
correspondante au verrou. Alors, qu'entend-on
par ancien PTR ici ? D'accord ? Je peux donc écrire ici où l'ancien PTR représente
en fait le pointeur qui
pointe vers le bloc de mémoire qui est
déjà alloué l'aide de malloc ou calloc, comme ils l'ont indiqué horizontalement, allouera de la mémoire. Utiliser malloc ou calloc write. Ce pointeur mondial représente
en fait le pointeur pointant
vers l'ancienne mémoire. À la mémoire. Et cette mémoire est allouée
en utilisant malloc ou calloc. D'accord ? Cela représente donc
cette mémoire orale. Maintenant, qu'est-ce que le nouveau soleil ? La nouvelle taille représentera donc taille
mise à jour que vous souhaitez
allouer en utilisant un vrai casier. Je peux donc écrire ici la taille
du nouveau bloc, d'accord ? Ou taille du bloc
à déplacer. Encore
une fois, une fois que vous aurez déplacé
la mémoire, un nouveau point, rien ne vous indiquera la mémoire nouvellement allouée en utilisant un vrai OK. Permettez-moi donc de vous
montrer un exemple ici. Prenons donc un exemple
utilisant real alias première fois en considérant qu'
un pointeur déçu ici dans l'étoile b. Maintenant, j'alloue de la mémoire en utilisant malloc pour ce
pointeur inducteur. C'est donc dans l'
étoile Malloc Off. Nous pouvons écrire, par exemple « Je veux allouer
n emplacements de mémoire ». Donc, dix en taille réduite en
dix en taille int. D'accord ? Il attribuera donc dix emplacements et chacun
aura une taille entière. Maintenant, nous pouvons allouer
en utilisant de l'ocre jaune. Donc, si la
mémoire déjà allouée n'est pas suffisante. D'accord ? Vous allez donc
localiser en utilisant un vrai verrou. Supposons que je
veuille 20 emplacements, nouvelles tailles, 20, par exemple pour pouvoir écrire
dans Star Real Lock Off. Alors, quel est le pointeur mondial ici ? J'utilise le mot pointeur, un nouveau pointeur, les deux
ayant le même P uniquement. Donc ancien pointeur, nouvelle taille commune. En ce moment, j'
attribue de nouvelles tailles. 2010 sites, soit dix
pâtés de maisons, sont localisés. Maintenant, c'est 20 blocs. Nous sommes en train de déménager. Le pointeur mondial et le nouveau
pointeur sont tous deux identiques, ce qui signifie que le nouveau
pointeur sera le même point que p
pointera
vers la mémoire nouvellement allouée. D'accord ? Donc, précédemment,
vous pouvez voir qu'il
y a dix blocs de mémoire. Dix sur quatre
équivaut à 40 octets de
mémoire alloués. Mais en utilisant cela, ce
sera 2020 sur quatre, soit 80 octets de
mémoire
qui seront alloués. Pour les deux, nous utilisons le même
pointeur vers point. P va maintenant pointer
vers la mémoire mise à jour, qui est de 80 octets de mémoire. D'accord ?
Examinons maintenant un exemple ici. Pour de vrai, alias. D'accord, donc d'abord, je vais essentiellement envisager d'allouer
un pointeur de caractère. Permettez-moi de mettre en œuvre directement. D'accord ? J'utilise donc un pointeur de
caractère ici. Je l'utilise comme pointeur de caractères. Alors, où je peux l'écrire
sous forme de nom d'étoile de la voiture, par exemple, d'accord, nom de l'étoile. Voici donc mon pointeur de caractère utilisant le terme
allocation de mémoire. Donc, ce nom est
égal à, d'accord. Alors lancez Malloc. D'accord.
Supposons donc que j'alloue dix emplacements contigus et chacun soit du type de données de type caractère,
mais donc, ce qui signifie que la taille
des caries, un octet, dix en un, correspond à dix octets de mémoire que j'alloue
en utilisant malloc. D'accord ? Alors maintenant, je veux
y copier du contenu. Vous pouvez utiliser
STR CPI pour la copie. Mais pour cela, vous devez inclure un autre profil élevé qui est un fichier d'en-tête string
point h. Fichier d'en-tête String Dot H. D'accord ? Donc, une fois que j'ai inclus, nous sommes
maintenant libres d'utiliser
cette STR pour voir BY. D'accord. J'écris donc sur le placement
d'une chaîne appelée Hyderabad. D'accord. Donc, après l'avoir copié, nous essayons
maintenant
d'imprimer le nom qui se
trouve à cette adresse
particulière. Bien, supposons que je
vais essayer de les imprimer. Le nom que je stocke,
qui est un sac hydrofuge, et qui est enregistré
à l'adresse. D'accord. Donc, l'iris est un pourcentage p. d'accord ? Nous pouvons donc l'écrire sous forme
de nom, de virgule. Vous pouvez donc absorber qu'un nom pour la
première fois sera imprimé dans le format de
chaîne exact, d'accord ? Mais la deuxième fois, vous
pouvez voir le même nom, mais le pourcentage d'utilisateurs SBus, c'
est-à-dire l'adresse,
sera affiché. D'accord ? Maintenant, cela utilise le malloc que
nous avons alloué, supposons que je veuille
stocker une chaîne plus grande. D'accord ? Donc, dans ce cas, ce
n'est pas un écrivain suffisant, je vais
donc utiliser le verrouillage gratuit. Supposons une étoile. D'accord. J'utilise donc realloc et j'alloue ici. Supposons qu'il y ait 15
caractères et que vous essayez de stocker. Il s'agit donc d'un type de taille de
caractère. D'accord ? Donc ici aussi un point-virgule,
ici aussi un point-virgule. D'accord ? Maintenant, j'essaie de
copier une autre chaîne. D'accord ? Supposons que le nom soit une virgule. Il nous suffit donc de prendre
une corde plus grande. D'accord ? Je vais donc enlever une ficelle
comme un mini pour ça. D'accord ? Le nombre de caractères est donc supérieur au nombre de
caractères à Hyderabad. Alors maintenant, imprimons de la
même manière ici également. l'heure actuelle, le nom, l'adresse
correspondante, j'essaie également d'afficher
avec le nom. D'accord ? Ainsi, une fois que vos utilisateurs ont terminé, vous pouvez simplement
allouer la mémoire
allouée ici. Donc sans nom, l'aide duquel vous pouvez désallouer la mémoire qui se trouve ici. Exécutons ce code
et voyons réservé. OK, alors j'ai essayé
de l'utiliser ici, d'accord. Nous
imprimons donc déjà uniquement sur une autre ligne. D'accord ? Donc, ici, une entaille
et là aussi une entaille. Maintenant, vous pouvez voir que le nom est
Hydro Bot, ce n'est pas notre robe. D'accord. Vous pouvez consulter l'adresse
correspondante attribuée à cet effet. Maintenant, le nom est Minneapolis, et ce sont normalement des couches à
cette adresse particulière. D'accord.