Pointeurs en C | Surendra Varma | Skillshare

Vitesse de lecture


1.0x


  • 0.5x
  • 0.75x
  • 1 x (normale)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Leçons de ce cours

    • 1.

      Intro de pointeurs

      1:01

    • 2.

      Comprendre les pointeurs

      16:23

    • 3.

      arithmétique

      6:52

    • 4.

      Pointeurs comme paramètres

      3:44

    • 5.

      Pointer à une fonction

      4:56

    • 6.

      Accéder à la chaîne à l'aide de pointeurs

      2:37

    • 7.

      Comparaison à chaînes à l'aide de pointeurs

      6:30

    • 8.

      Concaténation à chaînes à l'aide de pointeurs

      5:51

    • 9.

      Trouver la longueur de la corde à l'aide de pointeurs

      6:06

    • 10.

      Pointer et matrices 1D

      15:41

    • 11.

      Pointer et matrices 2D

      17:46

    • 12.

      Double pointage

      10:31

    • 13.

      Programme d'exemple dans les doubles

      2:41

    • 14.

      Mémoire et fonctions dynamiques

      21:22

    • 15.

      Malloc() Exemple

      7:09

    • 16.

      Calloc()

      15:25

    • 17.

      Réallocation()

      11:01

  • --
  • Niveau débutant
  • Niveau intermédiaire
  • Niveau avancé
  • Tous niveaux

Généré par la communauté

Le niveau est déterminé par l'opinion majoritaire des apprenants qui ont évalué ce cours. La recommandation de l'enseignant est affichée jusqu'à ce qu'au moins 5 réponses d'apprenants soient collectées.

28

apprenants

--

projet

À propos de ce cours

Notre cours sur les pointeurs en C couvrira les principes fondamentaux des pointeurs et la façon dont ils sont utilisés dans le langage de programmation en C.

Nous commencerons par expliquer ce que sont les pointeurs et comment ils diffèrent des variables régulières. Nous découvrirons ensuite comment déclarer et initialiser les pointeurs, ainsi que comment attribuer les valeurs aux pointeurs et les extraire à partir des.

Ensuite, nous explorerons le concept d'arithmétique de pointeur et la façon dont il peut être utilisé pour manipuler les structures de données en mémo. Nous discuterons également les différents types de pointeurs, comme les pointeurs de fonction.

Tout au long du cours, nous fournirons des exemples et des exercices pratiques pour renforcer les concepts couverts. À la fin du cours, vous aurez une bonne compréhension des pointeurs en C et serez en mesure de les utiliser efficacement dans vos propres programmes C.

Rencontrez votre enseignant·e

Teacher Profile Image

Surendra Varma

Best Instructor

Enseignant·e

The name of the instructor is Surendra varma.

He is a winner of  BEST TEACHER award.

He is a winner of  Young Achiever award.

He holds Bachelors degree in Computer Science & Masters degree in Computer science. He cracked toughest exams in computer science such as GATE & UGC-NET with flying colors. Also, he is a university topper during masters.

He is currently Pursuing PhD from world's most reputed university Indian Institute of Sciences(IISC), Bangalore.

He worked with various EdTech companies in India including Great Learning. He always received best feedback from his students.

He has 14+ Years of experience in Teaching/research/Industry.

He worked in various roles like Software Engineer... Voir le profil complet

Level: All Levels

Notes attribuées au cours

Les attentes sont-elles satisfaites ?
    Dépassées !
  • 0%
  • Oui
  • 0%
  • En partie
  • 0%
  • Pas vraiment
  • 0%

Pourquoi s'inscrire à Skillshare ?

Suivez des cours Skillshare Original primés

Chaque cours comprend de courtes leçons et des travaux pratiques

Votre abonnement soutient les enseignants Skillshare

Apprenez, où que vous soyez

Suivez des cours où que vous soyez avec l'application Skillshare. Suivez-les en streaming ou téléchargez-les pour les regarder dans l'avion, dans le métro ou tout autre endroit où vous aimez apprendre.

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.