C++ pour les débutants | Primorous Arts | Skillshare
Recherche

Vitesse de lecture


1.0x


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

C++ pour les débutants

teacher avatar Primorous Arts, Course Instructor

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.

      Introduction

      2:45

    • 2.

      Chapitre 1 (Setup) : installer Visual Studio

      4:48

    • 3.

      Chapitre 1 (Setup) : mettre tout le monde sur la même page

      3:19

    • 4.

      Chapitre 2 (Hello World) : expliquer le code

      12:26

    • 5.

      Chapitre 2 (Hello World) : espace blanc

      2:29

    • 6.

      Chapitre 2 (Hello World) : écrire pour

      8:12

    • 7.

      Chapitre 2 (Hello World) : Commentaires

      3:45

    • 8.

      Chapitre 3 (Variables) : Introduction aux variables

      6:24

    • 9.

      Chapitre 3 (Variables) : Entiers

      7:42

    • 10.

      Chapitre 3 (Variables) : points flottants

      6:40

    • 11.

      Chapitre 3 (Variables) : Booléens

      6:24

    • 12.

      Chapitre 3 (Variables) : caractères

      4:14

    • 13.

      Chapitre 3 (Variables) : cordes

      8:39

    • 14.

      Chapitre 3 (Variables) :

      4:55

    • 15.

      Chapitre 4 (Entrée utilisateur) : entrée utilisateur Cin

      9:32

    • 16.

      Chapitre 4 (Entrée utilisateur) : fonctions Getchar et Getline

      6:25

    • 17.

      Chapitre 4 (Entrée utilisateur) : chaîne à entrée

      6:09

    • 18.

      Chapitre 5 (Opérateurs) : arithmétique de base

      5:48

    • 19.

      Chapitre 5 (Opérateurs) : incrément et décrément

      7:28

    • 20.

      Chapitre 5 (Opérateurs) : module

      1:55

    • 21.

      Chapitre 5 (Opérateurs) : signature

      2:18

    • 22.

      Chapitre 5 (Opérateurs) :

      4:15

    • 23.

      Chapitre 5 (Opérateurs) : coulage et tronquer

      9:02

    • 24.

      Chapitre 6 (contendus) : champ d'application

      4:01

    • 25.

      Chapitre 6 (contendus) : Introduction aux contendus

      1:27

    • 26.

      Chapitre 6 (contendus) : opérateurs relationnels et en égalité

      3:02

    • 27.

      Chapitre 6 (Contives) : opérateurs logiques

      2:16

    • 28.

      Chapitre 6 (contendus) : instructions de type if

      6:36

    • 29.

      Chapitre 6 (contendus) : instructions d'imbrication de si

      6:17

    • 30.

      Chapitre 6 (contendus) : instructions If-Else

      3:07

    • 31.

      Chapitre 6 (contendus) : instructions Else-If

      7:10

    • 32.

      Chapitre 6 (contendus) : instructions de commutation

      10:44

    • 33.

      Chapitre 6 (Contives) : opérateur ternaire

      9:42

    • 34.

      Chapitre 7 (Boucles) : introduction aux boucles

      1:05

    • 35.

      Chapitre 7 (Boucles) : pendant les boucles

      7:29

    • 36.

      Chapitre 7 (Boucles) : boucles de Do While

      3:13

    • 37.

      Chapitre 7 (Boucles) : pour les boucles

      7:53

    • 38.

      Chapitre 7 (Boucles) : boucles d'imbrication

      3:39

    • 39.

      Chapitre 7 (Boucles) : instructions de pause

      8:49

    • 40.

      Chapitre 7 (Boucles) : poursuivre les instructions

      5:40

    • 41.

      Chapitre 7 (Boucles) : validation des entrées utilisateur

      14:26

    • 42.

      Chapitre 7 (Boucles) : opérateur de résolution de portée

      2:40

    • 43.

      Chapitre 8 (Nombres aléatoires) : introduction aux nombres aléatoires

      3:53

    • 44.

      Chapitre 8 (Nombres aléatoires) : générer des nombres aléatoires

      8:19

    • 45.

      Chapitre 9 (Récipients) : introduction aux récipients

      1:27

    • 46.

      Chapitre 9 (Récipients) : tableaux

      7:52

    • 47.

      Chapitre 9 (Récipients) : tableaux multidimensionnels

      10:07

    • 48.

      Chapitre 9 (Récipients) : Vecteurs

      11:25

    • 49.

      Chapitre 9 (Récipients) : files d'attente

      7:13

    • 50.

      Chapitre 9 (Récipients) : piles

      4:37

    • 51.

      Chapitre 10 (boucles de Foreach ) : introduction aux boucles de Foreach

      1:44

    • 52.

      Chapitre 10 (boucles de Foreach ) : boucles de Foreach

      14:08

    • 53.

      Chapitre 10 (boucles de Foreach ) : Mot-clé automatique

      8:07

    • 54.

      Chapitre 10 (boucles de Foreach ) : Cartes

      12:12

    • 55.

      Chapitre 10 (boucles de Foreach ) : itérateurs

      11:07

    • 56.

      Chapitre 11 (Enums) : introduction à Enums

      3:12

    • 57.

      Chapitre 11 (Enums) : créer un enum

      5:11

    • 58.

      Chapitre 11 (Enums) : utiliser Enums

      10:59

    • 59.

      Chapitre 11 (Enums) : Eums et Enum Classes

      4:04

    • 60.

      Chapitre 12 (Fonctions) : Introduction aux fonctions

      2:39

    • 61.

      Chapitre 12 (Fonctions) : créer une fonction

      6:46

    • 62.

      Chapitre 12 (fonctions) : prototypes de fonction

      2:58

    • 63.

      Chapitre 12 (fonctions) : types de retour

      7:49

    • 64.

      Chapitre 12 (fonctions) : paramètres et arguments

      6:45

    • 65.

      Chapitre 12 (Fonctions) : arguments optionnels

      5:58

    • 66.

      Chapitre 12 (Fonctions) : fonctions surchargées

      4:38

    • 67.

      Chapitre 12 (Fonctions) : récursion

      7:32

    • 68.

      Chapitre 12 (fonctions) : tableaux en tant que paramètres

      8:17

    • 69.

      Chapitre 13 (références) : Introduction aux références

      1:28

    • 70.

      Chapitre 13 (références) : créer une référence

      3:32

    • 71.

      Chapitre 13 (références) : références et boucles de Foreach

      4:01

    • 72.

      Chapitre 13 (références) : références en tant que paramètres

      4:17

    • 73.

      Chapitre 13 (références) : références en tant que types de retour

      7:31

    • 74.

      Chapitre 13 (références) : adresses mémoire

      4:20

    • 75.

      Chapitre 14 (Pointeurs) : introduction aux pointeurs

      1:14

    • 76.

      Chapitre 14 (Pointeurs) : créer un pointeur

      9:45

    • 77.

      Chapitre 14 (Pointeurs) : pointeurs NULL

      3:52

    • 78.

      Chapitre 14 (Pointeurs) : pointeurs et fonctions

      6:20

    • 79.

      Chapitre 14 (Pointeurs) : pointeurs et tableaux

      10:44

    • 80.

      Chapitre 14 (Pointeurs) : pointeurs et références

      2:56

    • 81.

      Chapitre 15 (Cours) : introduction à la POO

      4:03

    • 82.

      Chapitre 15 (Cours) : créer un cours

      5:59

    • 83.

      Chapitre 15 (Cours) : objets de cours

      1:59

    • 84.

      Chapitre 15 (Cours) : spécificités d'accès

      4:32

    • 85.

      Chapitre 15 (Cours) : fonctions de cours

      6:12

    • 86.

      Chapitre 15 (Cours) :

      10:32

    • 87.

      Chapitre 15 (Cours) : initialisateurs de liste

      5:50

    • 88.

      Chapitre 15 (Cours) : encapsulation, abstraction et propriétés

      16:11

    • 89.

      Chapitre 15 (Cours) : héritage

      29:24

    • 90.

      Chapitre 15 (Cours) : récapitulation des cours

      27:44

    • 91.

      Chapitre 15 (Cours) : mot-clé statique

      18:07

    • 92.

      Chapitre 15 (Cours) : cours et structure

      3:06

    • 93.

      Chapitre 15 (Cours) : empêcher la création de cours de base

      2:01

    • 94.

      Chapitre 15 (Cours) : opérateurs d'accès aux membres

      2:57

    • 95.

      Chapitre 15 (Cours) : polymorphisme

      19:00

    • 96.

      Chapitre 15 (cours) : quatre principes principaux de la POO

      5:01

    • 97.

      Chapitre 15 (Cours) : fonctions d'ami et cours

      8:06

    • 98.

      Chapitre 15 (Cours) : espaces de noms

      8:00

    • 99.

      Chapitre 15 (Cours) : tableaux d'objets

      6:56

    • 100.

      Chapitre 15 (Cours) : création d'un cours alternatif

      11:50

    • 101.

      Félicitations !

      2:06

  • --
  • 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.

129

apprenants

--

projet

À propos de ce cours

Description

Dans ce cours complet C++ pour débutantsje vous aiderai à passer de votre propre code C++, à maîtriser les bases et à aborder des sujets avancés tels que l'héritage, le polymorphisme et les interfaces. Avec des directives étape par étape, des défis pratiques et des clarifications sur ce qu'il faut faire, mais aussi sur la raison, vous serez sur la bonne voie pour créer des projets réels en un rien de temps !

Pourquoi vous devriez suivre ce cours :

  • Polyvalence : C++ est utilisé dans le développement de jeux (Unreal), les applications mobiles, l'ingénierie logicielle, et bien plus encore.
  • Forte demande pour les développeurs C++ : avec un salaire moyen de 100 000 $ et plus pour les programmeurs qualifiés, C++ est un excellent point de départ pour une carrière technologique lucrative.
  • Apprendre en faisant : vous acquerrez une expérience pratique des défis de codage à partir du chapitre 3 pour vous aider à appliquer ce que vous avez appris et à solidifier votre compréhension des concepts enseignés tout au long du cours.

À qui s'adresse ce cours

  • Aspirer les programmeurs sans aucune compétence en programmation.
  • Toute personne souhaitant développer ses compétences en C++.
  • Les programmeurs qui ont besoin d'un rappel ou qui souhaitent simplement apprendre une nouvelle langue.

Matériaux/ressources requis

  • Un ordinateur (Windows, macOS ou Linux) capable d'exécuter Visual Studio ou n'importe quel IDE C++ de votre choix.
  • Aucune expérience préalable en programmation n'est requise.
  • Tous les logiciels utilisés dans le cours sont gratuits.
  • Je recommande vivement d'avoir un clavier physique.

Rencontrez votre enseignant·e

Teacher Profile Image

Primorous Arts

Course Instructor

Enseignant·e
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. Introduction: Bienvenue dans le cours Primoris Arts C plus plus pour débutants Si vous êtes ici, vous êtes probablement intéressé à apprendre à coder, mais vous ne savez pas par où commencer. J'ai compris. J'y étais aussi. Lorsque j'ai essayé d'apprendre à coder pour la première fois, j'ai passé plus de temps à chercher un cours complet, à suivre le contenu de ce que j' avais déjà appris et/ou à répondre à des questions de base qu'à apprendre réellement. De plus, j'avais l'impression qu'on m'apprenait simplement à suivre les mouvements alors que ce dont j' avais vraiment besoin et que je voulais c'était de savoir comment les choses fonctionnaient et , c'était de savoir comment les choses fonctionnaient et quand les utiliser afin de pouvoir me lancer dans mes propres projets. C'est pourquoi nous avons créé ce cours afin que vous n' ayez pas à faire face aux mêmes difficultés au cours de votre parcours pour devenir programmeur. Tout ce dont vous avez besoin pour commencer est réuni en un seul endroit, des sujets pour débutants aux sujets avancés, avec une véritable assistance disponible lorsque vous en avez le plus besoin. Alors pourquoi devriez-vous apprendre le C plus spécifiquement ? C plus plus est un langage puissant et polyvalent utilisé dans le développement de jeux, les navigateurs Web, les bases de données, etc. Grâce à elle, vous aurez les bases nécessaires pour commencer à créer vos propres projets à une échelle très appréciée dans le secteur technologique en pleine croissance. Bien que le C plus soit considéré comme un langage plus difficile à apprendre basé sur le langage C, il peut être un outil essentiel pour ceux qui cherchent à maîtriser programmation dans des domaines où mémoire et la vitesse sont des préoccupations majeures, et il fournit une base solide qui facilite l'apprentissage d'autres langages basés sur le C tels que C Sharp ou Java. Dans cet esprit, ce cours va commencer par les bases absolues. Si vous n'avez jamais écrit une seule ligne de code, ne vous inquiétez pas, tout ira bien. Nous aborderons les principes fondamentaux tels que les variables et passerons progressivement à des sujets plus avancés tels que les classes ou les objets, l'abstraction, l'encapsulation, polymorphisme, l'héritage, À partir du chapitre trois, vous aurez l'occasion de relever défis de codage spécialement conçus pour vous aider à approfondir votre compréhension des concepts enseignés tout au long du cours Alors pourquoi choisir ce cours pour apprendre C plus plus ? Parce qu'au lieu de simplement vous montrer comment suivre les étapes et de vous retrouver avec un projet que vous ne savez pas comment recréer vous-même, je vais vous apprendre non seulement comment écrire le code, mais surtout, quand l'utiliser et pourquoi En vous apprenant à penser comme un programmeur, vous allez acquérir une compréhension beaucoup plus approfondie de chaque concept enseigné, de sorte qu'à la fin du cours, vous serez prêt à aborder vos propres projets en toute confiance. Et pour rendre les choses encore meilleures, tout ce que nous utilisons dans ce cours est gratuit, qui signifie qu'il n'y a pas d'essais gratuits ni de frais cachés à craindre. Maintenant, à qui s'adresse ce cours ? Ce cours est parfait pour les débutants qui souhaitent démarrer, pour programmeurs expérimentés qui souhaitent rafraîchir ou approfondir leurs compétences, et pour tout le monde entre les deux Et n'oubliez pas qu'il n'y a pas d'urgence. N'hésitez pas à y aller à votre rythme et à revenir pour revoir des leçons spécifiques en cas de besoin. Chez Primoris Arts, nous nous engageons à vous aider à réussir à chaque étape Donc, si vous êtes prêt à commencer votre parcours de codage, il n'y a pas de meilleur moment que maintenant. Nous vous invitons à vous joindre à nous dès aujourd'hui dans la prochaine vidéo où nous aborderons la programmation étape par étape avec des leçons claires, concises et faciles à suivre. Merci d'avoir regardé, je vous verrai dans le prochain. 2. Chapitre 1 (Configuration) : Installer Visual Studio: Bienvenue dans le tout premier épisode du cours C plus plus pour débutants. Dans cet épisode, je vais vous montrer comment installer Visual Studio, un programme entièrement gratuit que nous utiliserons pour écrire et exécuter tout notre code. Malheureusement, si vous utilisez Mac OS ou Linux, vous devrez télécharger un autre programme qui vous permettra d'écrire et d'exécuter du code C plus plus plus. Mais ne vous inquiétez pas, une fois que vous aurez fait cela, vous pourrez très bien suivre. Et plusieurs programmes gratuits sont disponibles, ainsi que de nombreux tutoriels en ligne sur la façon de les utiliser. Ensuite, dans le prochain épisode, je vais m'assurer que tout le monde est exactement sur la même longueur d'onde afin que vous puissiez suivre quel que soit le programme que vous utilisez. Très rapidement ici et juste quelques exemples de certains programmes que je recommande. Que vous utilisiez macOS ou Linux. Vous pouvez utiliser Visual Studio Code. Vous pouvez également utiliser des blocs de code. Enfin, pour les utilisateurs de macOS en particulier, vous pouvez utiliser le logiciel Xcode intégré. Quoi qu'il en soit, pour tous ceux qui utilisent Windows, Visual Studio est le programme le plus populaire et celui que je recommande d' utiliser car il est très facile à configurer et à démarrer. Donc, la première chose à faire est d' aller sur Visual Studio.Microsoft.com. Ensuite, en haut de la page, accédez aux téléchargements. Ensuite, vous verrez votre Visual Studio avec C plus plus. Allez-y, allez dans la liste déroulante de téléchargement et allez à l'endroit où il est écrit Community Free. Assurez-vous de ne pas cliquer sur celui qui indique l'essai gratuit. Ensuite, une fois qu'il est téléchargé, ouvrez l'application de configuration de Visual Studio et assurez-vous d'accepter toutes les instructions qui peuvent apparaître sur votre écran. Ensuite, allez-y et attendez que le téléchargement et l'installation soient terminés. Maintenant, une fois l'installation terminée, vous pouvez créer un compte gratuit si vous le souhaitez. Comme je crois que cela vous obligera à créer un compte à un moment donné, même si le programme est totalement gratuit. Cependant, pour le moment, je vais simplement continuer sans compte. Ainsi, aucun des paramètres de mon compte précédent ne soit là et que nous puissions tout revoir avec un nouveau crâne. Je vais donc continuer et cliquer sur Pas maintenant, peut-être plus tard. Maintenant, je recommande vivement d' opter pour un thème sombre. Pas seulement un Visual Studio, mais n'importe quel programme que vous utiliserez pour écrire du code à l'avenir, car ce sera certainement beaucoup mieux pour vos yeux. Ensuite, en ce qui concerne les paramètres de développement, je vais simplement les laisser sur les paramètres généraux. Ensuite, nous allons continuer et appuyer sur Démarrer Visual Studio. Très bien, une fois qu'il sera ouvert, nous allons créer un nouveau projet. Et ce que vous allez rechercher ici en haut, c'est C plus, plus. Une autre chose que vous pouvez faire est d'aller à l'endroit où toutes les langues sont affichées et de cliquer sur C plus plus. Et vous devriez en voir un pour l'application console. Je vais donc cliquer dessus , puis appuyer sur Suivant. Ensuite, vous allez donner un nom à votre projet. Maintenant, vous pouvez donner le nom que vous voulez, mais je vous recommande de vous en tenir à une convention de dénomination Pascal Case. Cela signifie que vous n'aurez aucun espace. Vous allez commencer par une majuscule et chaque mot suivant commencera également par une majuscule. Alors allez-y et donnez-lui un nom rapidement. Vous remarquerez maintenant que le nom de votre solution en bas est exactement le même que celui de votre projet. Pour ce cours. Nous allons continuer et laisser les choses ainsi. Mais sachez qu' à l'avenir, votre solution et le nom de votre projet ne sera plus nécessaire que votre solution et le nom de votre projet soient identiques. Vous pouvez également choisir l' emplacement de votre choix pour ce projet. Ensuite, assurez-vous que cette case en bas indique Play Solution dans le projet dans le même répertoire. Comme incontrôlé. Comme il s'agit généralement d' une bonne pratique. Ensuite, allez-y et cliquez sur Créer. Très bien, alors tu peux y aller et clore tout ça. Et voilà, vous l'avez. Nous avons maintenant installé Visual Studio et créé notre tout premier projet C Plus Plus. Maintenant, ce que je veux que vous fassiez, c'est d'aller dans le fichier en haut et d'appuyer sur Enregistrer tout, et assurez-vous de le faire à la fin de chaque vidéo, sauf indication contraire. Maintenant, je sais que vous n'utilisez pas tous Visual Studio. Donc, dans la vidéo suivante, je vais m' assurer que vous êtes tous exactement sur la même longueur d'onde que moi et que vous êtes prêts à apprendre à lire et à écrire du code ensemble. Et ne vous inquiétez pas, c' est le seul programme que je vais vous faire installer tout au long de ce cours. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 3. Chapitre 1 (Configuration) : faire monter tout le monde sur la même page: Dans cette vidéo, je vais m' assurer que vous êtes tous exactement sur la même longueur d'onde que moi, afin que vous puissiez facilement suivre le reste du cours. Et n'oubliez pas, si vous avez besoin d'aide. Merci de me le faire savoir dans la section de discussion ci-dessous et je serai plus qu' heureux de vous aider. Quoi qu'il en soit, allons-y. Maintenant, très rapidement, pour ceux d'entre vous qui utilisent Visual Studio, nous allons accéder aux outils en haut et descendre dans les Options. Et sous le bogue, cliquez sur Général. Faites ensuite défiler l'écran vers le bas. Et vous devriez voir une case à cocher indiquant fermer automatiquement la console lors du débogage des tampons. Assurez-vous que cette case est cochée. Ensuite, continuez et cliquez sur OK. Ensuite, quel que soit le programme que vous utilisez, si vous avez d'autres textes en dehors de ce hashtag, incluez la ligne iostream dans ce crochet bouclé fermé. Donc, tout est là, allez-y et débarrassez-vous de tout le reste. Comme ça. OK, donc ça devrait être la seule chose qui reste sur ton écran. Maintenant, si ce n'est pas sur votre écran, allez-y et copiez-le exactement. Maintenant, une fois que votre code ressemble au mien, nous allons ajouter quelques lignes de code supplémentaires. Maintenant, ne vous inquiétez pas, vous n' avez rien à comprendre. Nous allons passer en revue tout cela dans la prochaine vidéo. Mais pour l'instant, je veux juste m' assurer que le code de chacun fonctionne. Donc, juste après cette ligne HelloWorld, ici, juste après le point-virgule, nous allons continuer et cliquer sur Entrée pour créer une nouvelle ligne. Et nous allons taper std, deux-points, deux-points, points C, obtenir des parenthèses ouvertes, des parenthèses fermées, des points-virgules. Ensuite, nous allons appuyer à nouveau sur Entrée. Ils créent une nouvelle ligne. Je vais taper return. Ensuite, le chiffre 0 suivi d'un autre point-virgule. Le code de chacun doit donc ressembler exactement à ceci. Maintenant, quel que soit le programme que vous utilisez, vous devriez pouvoir exécuter le code tel quel. Maintenant, pour ceux d'entre vous qui utilisent Visual Studio, vous pouvez simplement cliquer sur le bouton Jouer en haut, ou le hockey se joue à F5. Maintenant, pour ceux d'entre vous qui utilisent un autre programme, vous devez trouver comment exécuter votre code. Et s'il existe un raccourci clavier pour le faire, je vous recommande vivement de vous en souvenir car nous le ferons beaucoup tout au long de ce cours. Quoi qu'il en soit, une fois votre code exécuté, je devrais simplement dire bonjour tout le monde. Et lorsque vous appuyez sur Entrée, je dois sortir du code. Juste comme ça. Maintenant, il se peut que vous n'ayez pas tous une fenêtre de console qui s'affiche lorsque votre code s'exécute. Et c'est parfaitement bien. Tant que votre code s'exécute et qu'il indique « Bonjour tout le monde », vous êtes prêt à partir. Pour le reste d'entre vous, la première chose que je veux vérifier, votre code ressemble exactement au mien. Alors, si vous rencontrez toujours des problèmes, veuillez me le faire savoir dans la section de discussion ci-dessous, et je serai plus qu' heureuse de vous aider. De toute façon. C'est tout pour cette vidéo. la vidéo suivante, nous allons voir ce que signifie réellement tout ce code. Alors merci de m'avoir écouté, et à bientôt. 4. 3: Dans cette vidéo, nous allons passer brièvement en revue tout le code que nous avons ici. Maintenant, ne vous inquiétez pas, je ne m'attends pas à ce que vous vous souveniez de tout, car nous reviendrons sur tout cela plus en détail plus tard dans le cours. Je voudrais juste vous donner une brève introduction de ce qui se passe. Et à la fin de la vidéo, je vais vous donner un bref résumé des quelques points clés dont je veux que vous vous souveniez au fur et à mesure que nous avançons. Donc, au début, nous avons cette instruction include, qui indique essentiellement au compilateur que nous voulons prendre le code du fichier d'en-tête nommé iostream et le mettre dans notre programme. Le compilateur traduit tout ce qui se trouve ici en binaire ou en uns et en zéros afin que notre ordinateur puisse réellement le comprendre. Et un fichier d'en-tête est essentiellement une collection de code conçue pour être utilisée par d'autres programmes. Ensuite, nous avons notre fonction principale. La fonction principale est importante car chaque programme C plus plus a une fonction principale, car c'est là que votre programme commence et se termine. Et tout ce qui fait partie de la fonction principale doit être placé entre ces crochets bouclés ouverts et fermés. Et c'est là que la majorité de notre code sera écrite. Ensuite, nous avons cette ligne de code qui imprime Hello world. Et allons-y et décomposons-le rapidement. Nous avons donc d'abord écrit std, qui est un espace de noms qui contient une définition pour l'objet C out. Et nous reviendrons aux espaces de noms ici dans une minute. Maintenant, regardez-le comme un objet utilisé pour afficher du texte. Et il est toujours suivi par l'opérateur d'insertion, qui est deux de moins que des symboles. Et ce qui se trouve à droite de l'opérateur d'insertion est ce que vous souhaitez réellement imprimer. Lorsque vous souhaitez imprimer des textes littéralement, ou si vous souhaitez imprimer exactement ce que vous tapez. Vous devez l'avoir entre deux guillemets doubles, comme ça. Et toute cette ligne ici en tant que déclaration ou instruction pour notre programme. Et la plupart des déclarations se terminent par un point-virgule. Donc, pour résumer, nous disons en gros que nous voulons utiliser l'objet C out pour imprimer Hello World. Ensuite, cette ligne que nous avons ajoutée dans la dernière vidéo indique simplement que nous voulons obtenir des informations de l'utilisateur. Et la seule raison pour laquelle nous l'avons mis ici est que notre programme ne s' arrête pas immédiatement après son exécution. Comme d'habitude, une fois qu'un programme a parcouru toutes ses lignes de code, il suppose que c'est fait et se ferme automatiquement. Maintenant, selon le programme que vous utilisez réellement pour écrire du code, votre code peut rester ouvert avec ou sans cette ligne. Mais pour ceux d'entre vous qui en ont besoin, je vais le laisser ici à l'écran à titre de rappel. Donc, juste pour vous montrer rapidement, si je me débarrassais de cette ligne de code et que j'essayais d'exécuter mon programme, il s'exécuterait instantanément puis s'éteindrait immédiatement. Donc, si je le remets et que je réexécute mon code, je dois maintenant appuyer sur Entrée pour fermer. Maintenant, il me permettra de taper plusieurs lettres et chiffres. Mais une fois que j'ai appuyé sur Entrée, il s'éteindra immédiatement. Et c'est parce que cette méthode get attend essentiellement ici. Ils prennent en compte les entrées de l'utilisateur et supposent que vous avez terminé lorsque vous appuyez sur la touche Entrée. Enfin, nous avons cette déclaration de retour en bas, qui indique simplement que nous voulons renvoyer le nombre entier zéro. Et la raison pour laquelle nous renvoyons zéro est que notre fonction principale a un type de retour d'un entier. Une fois que le code qui fait appel à notre fonction principale reçoit ce zéro. Et ce sont des codes exécutés avec succès. Et quelque chose que vous pouvez voir ici, manière interchangeable avec le zéro, c'est succès de sortie avec un trait de soulignement entre les deux et en majuscules. Comme ça. Cela fonctionnera très bien. Comme dans C plus, plus. C'est exactement la même chose que de simplement saisir les chiffres réels de zéro. Et je vais en fait laisser les choses comme ça pour plus de clarté. Pour ceux d'entre vous qui en ont besoin. Cependant, cela étant dit, C Plus Plus vous permet en fait de simplement supprimer cette ligne et elle renverra zéro automatiquement. Mais comme je l'ai dit, je vais laisser cela ici pour des raisons de clarté, car c'est ce qui se passe réellement en arrière-plan. Donc, très vite, revenons à l'espace de noms std. L'espace de noms est essentiellement cela. Il s'agit d'un espace nommé dans lequel se trouve le code. Et vous pouvez considérer cela comme le nom de famille d'une personne, par exemple, si je viens de vous donner le prénom de quelqu'un, vous ne savez peut-être pas de qui je parle, mais si je vous donnais son nom de famille, puis quand j'ai prononcé leur prénom, vous n'avez pas de contexte quant à qui je faisais référence. Exactement. Il en va de même pour notre code ici. Donc, quand nous disons que le péché en tant que partie du std, espace de noms et le nez ont été envoyés comme provenant juste au cas où d'autres objets porteraient également le même nom. Et cet espace de noms std provient de ce fichier d'en-tête iostream, qui est utilisé pour les entrées et les sorties standard, c'est pourquoi vous verrez ce fichier d'en-tête utilisé et de nombreux programmes C plus plus plus. Donc, nous pouvons faire quelque chose, au lieu de placer cet espace de noms avant tout ce qui fait partie de cet espace de noms se trouve en haut, juste en dessous de notre instruction include. On peut dire en utilisant un espace de noms. Std puis un point-virgule à la fin. Et maintenant, il saura automatiquement d'où viennent ces objets. Nous aborderons les objets plus en détail plus tard dans le cours. Car C plus plus est un langage de programmation orienté objet. Maintenant que nous disons que nous utilisons cet espace de noms et qu'il sait d'où viennent ces objets, nous pouvons simplement supprimer complètement ce préfixe ici. Juste comme ça. Et si je lance le programme, vous pouvez voir qu' il fonctionne très bien. Cela étant dit, certaines personnes préfèrent les laisser là pour des raisons de clarté. Mais personnellement, je préfère simplement taper C out ou CN, étant donné qu'ils sont si couramment utilisés. Je vais donc le supprimer comme ça et enregistrer le programme. Et c'est ce que nous utiliserons à l'avenir. Alors assurez-vous que vous avez cette ligne de code et vous serez tous au courant. Enfin, revenons à ce texte de Hello World ici. Vous vous demandez peut-être ce qu'est cette barre oblique inverse n et pourquoi elle n' est pas apparue lorsque nous avons exécuté notre code. Comme vous pouvez le voir, lorsque je lance un code, il est écrit Hello world, point d'exclamation. Ensuite, notre curseur clignote ici en bas. Et c'est parce que cette barre oblique inverse indique que nous voulons passer à une nouvelle ligne. Alors allons-y, supprimons cela rapidement et exécutons à nouveau notre code. Et comme vous pouvez le constater, notre curseur se trouve maintenant à la fin de la ligne. Donc, cette barre oblique inverse indique simplement que nous voulons passer à une nouvelle ligne. Et si vous vouliez écrire plus de texte sur la nouvelle ligne ? Certains d'entre vous peuvent instinctivement suivre cette voie. Makerspace, bonjour, a commencé et exécute ce code. Mais vous remarquerez que cet espace est en fait enregistré en tant qu' espace sur la nouvelle ligne. Donc, si nous ne le voulons pas, il faudra supprimer l'espace d'ici. Parce que, comme je l'ai déjà dit, tout ce qui se trouve entre ces guillemets sera imprimé littéralement ou exactement. Cependant, cette barre oblique inverse est en fait un caractère d' échappement spécial qui lira le caractère suivant et en fera quelque chose de spécifique. Et il y avait toute une liste de séquences d'échappement spéciales que vous pouvez utiliser. Et passons en revue quelques-unes à titre d'exemple. La première est la barre oblique inverse n, que vous avez déjà vue pour créer une nouvelle ligne. Vous pouvez également faire une barre oblique inverse, barre oblique inverse pour imprimer une barre oblique inverse. Comme ça. Une autre solution serait la barre oblique inverse entre guillemets. Pour imprimer réellement un guillemet. Plutôt que de signifier la fin de notre temps. Je lance un code. Vous pouvez voir le guillemet double juste là. Quoi qu'il en soit, allons-y, supprimons cela et mettons simplement la barre oblique inverse en arrière-plan, comme si c'était très rapidement, quelque chose que vous verrez peut-être à la place de la barre oblique inverse n est le suivant. Ainsi, après un guillemet, vous pouvez voir un autre opérateur d'insertion suivi du mot se terminer par un l minuscule, comme ça. Ensuite, assurez-vous que le point-virgule est toujours à la fin. Si nous exécutons notre code. Cela se traduira également par une nouvelle ligne. Et L est simplement l' abréviation de N line. Et vous pouvez les utiliser de manière interchangeable car ils font exactement la même chose, juste pour vous rappeler que la barre oblique inverse doit figurer à l'intérieur de vos guillemets. Et l'extrémité L doit être isolée après un autre opérateur d'insertion, comme ça. Quoi qu'il en soit, je vais aller de l'avant et remettre ça comme avant. Maintenant, très vite. j'aimerais mentionner, c'est que Ce que j'aimerais mentionner, c'est que même si je l'ai appelée la fonction principale, vous pouvez entendre des gens dire que méthode principale en tant que méthode fonctionnelle est souvent utilisée de manière interchangeable. Et vous êtes peut-être habitué à ce que les gens disent méthode, surtout si vous venez d' un autre langage de programmation. Quoi qu'il en soit, allons-y et récapitulons rapidement tant que nous n'avons qu'un seul écran. Donc, d'abord, nous avons cette instruction include, qui indique essentiellement que nous voulons utiliser code du fichier d'en-tête iostream. Ensuite, nous disons que nous allons utiliser l'espace de noms std, qui indique à notre programme que cet objet c out et sent provient de l'espace de noms std. Et comme je l'ai dit, vous pouvez essentiellement considérer un espace de noms comme le nom de famille de quelqu'un. Et en gros, c'est juste un moyen de spécifier d'où vient quelque chose ou à quoi nous faisons référence. Quand nous avons parlé de scalp, ils savent que nous voulons utiliser c hors de l'espace de noms std. Très bien, nous incluons donc du code provenant d'iostream. Ces deux objets étant ici C out et C n, proviennent du nom space std. Ensuite, nous avons notre fonction principale, ou une méthode qui fait partie du programme array C plus plus, car c'est là que notre programme commence et se termine. Et à l'intérieur, nous n'avons que quelques déclarations. Nous avons ce premier objet, qui est l'objet CL pour imprimer Hello World. Nous avons ce fichier sin.gov, qui attend essentiellement de recevoir les commentaires des utilisateurs. Et puis nous avons simplement là pour que notre programme ne se ferme pas immédiatement tant que nous n' avons pas appuyé sur la touche Entrée. Ensuite, nous avons return exit success, ce qui revient à dire return zero car notre fonction principale doit renvoyer une valeur entière ou un nombre entier. Et il renverra normalement zéro lorsqu'il aura réussi et fonctionnera. Donc, ceci et cela sont exactement la même chose. Et comme je l'ai dit, C plus plus vous permettra de simplement le supprimer et de taper. D'accord, de toute façon, c' est tout pour cette vidéo. Assurez-vous de voir ce que vous avez. Et ne vous inquiétez pas si vous ne vous souvenez pas de tout ce dont nous avons parlé ici. La seule chose dont je veux vraiment que vous vous souveniez à l'avenir, car le code R aura lieu dans la fonction principale. Et puis chaque programme C plus plus a une fonction principale car c'est là notre programme commence et se termine. Et à partir de maintenant, nous allons décomposer chaque petite chose étape par étape dans sa propre vidéo individuelle afin que vous puissiez les suivre facilement, vraiment comprenez ce qui se passe afin de pouvoir l'utiliser dans vos propres programmes. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 5. Chapitre 2 (Hello World) : l'espace blanc: Dans cette vidéo, nous allons parler des espaces blancs. espaces blancs et C plus pointent au-dessus de vos deux premiers caractères qui sont utilisés à des fins de mise en forme, tels que des espaces, des tabulations sur des lignes parfois nouvelles. Et le compilateur C plus plus ou celui qui prend tout ce code et convertit en binaire pour que l'ordinateur puisse le comprendre ignorera généralement les espaces blancs. Cependant, il y a quelques exceptions que nous allons examiner dans cette vidéo. Donc, pour vous donner un exemple d'espace, vous pouvez utiliser autant de nouvelles lignes, autant de fois, autant d' espaces que vous le souhaitez, général. Même entre deux choses. Donc, votre code fonctionnera très bien. OK ? Donc, en gros, vous voulez utiliser des espaces pour rendre le code aussi lisible que possible pour vous. Et si vous comptez travailler avec d'autres personnes, vous devez également le rendre aussi lisible que possible pour eux. Alors, quand les espaces ne sont-ils pas ignorés ? Eh bien, lorsque nous utilisons des guillemets pour indiquer à notre programme que nous voulons qu'il imprime exactement ce qui se trouve entre eux. Cela suppose que lorsque nous plaçons un espace, nous voulons espacer. Alors quand nous avons mis un espace ici entre Hello et World, mais que nous sommes venus et que nous sommes venus avec notre programme. Comme dans tous les autres espaces avec lesquels nous avons joué ici. Comme vous pouvez le voir ici. L'autre fois c'est lorsque nous avons un opérateur qui utilise deux caractères, comme avec notre opérateur d'insertion ici. Si vous mettiez des espaces entre les deux, il ne comprendrait plus ce que c'est. Et puis il n'y a vraiment qu'une seule autre fois où le compilateur n'ignorera pas les espaces blancs. Et c'est-à-dire que lorsque vous avez un mot clé tel que return here, vous ne pouvez pas le séparer ainsi. Et voilà, vous l'avez. Vous connaissez maintenant les espaces blancs comme dans la programmation C plus plus. En gros, vous pouvez utiliser autant de nouvelles lignes, espaces et d'onglets que vous souhaitez pour rendre votre code aussi lisible que possible. À l'exception de l' impossibilité de séparer les mots clés. Tous les espaces où vous indiquez à votre programme que vous souhaitez qu'il imprime exactement ce que vous lui demandez. Et vous ne pouvez pas séparer les opérateurs comportant deux caractères ou plus. Quoi qu'il en soit Merci de m'avoir écouté , et à bientôt. 6. Chapitre 2 (Hello World) : Écrire sur la console: Dans cette vidéo, nous allons simplement revenir en arrière et expliquer comment imprimer des textes sur la console. Donc, le principal moyen de protéger la console et C plus, plus, comme pour un objet C, suivi de l'opérateur d'insertion. N'oubliez pas que si, pour une raison quelconque, votre code ne l'accepte pas, car vous devez inclure l'iostream. Et vous devez laisser votre code maintenant que vous utilisez l'espace de noms std. Sinon, vous pouvez dire explicitement qu'il provient de l'espace de noms std, tapant S, T, D deux-points, deux-points, suivi de C out. Mais pour l'instant, je vais juste aller de l'avant et supprimer cela. Puisque nous avons déjà indiqué que nous utilisons cet espace de noms ici. Personnellement, je trouve cela beaucoup plus facile à lire. Je vais donc juste nettoyer un peu pour que nous connaissions tout notre code ici. Alors j'aimerais que vous me suiviez. Et nous allons simplement supprimer cette ligne et écrire des textes sur la console à partir de zéro. Nous allons donc sortir et nous en débarrasser. Et chaque fois que vous voulez écrire des textes sur la console, vous allez simplement dire C en minuscules. Oui, la capitalisation est importante lorsqu'il s'agit de programmation. Suivi par l'opérateur d'insertion. Nous allons donc dire C out space, l'opérateur d'insertion placé dans un autre espace. Ensuite, entre guillemets, nous saisirons ce que nous voulons dire. Je pourrais donc dire, écoutez de nombreux prénoms et n'hésitez pas à y mettre ce que vous voulez. Ensuite, après le dernier guillemet, vous allez simplement saisir une déclaration avec un point-virgule. Ensuite, nous exécutons notre code. Ils diront qu'il s'agit de ma première ligne de texte et que notre curseur restera juste là à la fin. Parce que nous ne l'avons pas mis en place si nous voulions qu' il passe à une nouvelle ligne. Très bien, alors voilà. C'est ainsi que vous pouvez imprimer une seule ligne de texte sur la console. Mais que se passerait-il si vous vouliez imprimer plusieurs lignes ? Eh bien, vous avez plusieurs options. Vous pouvez toujours simplement dire backslash n. Et puis vous dites quelque chose comme : «  C'est ma deuxième ligne ». Et quand ton programme, et c'est parti. Et vous pouvez le faire autant de fois que vous le souhaitez. Maintenant, bien que nous puissions simplement continuer à taper backslash n suivi de tous les textes supplémentaires que nous voulons écrire. Cela finira par devenir assez compliqué et rendre notre code difficile à lire. Nous avons donc une autre option. Allons-y et supprimons ce code supplémentaire ici. Copions et collons ensuite cette ligne ci-dessous. Et nous dirons quelque chose comme C'est ma deuxième ligne. Comme je l'ai dit, n'hésitez pas à y jeter ce que vous voulez. Ensuite, nous allons exécuter notre code. Et comme vous pouvez le voir, il est simplement dit que c'est ma première ligne de texte. Alors c'est ma deuxième ligne de texte sans espaces, sans ponctuation. Ce n'est pas sur une nouvelle ligne. Rien. C'est parce qu'en programmation, votre code va faire exactement ce que vous lui demandez. Et ça ne va rien faire de plus pour t'aider. Donc, en gros, si vous voulez que quelque chose se produise, vous devez y arriver. Donc, si nous voulons nettoyer tout ça et le faire apparaître sur n'importe quelle ligne, il faut y mettre de la ponctuation, des trucs comme ça. faudrait le saisir manuellement. Je peux donc dire que c'est ma première ligne de texte. Période. Backslash n créera une nouvelle ligne. Et puis tu peux mettre un point. Je pense à celle-là aussi. Quand je code à nouveau et vous voilà. Probablement un peu plus proche de ce à quoi vous vous attendiez auparavant. Et si vous voulez une ligne blanche entre ces deux lignes, eh bien, vous pouvez simplement ajouter une autre barre oblique inverse n au début. Et voilà. Tu as une nouvelle gamme. Et vous pouvez simplement continuer à le faire pour obtenir plus de nouvelles lignes entre les deux. Devriez-vous choisir. Quoi qu'il en soit, je vais aller de l'avant et supprimer ça. Et si vous vous souvenez de notre autre option, au lieu de dire backslash n et quelque chose que vous pouvez également voir fréquemment, vous devriez utiliser des guillemets pour le placer dans un autre opérateur d'insertion. Insight et l, tous en minuscules. Et avant le point-virgule. Ensuite, si nous lançons à nouveau un programme, vous pouvez voir qu'il fonctionne très bien. Si vous vous souvenez, je vous ai dit que les espaces blancs pouvaient généralement être ignorés par C plus plus. Donc, si je devais revenir en arrière et supprimer tous les espaces entre C et son opérateur, les guillemets ici. Et à la fin, je vais programmer. Il fonctionnerait toujours très bien. Cependant, je vous ai simplement dit de mettre un espace, comme nous l'avons écrit, pour des raisons de lisibilité, car quelque chose que vous voudrez toujours faire matière de programmation est de créer votre code en tant que lisible autant que possible. Parce que même si vous pouvez construire une lecture et la comprendre aujourd'hui, vous pouvez penser que quiconque le regarde penser que quiconque le regarde peut également le comprendre . Vous voulez vous assurer de pouvoir comprendre cela sans problème demain, une semaine, un mois, dans une semaine, un mois, voire des années plus tard. C'est quelque chose que je veux que vous gardiez à l'esprit et que vous mettiez en pratique tout au long de ce cours. Quoi qu' il en soit, c'est à peu près tout pour imprimer du texte. Mais je vais vous montrer une dernière astuce. Donc, tout comme nous pouvons ajouter un autre opérateur d'insertion pour lancer cette ligne N ici pour créer une nouvelle ligne. Nous pouvons également simplement y mettre les textes. Donc, au lieu de créer une toute nouvelle instruction C out, peux simplement copier ce texte avec les citations. Débarrasse-toi complètement de cette ligne. Et après cet opérateur d'insertion supplémentaire, nous pouvons simplement le coller dans notre ligne. Et je vais en fait placer tout cela sur une ligne séparée, juste pour que tout reste dans l'écran. Juste comme ça. Et ça va très bien fonctionner. Et nous pourrions même ajouter notre ligne M ici avec un autre opérateur d'insertion entre les deux. Et tout cela fonctionnera comme avant. Tu y vas. Donc, chaque fois que vous utilisez l'objet CLI pour imprimer du texte à l'écran, je vais m'assurer que vous incluez l'iostream, c'est-à-dire tel que l' objet provient. Et quand je passe la souris dessus, vous pouvez voir qu'il provient de l'espace de noms std, que nous avons indiqué ici. Ensuite, nous le suivons toujours avec l'opérateur d'insertion, qui va insérer ce que nous avons placé après dans notre programme. Ensuite, chaque fois que vous souhaitez ajouter plus d'un élément, il vous suffit de le suivre avec un autre opérateur d'insertion. Nous avons donc dit C out. Ensuite, nous avons dit que nous voulions mettre exactement ce qui se trouve entre ces guillemets doubles à l'écran. Il a donc dit : « C'est notre première ligne de texte. Mettez un autre opérateur d'insertion. Mettez une ligne de fin ici pour indiquer que nous voulons descendre vers une nouvelle ligne. Et si vous vous souvenez, nous codons aussi, il suffit mettre backslash n, comme ça. Ensuite, comme nous ajoutons quelque chose d'autre, nous utilisons un autre opérateur d'insertion. Ensuite, nous ajoutons une autre ligne littérale de textes que nous voulons qu'elle soit imprimée sur la console, encore une fois par des guillemets. Enfin, à la fin de cette instruction OU instruction pour notre programme, nous mettons simplement un point-virgule. Quoi qu'il en soit, nous utiliserons l' objet CL de nombreuses fois tout au long de ce cours. Alors ne vous inquiétez pas, si vous n' avez pas tout compris maintenant, vous allez avoir une tonne de pratique. Et juste pour récapituler rapidement la syntaxe ou les règles d'écriture de textes sur la console. Vous allez simplement dire Cl, suivi de l'opérateur d'insertion, suivi de guillemets doubles et d'un point-virgule à la fin. Et à l'intérieur de ces citations trouve l'endroit où va aller votre texte . Et vous pouvez même ne rien y mettre du tout et cela fonctionnera très bien. Alors allez-y et jouez un peu avec ça. Revoyez la vidéo si besoin, et je vous verrai dans la prochaine. 7. Chapitre 2 (Bonjour au monde) : Commentaires: Dans cette vidéo, nous allons parler commentaires dans la programmation. Très vite. Allons-y et supprimons tout ce code supplémentaire en dehors de son relevé Cintiq et de notre relevé de retour. Donc, nos commentaires et notre programmation, eh bien, ils sont essentiellement ce que vous pensez. Un commentaire est essentiellement un texte que vous écrivez vous-même pour rendre votre code plus lisible. Très vite, allons-y et remettons-les dans nos textes. Nous écrivons Hello World sur la console. Nous allons donc dire C out, opérateur d'insertion. Et puis entre guillemets venez dire bonjour à tout le monde. Et n'oubliez pas le point-virgule à la fin. Nous avons donc déjà travaillé avec ce programme à quelques reprises. Nous savons déjà à quoi il sert. Lorsque nous exécutons notre code. Il va simplement dire «  Bonjour tout le monde » sur une seule ligne. Et si nous voulions ajouter quelques lignes à elle pour rendre ce code plus lisible. Maintenant, pour l'instant, je comprends que notre programme est assez petit et basique et que ce n'est pas très nécessaire. Mais au fur et à mesure que nous avancerons et que nous commencerons à travailler avec des programmes plus complexes, vous voudrez certainement ajouter autant de commentaires que possible pour rendre votre code aussi lisible que possible. Parce que même si vous savez peut-être ce que cela dit aujourd'hui, vous voulez être capable de voir dans les années à venir où vous ne vous souvenez plus d' avoir rien écrit et où vous serez toujours capable de le lire. Pas de problème. Alors, comment écrire un commentaire ? Sur n'importe quelle ligne de notre code, nous pouvons placer deux barres obliques et tout ce qui se trouve après ces deux barres obliques sera complètement ignoré. Lorsque nous exécutons notre programme. Vous insérez un texte comme celui-ci et exécutez notre code. Et il va juste dire HelloWorld, comme je le faisais auparavant. Dans ce commentaire, se terminera automatiquement une fois que nous passerons à une nouvelle ligne. Maintenant, il existe un moyen de faire des commentaires qui s' étendront sur plusieurs lignes. Donc, si vous tapez une barre oblique suivie du symbole réel, tout ce qui se passe au-delà de ce point sera un commentaire. Comme vous pouvez le voir, il a commenté tout ce qui s'est passé. Le chemin vers n, c'est ce qui est un autre symbole Astro suivi à nouveau de la barre oblique. Donc, comme vous pouvez le voir, c'est tout ce que je veux ici, mais une nouvelle ligne. Et tout fonctionnera comme je l' ai fait auparavant. Tu y vas. Quoi qu'il en soit, je vais l'enlever pour que vous l'ayez. Vous savez maintenant comment ajouter des commentaires à votre code pour le rendre plus lisible. Mais il y a un autre cas d' utilisation des commentaires, qui est incroyablement utile, que je vais passer en revue avec vous maintenant. Ainsi, comme tout ce qui se trouve dans un commentaire sera ignoré, vous pouvez en fait sortir une ou plusieurs lignes de code pour tester votre programme sans elles. Cela peut être extrêmement utile lorsque vous essayez de déterminer la cause d' un problème ou simplement pour voir comment votre code s'exécute sans rien. Par exemple, nous allons copier et coller cette ligne HelloWorld plusieurs fois. Juste comme ça. Et nous allons commenter quelques-unes d'entre elles. Je pouvais donc exécuter mon code comme avant. Mais Hello World ne sera imprimé que trois fois car ce quatrième article est commenté. Bien entendu, ce n'est pas un bon exemple de la façon de l'utiliser, mais nous le ferons tout au long du cours. Vous aurez donc une expérience pratique de l'utiliser à votre avantage. Mais je voulais juste vous informer le plus possible et vous faire connaître tous les cas d'utilisation des commentaires. Quoi qu' il en soit, c'est à peu près tout pour cette vidéo très rapidement. Je tiens juste à le mentionner à partir de maintenant, alors que je commençais chaque vidéo avec une table rase qui ressemble exactement à ceci. Et c'est ce que nous ferons à partir de maintenant, sauf indication contraire. Alors merci de m'avoir regardé et à bientôt. 8. Chapitre 3 (Variables) : Intro aux variables: Dans cette vidéo, nous allons parler de variables. Une variable est essentiellement un conteneur pour stocker des valeurs de données ou un nom donné à un emplacement mémoire. Jusqu'à présent, nous avons appris à imprimer quelque chose pour l'utilisateur. Mais que se passerait-il si nous voulions réellement récupérer des informations ? Ou que se passerait-il si nous voulions des informations auxquelles nous pourrions faire référence, accéder et manipuler ultérieurement ? Eh bien, c'est là que les variables entrent en jeu. Alors, comment créer une variable ? Eh bien, passons en revue cela. La syntaxe pour créer une variable ou les règles de création d'une variable est donc ou les règles de création d' la suivante. Vous allez d'abord commencer par le type de données. Et cela représente le type de données que vous souhaitez stocker dans la variable. Vous pouvez stocker des chiffres, des mots, des caractères ou une valeur vraie ou fausse, etc. Et nous allons passer en revue les différents types de données dans les prochaines vidéos. Après le type de données, vous allez mettre le nom de la variable. Maintenant, lorsque vous nommez une variable, vous devez vous assurer que votre nom décrit ce que vous stockez. Supposons, par exemple, que vous créiez un jeu de flipper. Vous vouliez enregistrer le score actuel. Au lieu de simplement appeler ce numéro un, nous pourrions l' appeler score actuel. Ensuite, nous pouvons avoir besoin d' une autre variable pour stocker le score le plus élevé, par exemple. Et nous ne voudrions pas les nommer en conséquence. Maintenant, lorsque vous nommez une variable, il existe quelques conventions de dénomination courantes que je vous recommande d'utiliser, car vous les verrez assez souvent. Et surtout si vous travaillez avec d'autres personnes, c'est probablement ce qu'elles feront également. Donc, en général, lorsque vous nommez une variable, elle commence toujours par une lettre minuscule. De plus, je recommande de l'écrire en CamelCase, ce qui signifie que la première lettre sera en minuscules. Il n'y aura ni espaces ni ponctuation. Et au début de chaque mot suivant après le premier, nous commencerons par une majuscule. L'autre option, que vous verrez fréquemment pour nommer des variables, est que Snake Case justifie ceux qui les séparent en ayant simplement une majuscule au début de chaque mot suivant jusqu'au 1er, vous allez simplement les séparer par un trait de soulignement. Ensuite, vous pouvez laisser la première lettre en minuscules, comme ça. Maintenant, pour le reste de ce cours, je vais écrire nos variables avec une première lettre minuscule, puis une minuscule Kimball. Parce que le z est le plus fréquent et je trouve qu'il est plus facile à lire personnellement. Je vais donc commencer et écrire le nom de la variable, comme ça. Et je vais vous montrer d'autres conventions de dénomination lorsqu'il s'agit d'autres choses au fur et à mesure que nous continuerons tout au long du cours. Donc, pour déclarer une variable ou simplement indiquer que vous allez avoir besoin d'une variable. Dans ce programme, nous allons commencer par un type de données, suivi du nom, puis d'un point-virgule à la fin. Et puis vous avez créé une variable. Comme je l'ai dit dans les prochaines vidéos, nous allons passer en revue les différents types de données, comment les créer spécifiquement et leurs cas d'utilisation. Maintenant, avant d'utiliser cette variable et de saisir du code, nous devons lui donner une valeur initiale. Il existe plusieurs façons de procéder. Donc, tout d'abord, supposons que cette variable stockait un nombre entier. OK, nous avons donc notre type de données pour stocker un nombre entier. Et puis appelons-le simplement ce score. Par exemple. Disons que c'était un score et un match de foot ou quelque chose comme ça. Eh bien, nous pourrions définir sa valeur initiale égale à 0, comme ça. C'est parfaitement valide et nous avons maintenant déclaré et donné à notre variable une valeur initiale afin de pouvoir l' utiliser ultérieurement. Vous ne voudriez jamais utiliser une variable avant de lui donner une valeur initiale, car vous vous retrouvez avec diverses erreurs. Une autre option serait de le déclarer maintenant, comme nous l'avons déjà fait, et de lui donner une valeur initiale plus tard. Alors laisse-moi te montrer à quoi ça ressemble. Ainsi, après avoir déclaré une variable ici, nous pouvons la référencer et lui donner une valeur initiale plus tard dans notre code. Alors, comment s'y prendre ? Tout d'abord, nous disons simplement le nom de la variable à laquelle nous voulons faire référence. Nous pouvons donc dire portée, puis nous lui donnons la valeur que nous voulons. Donc je pourrais dire que ça fait cinq. Par exemple. Cela fonctionnerait également. Tant que nous donnons une valeur à nos variables avant les utiliser plus tard, nous sommes tous prêts à partir. Maintenant, il existe un autre moyen de déclarer et d'initialiser des variables que je vais vous montrer tout de suite. Mais personnellement, je ne le recommanderais pas vraiment. Mais au cas où vous le verriez, je tiens à vous faire savoir qu'il existe. Et qui sait, peut-être déciderez-vous de l'utiliser dans un futur projet. Donc, ce que je vais vous montrer, c'est comment déclarer et initialiser plusieurs variables sur la même ligne. Nous pouvons donc dire le type de données suivi des noms des variables que vous souhaitez pour ce même type de données. Supposons, par exemple, que je veuille créer plusieurs variables pour stocker des nombres. Je le mettrais dans le type de données approprié, suivi du nom de ma première variable. Je vais donc juste dire var un, par exemple, séparé par une virgule. Ensuite, je peux faire autant de variables que je le souhaite. Je peux le faire si R1, R2, R3, ainsi de suite. Maintenant, ils peuvent porter le nom que tu veux. Je ne faisais que donner 123 comme exemple de base. Maintenant, bien que cela déclare plusieurs variables du même type de données, vous pouvez également donner à chacune d'elles une valeur initiale si vous le souhaitez. Donc, après n'importe lequel d'entre eux, je peux dire égal. Et puis, je pourrais le faire pour chacun. Je pourrais le faire pour un ou deux d'entre eux, et cetera. C'est donc une façon de déclarer et d'initialiser plusieurs variables sur la même ligne, à condition qu'elles aient le même type de données. Et vous pouvez toujours les initialiser plus tard, comme nous l'avons fait ci-dessus. Donc, par exemple, ici, je peux dire que var trois est égal à quatre. Maintenant, je l'aurais déclaré ici et je l'aurais initialisé ici. Et cela serait parfaitement valable. Quoi qu'il en soit, c'est tout pour cette vidéo. Dans la vidéo suivante, nous allons commencer à travailler avec notre tout premier type de données , les entiers. Alors merci de m'avoir écouté, et à bientôt. 9. Chapitre 3 (Variables) : Integers: Dans cette vidéo, nous allons passer en revue notre tout premier type de données variables, à savoir les entiers. Les entiers sont utilisés pour stocker des nombres entiers. Nous passerons en revue les types de données qui peuvent stocker des nombres avec des décimales ou des nombres à virgule flottante ultérieurement. Très rapidement, les entiers ne sont pas le seul type de données pour stocker des nombres entiers. Mais parce que c'est celui qui est le plus couramment utilisé, c'est celui que nous allons examiner aujourd'hui. Et ne vous inquiétez pas si vous avez déjà eu besoin d'utiliser l'un des autres. Ils sont utilisés exactement de la même manière. La seule différence réside dans la plage de valeurs dans laquelle ils peuvent stocker et la quantité de mémoire qu'ils occupent. Tout d'abord, il existe deux types d'entiers différents. Fondamentalement, la seule différence entre un entier assigné et un entier non signé est que les entiers assignés peuvent descendre en dessous de 0. Ils peuvent donc stocker n'importe quoi, de cette valeur négative ici à cette valeur positive ici. Et un entier non signé n'a pas la permission de descendre en dessous de 0. Mais à cause de cela, il peut le stocker deux fois la valeur positive et qu'il y a la seule différence entre les deux. Alors, quand voudriez-vous utiliser un entier non signé ? Eh bien, pour moi personnellement, si je sais que mon entier n'a pas besoin de descendre en dessous de 0, je vais toujours utiliser un entier non signé pour avoir le plus grand nombre maximum possible de positifs numéros disponibles pour moi sans utiliser de mémoire supplémentaire en utilisant un type de données différent. Par exemple, supposons que vous ayez créé un programme pour suivre, disons, un match de football et qu'aucune des deux équipes ne puisse descendre en dessous de 0, vous pouvez tout aussi bien utiliser un entier non signé. Alors allons-y et créons notre toute première variable du type de données entier. Donc, si vous vous en souvenez, la syntaxe pour créer une variable est la suivante. abord, nous allons commencer par le type de données. Dans ce cas, nous allons dire en minuscules pour indiquer que nous voulons créer un entier suivi du nom. Pour cet exemple, disons l'âge, puis un point-virgule à la fin. Et voilà, nous avons déclaré notre toute première variable entière. Maintenant, avant d'utiliser cette variable, nous devons lui donner une valeur initiale. C'est également le moment idéal pour vous faire savoir que tout notre code est lu de haut en bas dans notre fonction principale ici. Je ne peux donc pas initialiser la variable âge avant de la déclarer. Donc, par exemple, si ici j'essayais de dire que l'âge est égal à 0 avec un point-virgule à la fin. Il ne saurait pas ce qu'est l'âge. Parce que, comme je l'ai dit, c'est lu de haut en bas. Mais si nous prenons cela et le mettons ci-dessous ici, cela fonctionnera très bien. N'oubliez donc pas que l'ancien code est lu de haut en bas. Donc, dans cette première ligne, nous avons déclaré une variable. Et sur la deuxième ligne, on initialise une variable. Si vous vous en souvenez, nous pouvons faire les deux exactement dans la même ligne. Je vais donc les supprimer rapidement. Et nous allons dire que l'âge est égal à 0, puis un point-virgule à la fin. Et si nous voulions imprimer cette variable à l'utilisateur ? Eh bien, nous le faisons essentiellement de la même manière que nous imprimons des textes à l'utilisateur. Donc, ici, nous allons dire C0. Et puis l'opérateur d'insertion, suivi du nom de notre variable. N'oubliez pas que chaque fois que nous voulons accéder à une variable ou la modifier, nous avons besoin d'un nom d'utilisateur. Nous allons donc dire CL pour imprimer quelque chose à l'utilisateur. Ensuite, nous allons simplement taper H. Et la capitalisation, soit dit en passant, doit être exactement la même que celle d'ici. Donc, si, par exemple, je l'ai remplacé par un a majuscule, cette variable n'est plus reconnue. OK ? Donc, comme je l'ai dit, votre capitalisation dans la programmation est très importante. Donc, si nous voulions capitaliser ici, et nous devons également être une capitale ici. Maintenant, allons-y et exécutons notre programme. Et comme vous pouvez le voir, il imprime 0 sur la console. Nous pouvons également modifier la valeur d' une variable une fois qu'elle a été déclarée. Par exemple, ici, on pourrait dire que l'âge est égal à trois ans. Maintenant, nous aurions pu le faire comme ça, en déclarant notre variable, puis initialisant ici et en l'imprimant ici. Mais je vous montre juste qu'après avoir donné une variable et une valeur initiale, vous pouvez la modifier plus tard. Nous avons donc dit que nous voulions créer un entier nommé âge. Nous l'avons défini à 0. Ensuite, nous avons de nouveau référencé H. Nous voulons donc le fixer à trois. Ensuite, nous l'avons imprimé sur la console. J'exécute donc un code. Et vous y voilà. Nous en avons imprimé trois. Maintenant, si nous jetons un coup d' œil à notre variable ici, elle n'est pas très descriptive. En voyant, il imprime simplement la valeur réelle de H ici. Alors pourquoi ne pas ajouter certains défauts de texte. Donc, de retour ici, nous avons écrit CL après l'opérateur d'insertion. Allons-y et mettons-le entre guillemets, suivi d'un autre opérateur d'insertion avant le nom de notre variable ici. Ensuite, à l'intérieur de ces citations, nous allons dire que votre âge est l'espace deux-points, comme ceci. Et encore une fois, c'est beaucoup plus facile à lire maintenant. Donc c'est ton âge, tu as trois ans. Maintenant, une dernière chose que je voudrais aborder avec vous avant de passer à la vidéo suivante. Est-ce parce que notre code est lu de haut en bas. Si nous copions le plan ici et le plaçons après notre déclaration d'une variable, comme ça. Nous pouvons en fait imprimer H deux fois avec les deux valeurs différentes. Nous allons donc créer une variable entière appelée âge, en lui attribuant la valeur 0. Ensuite, nous l'imprimerons ici. Ensuite, nous le remplacerons par trois et l'imprimerons à nouveau. Dans notre programme, vous pouvez voir à quoi cela ressemble ici. Et vous y voilà. Le premier imprime sur 0, et le second en imprime trois. Et n'oubliez pas si nous voulons aller de l'avant et réparer cela pour qu'il soit un peu plus propre. Au début de celui-ci, nous pouvons simplement dire backslash, backslash n et R code. Créez une ligne blanche pour nous. Et voilà, vous l'avez. Vous savez maintenant comment créer et utiliser des nombres entiers. Et ne vous inquiétez pas, nous allons beaucoup les utiliser tout au long du cours. Vous allez donc avoir une tonne de pratique. De plus, la façon dont nous l' avons fait ici, où nous avons déclaré et initialisé une variable sur la même ligne, est généralement considérée comme bonne pratique lorsque vous êtes capable de le faire. La raison en est que vous ne souhaitez pas utiliser une variable avant de lui donner une valeur initiale. Lorsque vous le déclarez, il vous suffit de lui donner immédiatement une valeur initiale. Vous éviterez tout problème sérieux. Et enfin, avant que j'oublie cela, il est considéré comme un entier signé. Il s'agit du type entier par défaut. Si vous le souhaitez, vous pouvez même le définir explicitement comme un entier signé en disant espace signé , puis terminer comme ça. Mais ça, et c'est exactement la même chose. Si vous souhaitez créer un entier non signé, vous pouvez simplement dire non signé, comme suit. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 10. Chapitre 3 (Variables) : points flottants: Dans cette vidéo, nous allons parler de types à virgule flottante ou de nombres avec des décimales. Maintenant, nous n'allons pas passer en revue tous les types de virgule flottante dans C plus plus. Mais nous allons passer en revue les deux principales. Et je vais vous expliquer comment vous pouvez utiliser les connaissances que vous obtenez cette vidéo et les appliquer à d'autres types de virgule flottante. Alors allons-y et examinons ces deux principaux types de virgule flottante dans C plus, plus. Le premier que nous avons ici est un char. Et un flotteur peut contenir environ sept chiffres significatifs. Maintenant, si vous ne savez pas ce que sont les chiffres significatifs et que vous prévoyez de travailler avec des types à virgule flottante. Je recommande vivement d'y jeter un coup d'œil. Cependant, pour résumer brièvement ce qu'ils sont. Les chiffres significatifs sont chacun des chiffres d'un nombre qui sont utilisés pour l'exprimer le degré de précision requis à partir du premier chiffre différent de zéro. Maintenant, j'espère que cela a du sens. Si ce n'est pas le cas, ne vous inquiétez pas, vous pouvez toujours le rechercher à un autre moment et cela n' affectera pas votre capacité à suivre ce cours et à vraiment décoder en général. Cela étant dit, si vous prévoyez de travailler avec des données, cela doit être incroyablement précis, alors que vous prévoyez de travailler avec des décimales et des valeurs. Je vous recommande vivement de l' examiner afin de savoir ce que chacun des types à virgule flottante peut stocker avec précision. Ensuite, notre deuxième est un double, qui peut stocker environ 15 chiffres significatifs. Et si on l'appelle un double, c'est parce qu'il occupe en fait deux fois plus d'espace en mémoire. Et la précision d' un double par rapport à celle d'un flotteur est également environ le double. Quoi qu'il en soit, voyons comment créer des types de r à virgule flottante . Donc, comme pour toute autre variable, nous allons commencer par le type de données. Donc, pour la première fois, nous allons dire « float », le tout en minuscules, comme ça. Ensuite, nous allons dire quelque chose comme la hauteur pour le nom. Alors définissons-le à quelque chose comme 4.3. Ensuite, nous allons simplement mettre un point-virgule à la fin. Maintenant, une chose que je veux vous montrer ici c'est que si je passe la souris sur cette valeur, vous pouvez voir qu'elle considère cette valeur ici comme un double. Et cela est dû au fait que le type de données à virgule flottante par défaut dans C plus plus est un double. Donc, si vous ne travaillez pas réellement avec un double, vous devez indiquer explicitement au compilateur que vous pouvez le faire en ajoutant un suffixe spécifique en fonction du type de virgule flottante avec lequel vous souhaitez travailler. Et pour un float qui sera en minuscules, juste comme ça. Maintenant, si je passe la souris dessus, vous pouvez voir qu' il s'agit maintenant d'un flotteur. Très bien, donc si vous ne travaillez pas avec un double, vous devez ajouter un suffixe basé sur le type de virgule flottante avec lequel vous travaillez. Et vous pouvez facilement trouver toutes ces informations en ligne pour les différents types de virgule flottante si vous choisissez de les consulter. Mais comme je l'ai dit, pour la majorité d' entre eux seront les deux types que vous utiliserez. Ensuite, allons-y également et créons un double. Donc, en dessous, nous allons dire double type de données. Et encore une fois, tout était en minuscules. Ensuite, pour un nom, définissons-le simplement à 5.6, quelque chose comme ça. Parce que le type de données par défaut pour les nombres à virgule flottante est un double. Il n'est pas nécessaire d'ajouter un suffixe. Maintenant, juste pour vous informer, la syntaxe pour créer d'autres types à virgule flottante sera exactement la même que celle utilisée ici. Comme c'est le cas pour toutes les autres variables. Nous allons commencer par votre type de données, suivi du nom de votre variable. Et n'oubliez pas que nous n'avons besoin que de ces deux éléments pour le déclarer. Ensuite, nous pouvons également l'attribuer sur la même ligne, comme nous l'avons fait ici en ajoutant ce signe égal ou ce que certains d'entre vous appellent peut-être l'opérateur d'affectation. Et j'utiliserai ces mots de manière interchangeable. Sachez simplement que c' est la même chose, suivie d'une valeur ici. Donc, comme je le disais, nous aurions pu simplement déclarer nos variables comme ceci. Vous pouvez y accéder plus tard en utilisant uniquement le nom. Et ensuite, définissez-les comme quelque chose plus tard dans notre code. Comme ça. Cela aurait très bien fonctionné également. Quoi qu'il en soit, je vais aller de l'avant et annuler ça. Et une autre chose que je tiens à mentionner brièvement est que, contrairement aux types de données à nombres entiers, les types virgule flottante ne peuvent pas être signés ou non signés. Ils sont tous simplement assignés, ce qui signifie qu'ils peuvent en quelque sorte des nombres positifs et négatifs. Ensuite, nous allons imprimer ces deux variables. Donc, ici, nous allons dire CL. Ensuite, nous ajouterons un autre opérateur d'insertion, et nous dirons en ligne. N'ajoutez pas un autre opérateur d'insertion ici pour dire bonjour à. Juste comme ça. Nous avons donc créé un flotteur appelé hauteur et lui avons donné une valeur de 4,3. Nous avons ensuite ajouté le suffixe pour spécifier qu'il s' agissait d'un autre type de virgule flottante autre que le double, qui est le type par défaut. Ensuite, nous avons créé un double appelé hauteur deux et l'avons réglé à 5,6. Encore une fois, un double ne consomme pas suffixe, car un double est le type de données par défaut pour les nombres à virgule flottante et/ou les nombres avec une décimale. Ensuite, nous avons dit que nous voulions imprimer quelque chose. Et quoi que nous voulions imprimer, nous voulions imprimer une hauteur de 4,3. D'ailleurs, ce f ne sera pas imprimé. Il s'agit simplement d'un suffixe permettant au compilateur de dire explicitement quel est ce type de données. Ensuite, nous avons dit que nous voulions emprunter une nouvelle ligne. Nous avons donc ajouté cette ligne ici, et sur notre nouvelle ligne, nous l' imprimons en hauteur à 5,6. Donc, si nous exécutons un code, vous pouvez voir que tout fonctionne correctement. Encore une fois, notez que les suffixes pour les types à virgule flottante ne sont pas imprimés. Alors, tu y vas. C'est ainsi que vous pouvez créer et des types à virgule flottante. Et vous en verrez d'autres exemples plus tard dans le cours. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 11. Chapitre 3 (Variables) : booléens: Dans cet épisode, nous allons parler des booléens, également appelés taureaux, œil de taureau, ou d'un type de données permettant de stocker des valeurs vraies ou fausses, également appelé activé ou désactivé ou oui ou non, ou un ou 0. Alors allons-y et créons-en un exemple. Supposons, par exemple, que nous créions un programme pour une lampe. Il se peut que nous souhaitions stocker une variable indiquant si cette lumière est allumée ou éteinte. Alors, comment s'y prendre ? Eh bien, comme pour toutes les autres variables, nous allons commencer par leur type de données. Dans ce cas, nous allons dire Bool, tout en minuscules. Ensuite, nous allons le suivre avec le nom. Je vais le nommer ainsi. Ensuite, nous allons commencer et définir cette valeur sur false. Au fait, juste à titre de référence ici. Si quelque chose est vrai sur Oui, quel que soit le nom que vous voulez, c'est la même chose que de le mettre à un, dites que la valeur de celui-ci est un. Et si quelque chose est faux, maintenant je t'ai. C'est la même chose que de dire que c'est 0. Donc, voici une balle qui est réglée sur false, de la même manière que de dire que on est à 0. Et cela fonctionnera de toute façon. Quoi qu'il en soit, je vais aller de l'avant et nous y remettre. Assurez-vous que le mot faux est également en minuscules. Quoi qu'il en soit, allons-y, mettons cela sur la console et voyons ce qui se passe. Supposons que quelque chose comme CL soit activé. Génial. Les chanteurs imprimeront les choses à un moment sur la console tout au long du cours. Je vais juste dire Cl, puis ce que c' est que nous imprimerons juste pour que les choses continuent et que le dialogue soit juste pour que les choses continuent et que un peu plus clair. Quoi qu'il en soit, allons-y et lançons notre programme. Vous verrez qu'il imprime réellement 0. Parce que comme je l'ai dit, faux est identique à 0 en vrai et égal à un. D'ailleurs, il ne peut contenir qu'un ou 0. Vous pouvez également saisir explicitement faux ou vrai en minuscules, mais il ne peut pas contenir d'autres nombres en dehors de cela. Maintenant, il existe un moyen de faire en sorte qu'il affiche faux au lieu de simplement 0. Et je vais vous le montrer ici dans une minute. Très vite. Je vais aller de l'avant et changer cela en vrai. Et quand je le programme à nouveau, vous pouvez voir qu' il en imprime un. Maintenant, ce que je veux que vous fassiez, c'est copier le plan RSC ici avec un point-virgule. Et puis en dessous, nous allons dire CO. Ensuite, nous allons dire alpha cool. Puis un point-virgule à la fin. Juste comme ça. Une fois que nous l'avons tapé, nous activons réellement quelque chose. Donc, en gros, une fois que cela est activé, chaque fois que nous imprimons une valeur haussière, elle indiquera vrai ou faux. Donc, si nous collons notre ligne, nous l'avons simplement copiée ci-dessous, elle devrait maintenant indiquer un car notre valeur est vraie. Et puis, après avoir allumé la bobine Alpha ici, elle dira vrai. Et assurons-nous que ce soit sur une nouvelle ligne, sur notre première ligne ici à la fin. Et allons-y et ajoutons un autre opérateur d'insertion. Et nous dirons « fin de ligne » comme ça, ou « fin de ligne », devrais-je dire. Lorsque nous exécutons notre programme. Et vous y voilà. Maintenant dit un, puis vrai. Et ce serait pareil si nous allions de l' avant , changeons cela en faux et exécutions un programme, il fonctionnera exactement de la même manière. OK ? Et ce que nous allons faire, c'est copier à nouveau cette première ligne avec notre nième lien ici. Ensuite, nous supprimerons celui du bas et les collerons, le nouveau, comme suit. Ensuite, nous allons continuer et coller encore quelques fois. Et puis en dessous, il y aura CL, non, Alpha, tout en minuscules. Juste comme ça. Ensuite, nous allons continuer et coller le plan quelques fois de plus. Ensuite, lorsque nous activons l'alpha ici, au lieu d'imprimer les valeurs booléennes sous la forme 0 ou 1, il indiquera vrai ou faux. Et puis, lorsque nous le désactivons en disant No Bull Alpha, ce qui était le cas par défaut, il reviendra à 000. Je vais donc juste faire quelques commentaires ici. Et exécutez notre code. Comme vous pouvez le voir, 0 la première fois, puis imprimez-le faux trois fois, puis 03 fois. Ensuite, nous avons une ligne blanche parce que nous avons descendu une ligne ici. D'ailleurs, le spool Alpha in no, alpha fait partie de l'espace de noms std. Si vous vouliez le dire explicitement, encore une fois, vous pourriez dire que deux points deux-points standard suivis de alpha sont également acceptables. Mais comme nous l'avons déjà fait et que nous utilisons cet espace de noms, nous n'avons pas besoin de redéfinir d' où cela vient ou de dire explicitement d' où cela vient. Encore une fois, une dernière chose pour terminer la vidéo. Vous pouvez faire quelque chose au lieu de simplement dire que vous allez utiliser cet espace de noms en général, que nous utilisons actuellement pour les lignes CL, N et nous allons Alpha. Vous pouvez indiquer explicitement les éléments que vous allez utiliser à partir de cet espace de noms. Donc, je pourrais dire en utilisant deux points standard, deux points alignés avec un point-virgule à la fin, comme ça. Et puis vous pourriez faire de même pour CL et tirer Alpha et les ordinateurs portables sur les téléphones portables. Mais je vais aller de l'avant et remettre les choses comme avant. Bref. Vous savez maintenant comment utiliser et créer des variables booléennes, et nous les utiliserons également davantage tout au long du cours. C'est tout pour cette vidéo. Merci de m'avoir écouté, et à bientôt. 12. 11: Dans cette vidéo, nous allons parler du type de données char. Maintenant, char est l'abréviation de caractère, et donc datatype est utilisé pour stocker un seul caractère. La plage pour ce type de données est négative : 120 2027, signée, ou entre zéro et 255 données non signées. Et vous pouvez créer une version signée et non signée la même manière que nous l'avons fait avec la variable entière. Désormais, le type de données du graphique peut également utiliser des valeurs ASC, ISI, tos, et jouer certains personnages. Si vous voulez savoir de quoi il s'agit, vous pouvez simplement rechercher une référence de table A-S-C-I-I. Il s'agit de l'abréviation de l' American Standard Code for Information Interchange. Quoi qu'il en soit, allons-y et créons un type de données graphique. Nous allons donc dire graphique pour indiquer le type de données de la variable que nous créons, comme nous le ferions pour n'importe quelle autre variable. Alors on va lui donner un nom. Par exemple, nous appellerons cette lettre. Juste comme ça. Ensuite, nous allons également l' initialiser dès maintenant. Et nous dirons quelque chose d'égal à égal. Et puis, dans C plus, lorsque vous donnez à quelque chose la valeur d' un caractère ou d'un caractère, vous devez le mettre entre guillemets simples. Ensuite, nous pourrions dire que nous pouvions faire des choses capitales si nous le voulions. Cela sera imprimé comme il ferait si nous le mettions entre guillemets, un sur les instructions C out. Aussi gros qu'un chapiteau, il sera imprimé en tant que majuscule. Et s'il est en minuscule, il sera imprimé en tant que tel. Nous pouvons aller de l'avant et le tester maintenant. Donc, en bas, j' essaie de dire, oui. Lettre. Puis un point-virgule à la fin. D'ailleurs, pour ceux d'entre vous qui utilisent Visual Studio pendant que vous tapez, vous remarquerez peut-être cette liste déroulante. Et vous pouvez y accéder en utilisant les flèches vers le haut et vers le bas , puis en appuyant sur Entrée pour en sélectionner une. Ici, le nom de notre variable apparaît automatiquement au fur et à mesure que nous le saisissons. Et nous pouvons appuyer sur Entrée pour le remplir automatiquement. Et cela deviendra de plus en plus utile au fur et à mesure que nous manquions de programmes plus volumineux et que nous tapions un peu. Ou si vous avez un nom de variable plus long. Quoi qu'il en soit, allons-y et lançons notre programme. Et comme vous pouvez le voir, une faute de frappe. Vous pouvez également imprimer un caractère A-S-C-I-I aléatoire en saisissant un numéro associé à un caractère ici. Donc, par exemple, je vais juste en mettre 25. Maintenant, ce n'est pas vraiment aléatoire et cela imprimera la même chose à chaque fois. Je voulais juste dire que je ne sais pas quel personnage cela va imprimer. Nous devons donc le gérer. Et comme vous pouvez le voir ici, il imprime une flèche vers le bas. Et juste pour prouver que ce n'est pas un hasard, si je le lance à nouveau, il imprimera une flèche vers le bas à chaque fois. Comme je l'ai dit, vous pouvez toujours rechercher une référence de table des caractères ASC II si vous voulez voir quels sont ces et jouer avec cela. Remarquez cela parce que nous n'avons pas saisi un seul caractère comme valeur de notre variable char ici. Nous avons retiré les guillemets individuels. De plus, juste pour vous le montrer, allons-y et supprimons la valeur sur 25 ans. Remettez nos guillemets individuels. Ensuite, je vais juste commencer, taper un numéro comme trois et exécuter notre code. Cela fonctionnera également. Et juste pour vous montrer cela, juste dit avant, vous pouvez procéder et en faire un graphique signé en prenant un sinus. N'oubliez pas que c' est la valeur par défaut. Donc ceci et ceci sont exactement les mêmes pour, disons, non signés, comme ça. Et alors cela ne peut avoir qu'une valeur positive. Maintenant, si nous voulons l'appeler à nouveau, vous pouvez voir qu'il fonctionne toujours. Quoi qu'il en soit, c'est tout pour cette vidéo. Dans la vidéo suivante, nous allons passer revue le type de données de chaîne utilisé pour stocker plusieurs caractères, mots ou phrases. Alors merci de m'avoir écouté, et à bientôt. 13. Chapitre 3 (Variables) : chaînes: Dans cet épisode, nous allons parler de chaînes de caractères, qui sont un type de données destiné à contenir une série de caractères ou une séquence de caractères. Donc, en gros, chaque fois que vous souhaitez stocker une série de texte ou de chiffres plus longs qu'un seul caractère, vous devez utiliser une chaîne. Nous allons également inclure la chaîne du fichier d'en-tête. Donc, ci-dessous, cela copiera ce qui se trouve ci-dessus. Supposons que le hashtag inclue le symbole « moins que ». Nous allons dire chaîne de caractères, suivie du symbole supérieur à. Et vous y voilà. Nous aurons maintenant accès à tout le code contenu dans ce fichier. De plus, pour ceux d'entre vous qui utilisent Visual Studio, vous pouvez cliquer dessus avec le bouton droit souris et accéder à un document de référence. Et vous pouvez consulter le code contenu dans ce fichier. Mais pour la majorité d'entre vous et moi, ce n'est pas vraiment important. Mais pour ceux d'entre vous qui peuvent en avoir besoin ou qui sont simplement curieux, il y a une façon de procéder et d'examiner cela. Alors, comment créer une chaîne ? Eh bien, comme n'importe quelle autre variable. Nous allons donc faire une chaîne, type de données et tout en minuscules. Ensuite, nous allons y aller et lui donner un nom. Appelons donc ce nom, par exemple. Ensuite, nous allons le mettre sur un pied d'égalité avec John Doe. N'oubliez pas que chaque fois que nous travaillons sur une série de textes, nous utilisons des guillemets doubles. Et lorsque nous travaillons avec un seul caractère, utiliserons les guillemets simples. Comme nous voulons stocker une chaîne de caractères, nous allons utiliser les guillemets. Et nous dirons John, juste comme ça. Et si nous voulons l' imprimer, nous pouvons simplement dire C out. Et si nous exécutons notre programme, vous pouvez le voir », explique John Doe. Et d'ailleurs, une chaîne, ainsi que beaucoup d' autres choses que nous avons utilisées et qu'elle utilisera à l'avenir, font toutes partie de cet espace de noms std. Vous pouvez le définir explicitement ici si vous le souhaitez. Vous pouvez même voir que si je passe la souris dessus dans Visual Studio, cela me permet de savoir qu'il fait partie de cet espace de noms. Mais pour le reste du cours, je vais simplement laisser cela ici afin que tout ce qui fait partie de cela pas obligée de le mentionner explicitement. Maintenant, très rapidement, avant de terminer la vidéo, nous allons passer en revue quelques fonctions qui font partie de la classe des chaînes. Comme je l'ai dit, nous allons passer en revue les fonctions des classes. Plus tard dans le cours. Il y aura plusieurs vidéos dessus. Ne vous inquiétez donc pas de comprendre ce qu'ils sont ou comment ils fonctionnent actuellement. Mais je voulais juste passer en revue quelques-unes d'entre elles avec vous afin que vous sachiez comment les utiliser. Et juste pour que vous ayez une idée du type de fonctionnalité disponible pour les chaînes. Donc, par exemple, allons-y et nettoyons cette ligne ici. Donc, après la sortie d'un c et l'opérateur d'insertion, allons-y et mettons des guillemets. Et nous dirons que je m' appelle. Juste comme ça. N'oubliez pas que nous devons ajouter un autre opérateur d'insertion pour en séparer notre variable ici. Au fait, ce truc entre ces guillemets, oui, je sais que c'est du texte, mais on l' appelle aussi une chaîne littérale. Maintenant, lorsque nous exécutons un programme, ils disent Mon nom est espace, puis le nom que nous avons inséré. Mais allons-y et examinons également quelques fonctions de la classe de chaînes. Alors très vite, allons-y et ajoutons quelques commentaires. Ici. Je vais me dire une chaîne. Juste ici, je vais dire. Ensuite, en bas, nous allons dire la longueur de notre nom, espaces compris. Et ensuite, ici, nous allons dire la version plurielle. Et je vais vous montrer pourquoi dans une minute. Très bien, donc la première méthode, nous allons l' essayer en tant que méthode de longueur. Et comme je l'ai dit, nous allons passer en revue les fonctions méthodes en intérieur plus tard dans le cours. Donc, pour l'instant, il suffit de les suivre juste pour voir comment ils fonctionnent. Nous allons donc dire nom, qui est le nom réel de notre chaîne ici, puis mourir, également connu sous le nom d' opérateur d'accès aux membres, ou symbole de point. Ensuite, nous allons dire longueur, toutes en minuscules, entre parenthèses ouvertes et fermées, et un point-virgule à la fin. Ensuite, ici, nous allons en faire une autre en prononçant un nom. Diet, push, tout en minuscules, soulignez en arrière, puis ouvrez et fermez les parenthèses et un point-virgule à la fin. Et puis, à l'intérieur de ces parenthèses, nous devons mettre un caractère. Et si nous passons la souris dessus, vous pouvez voir qu' à l'intérieur des parenthèses cela indique qu' il faut une valeur de caractère. Nous allons donc mettre des guillemets simples. Et puis un S Juste comme ça, parce que nous ne travaillons qu' avec un seul personnage. Nous avons utilisé des guillemets simples. Et maintenant, ce qu'il va publier c'est que notre nom est John Doe. Parce que c'est ce que nous avons tapé ici. Ou tout ce que vous y avez tapé sera imprimé. Ensuite, il indiquera la longueur de notre nom, espaces compris. Je vais juste avoir huit ans. Ensuite, cette fonction ajoute un S à la fin de notre chaîne ou à la lettre que nous saisissons ici. Cependant, cela ne va rien faire. Donc, si nous exécutons notre code, cela fonctionnera. Et comme vous pouvez le voir, il fonctionne comme je le faisais auparavant. Le problème, c'est que nous faisons n'importe quoi avec ces valeurs. Donc, même si j' ai maintenant la longueur, nous ne l'avons pas imprimée sur la console. Alors allons-y et faisons-le. Nous allons dire CO, suivi l'opérateur d'insertion, puis de notre nom, point length. Et cela fonctionnera très bien. Comme vous pouvez le voir, il y a John Doe, puis huit. Et nous pouvons aller de l'avant avec une nouvelle ligne correspondante en disant comme nous l'avons fait par le passé. Et un autre opérateur d'insertion, comme ça. Et ça va tout nettoyer. Et puis ici, nous pouvons réellement imprimer cette année parce que tout cela ne fait qu'ajouter un S à notre nom ici. Ensuite, nous allons commencer et dire CL pour créer une nouvelle ligne. Ensuite, nous imprimerons notre nom. Assurez-vous de mettre un point-virgule à la fin. Et nous allons exécuter notre code. Maintenant dit : Je m'appelle John Doe. Nous avons imprimé la longueur de notre nom car c'est ce que cette fonction renvoie ici sous forme de valeur. Et nous sommes en mesure de mettre cette valeur ici et notre déclaration de sortie. Et puis ici, nous avons essayé une autre fonction qui faisait partie de la classe de chaîne, qui nous permet d'ajouter un caractère à la fin de notre chaîne. Donc, au lieu de John Doe, il est écrit John Dos. Et nous l'avons imprimé sur une ligne séparée. Comme ça. Et comme je l'ai dit, ne t' inquiète pas vraiment de tout comprendre pour l'instant. Je voulais juste vous montrer certaines des possibilités qu'offrent les cordes. Mais tu n'auras pas besoin de le savoir à l'avenir. Et si cela vous intéresse, n'hésitez pas à consulter la classe de chaînes et certaines de ses autres fonctions possibles. La seule chose que vous devez vraiment retenir de cette vidéo est que lorsque vous travaillez avec une chaîne ou un MP, envoyez le fichier d'en-tête de chaîne en utilisant cette instruction include en haut. Ensuite, nous avons créé une chaîne de la même manière que tout autre type de variable, sauf que nous avons spécifié qu'il s'agissait d'une chaîne et que ce n'était pas un entier ou quelque chose comme ça. Ensuite, nous l'avons utilisé de la même manière si nous faisions avec n'importe quelle autre variable lors de l'impression. Et pendant que nous sommes ici, je veux vous montrer que si nous essayons saisir une valeur différente, telle que 54 ou quelque chose comme ça, nous allons immédiatement obtenir cette erreur. Et cela nous indiquera que cela ne convient pas à ce type de données. Il est donc bon de noter que cela ne vous laissera pas gâcher. Si vous essayez de saisir le mauvais type de données. Il va juste vous faire savoir suite que c'est incorrect, moins quand il s'agit de quelque chose d'aussi radicalement différent que les chaînes et les entiers. Et ce que je veux dire par là, c'est que nous reviendrons dans une prochaine vidéo ici, mais nous voulions juste vous le montrer de toute façon, donc c'est tout pour cette vidéo. Et à partir de maintenant et pour le reste du cours, nous allons simplement continuer et laisser cette instruction include pour le fichier de chaîne. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 14. Chapitre 3 (Variables) : constantes: Dans cette vidéo, nous allons parler de constantes. Maintenant, une constante n'est fondamentalement qu'une variable. Tu ne veux jamais changer. Et vous vous demandez peut-être pourquoi je ferais cela ? Eh bien, la raison en est qu'en matière de programmation, vous devez faire tout ce que vous pouvez pour vous assurer que rien ne va mal avec votre code, en gardant à l'esprit l'erreur humaine. Supposons, par exemple, que vous créiez une émission à quatre heures et que vous vouliez que cette horloge sache qu'il y a 60 minutes par heure. Et cela n'allait jamais changer. Vous voudriez en faire une variable constante de telle sorte qu'il n'y ait aucun moyen gâcher et de l'embrouiller avec le reste de votre code en fin de ligne. Donc, nous allons faire un say const, qui est un mot clé pour représenter que nous voulons créer une variable constante de sorte qu'un CONTRE soit t. Et ensuite nous allons dire, et ensuite nous allons dire minutes par heure pour nommez-y. Ensuite, nous allons fixer cette valeur à 60 et mettre un point-virgule à la fin. Tu y vas. Nous avons maintenant créé une variable constante qui ne peut pas être modifiée. Vous pouvez le faire avec les différents types de variables. Eh bien, vous devez mettre ce mot clé constant avant le type de données. Donc, en gros, la syntaxe ou la règle pour créer une variable constante. Et vous allez dire const, suivi du type de données, suivi du nom, puis l'affectation de la variable. Mettez-leur donc l'opérateur d'affectation, suivi de la valeur. Maintenant, une chose à noter avec constantes, c'est que nous ne pouvons pas simplement le déclarer comme ceci. Et puis plus tard, disons que les minutes par heure sont égales à dix. Par exemple. Si je passe la souris sur le point-virgule ici, vous pouvez comprendre pourquoi. Il s'agit de la variable const. minutes par heure nécessitent un initialiseur. Si vous voulez créer une variable constante que vous ne voudrez jamais modifier. Vous devez l'initialiser et lui donner la valeur que vous souhaitez garder permanente, n' est-ce pas, lorsque vous déclarez la variable. Ainsi, contrairement aux variables normales, vous ne pouvez pas déclarer une variable constante et l'initialiser ultérieurement. C'est tout ce que j'ai pour être exactement sur la même ligne. Donc, nous dirons que la constante en minutes par heure est égale à 60, juste comme ça. Et juste pour vous montrer que nous ne pouvons pas changer cela plus tard. Maintenant, je sais que ça n'a pas l'air très important pour le moment. Mais lorsque vous commencez à travailler avec des programmes de plus en plus volumineux qui comportent plusieurs lignes de code et peuvent comporter plusieurs pages. Vous voulez vous assurer qu' il n'y a aucun moyen possible. Ainsi, le nombre de minutes par heure pourrait être modifié car il doit être de 60. Et surtout si nous fabriquons une horloge, n'est-ce pas, si elle est décalée d'un chiffre à la fin d' un mois ou d'une année. Qui que soit l'horloge, ça va être foiré, non ? Nous voulons donc simplement nous assurer qu'il est le difficile possible que notre code soit mal utilisé. Et même si le programme lui-même ne va rien faire, vous ne lui dites pas de le faire. Vous voulez rendre compte de l'erreur humaine ? De plus, il n'est pas si difficile d'ajouter ces mots clés rapides et de s'assurer que cette valeur est permanente. Et juste pour vous montrer ceci, si je devais dire minutes, notre ici, et ensuite essayer de le mettre à environ dix. Je vais recevoir une erreur immédiate m' indiquant que ce n'est pas une valeur modifiable car il s'agit d'une valeur constante. Alors que si je devais le supprimer, ce n'est plus constant. Je peux le changer comme je veux. Je vais donc y aller et le remettre en place. Et à cause du fonctionnement des constantes et de la façon dont le code est lu de haut en bas, même si j'avais plusieurs lignes qui ne le perturbaient pas déjà dans mon code. Dès que j'y mets ce mot clé constant, tout ce qui essaie d' ajuster cette valeur apparaisse comme une erreur, me faisant savoir que cela ne peut pas être fait. Donc, s'il y avait quelque chose qui compliquait ça avant de lancer ce mot clé const me donnera facilement accès à n'importe quoi. On a essayé de modifier cette valeur. Et une dernière chose avant de terminer cette vidéo, je veux juste vous montrer que même si cette valeur est constante et que nous ne pouvons pas la modifier, nous avons toujours accès à la valeur qui est considérée comme une lecture seule valeur. Vous pouvez le lire mais vous ne pouvez pas y écrire, vous ne pouvez pas le manipuler. Donc, si nous disons CL minutes par heure et que nous exécutons notre code, vous pouvez voir que nous pouvons toujours collecter cette valeur. Nous pouvons toujours dire que c'est 60, mais nous ne pouvons tout simplement pas le changer. Et voilà, vous l'avez. Vous savez maintenant tout ce qu'il faut savoir sur les constantes et la programmation. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 15. Chapitre 4 (entrée utilisateur) : Cin: Dans cette vidéo, je vais enfin vous montrer comment nous pouvons réellement récupérer les commentaires de l'utilisateur plutôt que de simplement les lui envoyer. Ainsi, par exemple, nous allons demander quelques informations différentes à l'utilisateur, puis les imprimer à nouveau sur la console. Très vite, je vais juste ajouter quelques commentaires. Nous allons donc leur demander leur prénom. Ensuite, nous leur demanderons leur nom de famille. Enfin, nous leur demanderons leur âge. Ensuite, nous irons de l'avant et leur imprimerons tout cela. Ce n'est qu'un exemple rapide de l'utilisation de commentaires pour rendre le code plus lisible. Mais lorsque vous commencez à écrire des programmes de plus en plus volumineux, je vous recommande vivement d'entrer dans beaucoup plus de détails et de vraiment décomposer ce que chaque ligne de code, où la fonction fonctionne lorsque nous arrivons à ce point. Parce que lorsque vous revenez et que vous regardez votre code, ce soit des jours, des semaines, mois ou même des années plus tard, ou que quelqu'un qui n'a jamais vu votre code auparavant, il y jette un coup d'œil. Il sera d'autant plus facile de comprendre ce qui se passe ici, au sommet. Allons-y et créons quelques variables pour stocker leurs informations. Donc, d'abord, nous allons créer une chaîne pour stocker le FirstName. Nous allons donc dire un prénom en chaîne. Ensuite, nous allons simplement mettre un point-virgule juste ici à la fin. Ensuite, en dessous, nous dirons la chaîne LastName. Et en dessous de cela, nous allons continuer et dire âge. Juste comme ça. Nous avons créé trois variables et nous venons de les déclarer. Nous ne leur avons pas donné de valeur initiale. Donc, bien que nous puissions entrer une valeur initiale pour chacune d'entre elles, je vais les laisser vides juste pour vous montrer que nous pouvons demander à l'utilisateur de saisir une valeur initiale plutôt que insérons une valeur initiale et leur permettons simplement de la modifier. Ici, nous allons commencer et dire CL. Et puis, entre guillemets, vous direz votre nom. Espace du côlon. Juste comme ça. Je ne mets pas de point-virgule à la fin. Et puis ci-dessous, nous allons en fait collecter ces informations auprès de l'utilisateur. Et pour ce faire, nous allons commencer et dire c n. Ensuite, le symbole supérieur à deux fois, suivi du nom de notre variable, du prénom, puis d'un point-virgule à la fin, comme ceci. Alors que là-haut, nous avons dit « c out » pour transmettre des informations à l'utilisateur. Nous allons dire C N pour récupérer les informations de l'utilisateur. Et aussi, au lieu d'un opérateur d' écoute, cela va insérer quelque chose dans le programme ou la console. Dans ce cas, nous utilisons l'opérateur d'extraction pour extraire quelque chose de notre programme vers notre code ici. Ainsi, les deux symboles inférieurs à constituent l'opérateur d'insertion, et les deux symboles supérieurs à constituent l'opérateur d'extraction. Et au lieu de produire des informations, nous avons obtenu des informations. Personnellement, j' aime considérer ces opérateurs d'insertion et d'extraction comme des flèches. Et imaginez que mon programme se trouve quelque part ici. Je publie donc des informations dans mon programme et je les réinsère de cette façon à l'endroit où se trouve mon code. C'est donc une façon de voir les choses si cela vous aide. Génial. Donc pour l'instant, si nous exécutons notre programme, il va dire «  tapez votre prénom ». Notre curseur dans la console va se retrouver ici. Et ils peuvent saisir leur prénom. Et puis, lorsque l' utilisateur appuie sur Entrée, il insère son texte dans le programme. Nous récupérons donc réellement les informations. Et c'est un peu la même chose avec notre méthode get ici. Et de cette façon, faites confiance ou appuyez sur Entrée. Une fois que l'utilisateur appuie sur Entrée, nous pouvons réellement récupérer des informations de sa part. Et c'est alors que tout s'exécute. Donc, ici, nous vous disons de taper votre prénom. Ils peuvent taper ce qu'ils veulent, puis appuyer sur Entrée. Et cette information ou cette chaîne de caractères sera stockée ici même dans notre chaîne FirstName. Mais nous devons quand même le saisir à nouveau à l'utilisateur ou en faire quelque chose. Sinon, elle restera juste là dans la variable et nous ne l'avons jamais réellement utilisée. Et c'est ce qu' il fera ici dans un instant. Mais d'abord, allons-y et créons une ligne blanche. Nous allons donc simplement dire CO. Et juste comme ça, allons-y, copiez-collez ceci ci-dessous. Comme nous allons faire à peu près la même chose pour obtenir leur nom de famille, sauf qu'au lieu de FirstName, nous allons dire LastName, qui est le nom de notre autre variable. Et ici, nous vous dirons de taper votre nom de famille. Alors, juste pour que tous nos textes ne soient pas regroupés. Allons-y et ajoutons une autre ligne blanche. Je ne l'ai donc pas annulé. Je vais juste ajouter un autre opérateur d'insertion et dire en ligne. Et je ferai de même. Ensuite, recopions tout cela et collez-le ici. Ensuite, nous dirons tapez votre âge. Ensuite, les informations qu'ils saisissent. Nous voulions entrer dans notre époque. Très bien, et assurez-vous que lorsque nous arriverons à cette partie d'un programme, vous tapez réellement un nombre entier. Parce qu'à l'heure actuelle, nous n'avons aucun moyen de vérifier s' ils ont réellement placé un nombre entier ou si une variable entière ne peut contenir qu'un nombre entier. Donc, pour éviter tout problème ou toute erreur, assurez-vous simplement de saisir un nombre entier. Si ce n'est pas le cas, vous pouvez toujours le fermer et relancer votre programme. Plus tard dans ce cours, nous verrons comment vérifier les différentes conditions. Mais pour l'instant, nous allons juste nous assurer de tout prendre correctement. Ensuite, nous allons imprimer leur nom complet et leur âge. Alors allons-y et disons CL. Ton nom est un espace comme ça. Ensuite, nous ajouterons un autre opérateur d'insertion. Et nous allons dire FirstName, suivi d'un autre opérateur d'insertion, avec un espace entre guillemets. Donc, un autre opérateur d'insertion et disons, d' accord, et puis en bas, nous allons continuer et dire ligne de sciatique. Un autre opérateur d'insertion. Et nous dirons que votre âge est l' espace deux-points, un autre opérateur d'insertion. Et puis passez par la mineure. Quel point-virgule à la fin. Laissez-moi zoomer ici pour que vous puissiez vous assurer que tout votre code correspond au mien. Ensuite, nous allons lancer le programme. donc le prénom, tapez ce que vous voulez et appuyons sur Entrée. Il va demander notre nom de famille. Maintenant, remarquez que lorsque nous avons appuyé sur Entrée après avoir tapé votre nom, cela a compté. Cela passe à la ligne suivante. Alors cette ligne finale est descendue encore une fois, et la ligne suivante est descendue encore une fois. Il y a donc en fait deux espaces. Donc, si nous voulons nettoyer cela, nous pouvons simplement supprimer l'une de ces n lignes de chacune d'elles. Sinon, je pense que ça a l'air très bien tel qu'il est. Je voulais juste vous en informer. Ensuite, tapez tout ce que vous voulez pour le nom de famille, entrez à nouveau. Ensuite, je vais demander h. Je vais taper un nombre entier. Ça peut être ce que tu veux, peu importe. Et appuyez à nouveau sur Entrée. Et cela clôturera le programme. Et vous vous demandez peut-être pourquoi il a fermé ses portes immédiatement. La raison en est que nous avons appuyé sur Entrée à la fin. Il a en fait compté que la mort faisait partie du péché. Donc, ce que nous allons faire, c'est simplement copier ceci et le coller une fois de plus. Alors lancez à nouveau le programme, récapitulant simplement nos trucs. Et voilà, vous l'avez. Donc, et c'est pour le prénom, tapez, quel que soit le nom de famille que nous voulons, séparez tout le monde. Pour ce qui est de votre H, pareil. Assurez-vous simplement qu'il s' agit d'un nombre entier, puisqu'il est stocké dans un entier, gardez à l'esprit que nous aurions pu simplement le mettre dans une chaîne et cela fonctionnerait très bien. Ensuite, nous l'imprimons à nouveau pour l'utilisateur. Votre nom est et votre âge est suivi de leur nom et de leur âge. Et juste pour vous montrer que cela fonctionnerait comme une chaîne, je vais mettre de la chaîne juste là, lancer le programme. Et comme vous pouvez le voir, cela a très bien fonctionné. Mais je voulais juste vous montrer que vous pouvez collecter différents types de variables auprès de l'utilisateur. Il n'est pas nécessaire que ce soit une chaîne. Maintenant, j'espère que vous avez appris quelque chose ici. Si vous êtes confus, je vous recommande vivement de revenir en arrière, de regarder à nouveau la vidéo. Et si vous n'arrivez toujours pas à le comprendre et faites-le moi savoir dans la section de discussion ci-dessous, je vous recontacterai dès que possible. Mais ne vous inquiétez pas si vous avez l' impression de l'avoir, mais que vous voulez quand même vous entraîner un peu plus et nous ferons beaucoup de choses avec ce genre de choses tout au long du cours. Bref, merci de m'avoir écouté, et à bientôt. 16. Chapitre 4 (entrée utilisateur) : les fonctions Getchar et Getline: Comment ça va, tout le monde ? Dans cette vidéo, nous voulons demander à l'utilisateur son nom complet, le stocker dans une variable et le réimprimer. Maintenant, vous vous demandez peut-être : « N'est-ce pas ce que nous venons de faire dans la dernière vidéo ? Eh bien, en quelque sorte, mais dans cette vidéo, nous allons utiliser quelques nouvelles méthodes. Je voulais donc m'en tenir à quelque chose qui vous était déjà familier. Nous allons vous présenter quelque chose de nouveau. Nous allons donc créer une chaîne ici. Et nous l'appellerons nom complet. Juste comme ça. Et nous allons simplement le déclarer. Nous n'allons rien y mettre. Alors. Nous allons demander à l' utilisateur son nom complet. Alors allez-y et dites C out. Et puis entre guillemets, vous direz « Veuillez prendre l'espace deux-points à la fin ». Et ensuite, ici, nous allons imprimer leur nom complet. N'oubliez pas votre point-virgule à la fin. C'est ce que dit CL. Ensuite, entre guillemets, nous allons mettre une barre oblique inverse et nous prononcerons votre nom complet. L'espace du côlon, juste comme ça. Ensuite, nous ajouterons un autre opérateur d'insertion imprimé, le nom complet, le nom qu'ils nous ont donné. Maintenant, dans la dernière vidéo, nous sommes allés de l'avant et avons dit péché pour recueillir leur nom complet. Allons-y et recommençons. Juste pour te montrer quelque chose. Vous allez juste le retirer. Donc on va dire cin, nom. Et ensuite, après avoir imprimé leur nom complet, allez-y et inscrivez une autre ligne N ici. Juste comme ça. Et vous verrez pourquoi je l'ai mis ici dans un instant. Maintenant, selon le programme que vous utilisez, il devrait y avoir un moyen d' exécuter votre code sans déboguer ni vérifier les erreurs essentiellement. Et dans Visual Studio, vous pouvez soit appuyer sur Control plus F5 soit simplement appuyer sur ce lien vide en haut. Et quel que soit le programme que vous utilisez, il devrait y avoir une option pour exécuter votre code sans débogage. Mais sinon, vous pouvez simplement prendre le code Sendai get. Il suffit de le copier et de le coller plusieurs fois et vous devriez obtenir le même effet. Vous devrez peut-être saisir quelques termes supplémentaires, sortir ou appuyer sur le X en haut de votre programme. Mais je vais juste y mettre celui que j'ai eu tout au long du cours et courir sans déboguer. Et la raison en est un peu plus compliquée que ce que je veux aborder pour le moment. Mais pour l'instant, essayez simplement d' exécuter votre code sans déboguer ou copiez et collez cette ligne ici plusieurs fois et tout ira bien. Ainsi, lorsque nous exécuterons notre code, il indiquera, s'il vous plaît, tapez votre nom complet. Allez-y et prenez John Doe par exemple. Et puis vous remarquerez qu'il est simplement écrit « Mon nom complet est John ». Puis il m'a demandé d' appuyer sur n'importe quelle touche pour continuer. Et cela est dû à Visual Studio, au moins lorsque vous exécutez votre code sans débogage, il ne se ferme pas automatiquement. Maintenant, pourquoi est-ce que c'est juste écrit « John » ? Eh bien, à cause de cet objet péché que nous utilisons pour récupérer les informations de l'utilisateur, cessera d'enregistrer les informations une fois que nous les aurons placées dans cet espace ici. C'est pourquoi, dès que nous avons fini taper Jon, on a dit : «  OK, je suis juste John, juste ici pour le nom complet ». Et si nous voulions tout collecter , y compris l'espace ? Eh bien, nous pouvons utiliser une nouvelle fonction appelée fonction getline. instant, allons-y et commentons cette ligne ici afin que nous puissions toujours la voir, mais cela n'affectera pas réellement notre code. Donc, juste en dessous de notre instruction cin, nous allons dire getline et toutes les parenthèses ouvertes minuscules, suivies de sin ou C, d'un espace virgule, suivi du nom de notre variable, étant nom complet, parenthèses et point-virgule à la fin. Juste comme ça. Maintenant, ce que nous faisons, c'est entrer les informations que nous obtenons de notre fonction getline ici dans le nom complet de la variable. Contrairement à notre dernière instruction ici, qui enregistrait des informations et les plaçait dans une variable jusqu'à ce que nous appuyions sur la barre d'espace ou sur la touche Entrée, ainsi obtenir une fonction de ligne ou une méthode ici va collecter jusqu'à ce que nous appuyions sur la touche Entrée. Il va donc sélectionner tout ce qui se trouve sur cette ligne. Maintenant, nous exécutons notre code, nous pouvons saisir notre nom complet. Et il imprimera notre nom complet. Et puis très vite, j'ai une dernière méthode à te montrer. Alors allons-y et commentons notre méthode getline que nous venons d'utiliser. Et puis en dessous, nous allons dire que le nom complet est égal à getchar, toutes les minuscules, les parenthèses ouvertes et fermées, et un point-virgule à la fin. Avec cette méthode ou cette fonction , vous pouvez simplement saisir le caractère suivant. Et je vais vous montrer comment cela fonctionne, puis allez-y et fermez votre programme sans déboguer à nouveau. N'oubliez pas que s'il ne peut pas le faire pour quelque raison que ce soit, suffit de copier et coller la ligne sin point getline plusieurs fois. Vous pouvez toujours quitter le programme manuellement. Donc, tapez simplement votre nom complet, allez-y et tapez ce que vous voulez. Appuyez sur Entrée. Vous remarquerez qu'il ne prend que le premier caractère. Nous sommes donc allés de l'avant, tapez-les comme nous le voulions. Ensuite, une fois que nous avons appuyé sur Entrée, tout ce que nous avons saisi est réellement placé dans le programme. Il ne sauvegarde que cette première lettre parce que c'est ce nous lui avons dit de faire et nous l'avons réimprimée. Tu y vas. Oui. Chaque fois que nous travaillons avec la console, vous pouvez littéralement taper comme vous le souhaitez et cela ne fera rien. Puisque vous avez saisi tout ce que vous avez tapé, il sera en fait intégré au programme que nous exécutons ici. Ensuite, il fera ce que vous lui avez demandé avec ces informations. Quoi qu'il en soit, c'est tout pour cette vidéo, je voulais juste vous montrer ces deux méthodes supplémentaires que vous pouvez je voulais juste vous montrer ces deux méthodes supplémentaires que vous pouvez utiliser pour obtenir des informations utilisateur. Maintenant, la fonction get char ici n'est peut-être pas très utile pour vous la plupart du temps, mais il y en aura certainement plusieurs fois car cette fonction getline vous sera certainement utile. Et il existe en fait d'autres façons d'utiliser cette méthode que vous pouvez rechercher en ligne si vous êtes intéressé. Mais pour l'instant, c'est la solution de base et celle la plus susceptible d'être utilisée le plus souvent. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 17. Chapitre 4 (entrée de l'utilisateur) : chaîne à insérer: Dans cette vidéo, je vais vous montrer comment convertir une chaîne nombre et comment faire l'inverse de la conversion d' un nombre en chaîne. Alors allons-y. Maintenant, ici, j'ai quelques méthodes différentes que vous pouvez utiliser. Il suffit de vous montrer qu' il y en a une poignée. Et il y a en fait bien plus que les trois que j'ai listés, mais nous allons simplement utiliser ce premier à titre d'exemple. Alors allons-y et créons un entier. Nous dirons que le nombre est égal à cinq. Ensuite, ci-dessous, vous allez réellement créer une variable de chaîne. Nous allons dire chaîne, nombre écrit égal. Nous allons mettre ce dix entre guillemets doubles parce que nous voulons que ce soit une chaîne. Donc, en bas, nous allons imprimer notre nombre entier. Donc, on va dire « C ». Ensuite, en dessous, vous allez créer une ligne vide. Et ensuite, en dessous, nous allons convertir notre chaîne en nombre. Alors, comment pouvons-nous nous assurer que cela fonctionne ? Tout d'abord, nous allons y aller et dire que le nombre est notre entier. Ensuite, nous allons le mettre sur un pied d'égalité. Ensuite, nous allons utiliser une nouvelle méthode. Nous allons donc dire S, T, O, et tout en minuscules entre parenthèses. Nous allons mettre le nom de notre chaîne. Nous allons donc dire un chiffre rouge, fermer les parenthèses et mettre un point-virgule à la fin. Alors, assurez-vous qu'il correspond à moi ici. Nous créons donc d'abord un entier appelé nombres pour que le cinq. Ensuite, nous avons créé une chaîne appelée nombre aléatoire et l'avons définie une chaîne contenant juste le chiffre dix , rien de plus. Et puis en dessous, nous avons imprimé le numéro, sauté la ligne ou descendu d'une ligne, devrais-je dire. Ensuite, nous définissons un nombre égal au nombre écrit, qui devrait être dix. Et nous l'avons fait avec cette méthode appelée S, trop courte pour passer d'une chaîne à un entier, non ? Parce que nous voulons convertir cette chaîne en entier afin de pouvoir définir notre entier actuel comme lui égal. Ensuite, nous allons créer une autre ligne blanche. Et nous imprimerons également à nouveau le numéro. D'ailleurs, pour le reste du cours, je vous recommande de simplement exécuter votre code sans le déboguer. Et si vous utilisez Visual Studio, oubliez pas que vous pouvez simplement maintenir la touche Ctrl enfoncée et appuyer sur F5. Et comme vous pouvez le voir, nous avons dit cinq, puis dix. Même si nous avons simplement imprimé le nombre entier deux fois. Parce que nous sommes capables de convertir ce nombre ici à l'intérieur de notre chaîne en un entier. À propos, pour ceux d'entre vous qui utilisent Visual Studio, s'il est difficile de garder le contrôle et de diriger un cinq, vous pouvez toujours appuyer sur ce bouton en haut. Ou si vous le souhaitez vraiment, vous pouvez aller dans Outils, Options, descendre jusqu'au débogage. Général. Tout en bas. Décochez simplement la case que nous avons cochée dans la deuxième vidéo. Cela ferme automatiquement la console lorsque le débogage s'arrête. Sinon, vous pouvez toujours la laisser cochée et les deux options s'offrent à vous à tout moment. Et c'est utile car lorsque vous envoyez votre programme à quelqu'un pour qu'il l'utilise, il ne restera pas simplement ouvert comme dans Visual Studio. C'est donc agréable de pouvoir avoir les deux options. Mais pendant que vous ne faites que coder, vous entraîner et apprendre, vous pouvez simplement décocher cette case et appuyer sur OK. Et nous attendrons que vous appuyiez sur une touche avant de fermer le programme, même si vous l'exécutez avec le débogage activé, en appuyant simplement sur F5. Et vous pouvez aller de l'avant et supprimer ce problème si vous décidez de le faire je n'en ai vraiment ici que pour les personnes qui pourraient en avoir besoin. Maintenant, la prochaine chose que nous allons faire est de convertir un nombre en chaîne. Eh bien, comment faisons-nous cela ? Donc, au lieu de convertir numéro cinq ici en ce nombre dix, en convertissant notre chaîne en une fin comme nous l'avons fait ici. Allons-y et commentons ces deux lignes. D'ailleurs, pour ceux d'entre vous qui utilisent Visual Studio, vous pouvez simplement surligner les lignes que vous souhaitez commenter , puis cliquer sur ce bouton en haut faire ressortir toutes les lignes qui permettent de le sélectionner. Et si jamais vous souhaitez les décommenter, vous pouvez simplement cliquer sur celui qui se trouve juste à côté , comme ça. Nous allons donc les commenter. Donc, pour l'instant, nous avons créé deux variables et nous avons imprimé le numéro. Ensuite, nous avons suivi une ligne. Donc, ici, nous allons en fait faire le contraire. Nous allons convertir notre nombre de 5 ans en chaîne. Donc, pour ce faire, nous allons commencer et dire que numéro britannique est notre nom de chaîne ici. Est égal à, puis à toutes les minuscules, chaîne de soulignement, et à nouveau à toutes les minuscules. Ensuite, entre parenthèses, nous allons mettre notre entier. Nous allons donc simplement dire un nombre, suivi de parenthèses et d'un point-virgule à la fin. Alors, qu'est-ce que ça va faire ? Il va commencer à lire le nombre étant notre chaîne égale à la valeur de chaîne de notre numéro. Donc, en gros, c'est le contraire de ce que nous avons fait ici, mais à la place, nous utilisons ces deux méthodes de chaîne qui convertissent cette année en chaîne. Il ne nous reste plus qu'à l'imprimer pour que nous puissions réellement en voir le résultat. Donc, on va dire « C ». Et puis un numéro écrit. Lorsque notre programme réimprime maintenant cinq fois, une fois à partir de notre variable entière réelle étant le nombre, et une fois à partir de notre chaîne, qui est maintenant égale à cinq, puisque c'est à cela que le nombre était égal. Eh bien, vous savez maintenant comment convertir une chaîne entier et comment convertir un entier en chaîne. Et les cas d'utilisation de ce logiciel deviendront plus évidents au fur et à mesure que nous poursuivrons le cours et que nous commencerons à entrer dans du code plus complexe. Quoi qu'il en soit, c'est tout pour cette vidéo et la suivante, nous allons commencer à travailler avec quelques notions d'arithmétique de base. Alors merci de m'avoir écouté, et à bientôt. 18. Chapitre 5 (Opérateurs) : l'arithmétique de base: Dans cette vidéo, nous allons passer en revue quelques notions d'arithmétique de base en programmation. Donc, la première chose que nous allons faire est de créer quelques variables entières. Alors allons-y et disons que int num un est égal à cinq. Ensuite, nous dirons que int num deux est égal à dix. Alors, eh bien, nous allons créer une autre variable entière, qui contiendra le résultat de toutes les mathématiques que nous ferons à l'avenir ici. Donc je vais dire que le résultat est égal, et mettons-le à 0 pour l'instant. N'oubliez pas que nous pourrions simplement le déclarer si nous le voulions, mais allons-y et initialisons-le. Ensuite, ici, on va faire quelques calculs. Maintenant, les mathématiques en C plus plus fonctionnent de la même manière. Ça n'a rien à voir. Pour la multiplication. Vous allez en fait utiliser la division des symboles astérisques. Vous allez utiliser une barre oblique, addition, un signe plus et une soustraction. Le symbole de soustraction, également C plus plus, suit le même ordre d'opérations que celui auquel vous êtes habitué lorsqu'il s'agit de ces quatre éléments ici. Et il existe également d' autres symboles et différentes choses que vous pouvez faire qui entrent également dans le tableau de l' ordre des opérations. Donc, si vous prévoyez de faire quelque chose sérieux avec les mathématiques en programmation, je vous recommande vivement de jeter un œil au C plus, ainsi que le tableau mathématique des opérations , et de voir comment tout cela fonctionne. Quoi qu'il en soit, allons-y et faisons juste quelques ajouts de base ici. Nous allons donc dire que le résultat est égal à num un plus num deux. D'ailleurs, vous pouvez même définir une variable égale à une autre variable. Donc, si je dis que le résultat est égal à num, un, le résultat serait égal à cinq. Mais nous sommes là, nous allons dire num un plus num deux, ce qui devrait être 15. Nous pouvons tester cela en disant « c out ». Exécutez notre code. Et voilà. Et juste pour vous montrer que cela suit le bon ordre des opérations au-dessus de la tête, et dites multiplier ici après un M deux par deux à nouveau. Donc, si cela était lu de gauche à droite, serait cinq plus dix , soit 15 fois dix si vous voulez 50. Mais comme cela suit le même ordre d'opérations, donc nous y sommes habitués, il va d' abord effectuer la multiplication. Ce sera donc dix fois dix, soit 100, plus cinq, soit 105. Et si nous exécutons notre programme ici, vous pouvez voir que c'est le cas. Et au cas où vous seriez curieux de connaître les mathématiques ici, vous pouvez dire que le résultat est égal au temps de résultat. Jusqu'à présent, cela indiquera que le résultat est 0. Nous voulons définir comme égal à num un, num deux, ce qui, nous le savons , sera égal à 15. Ensuite, ici, nous allons dire résultat, qui est 15 égal au résultat étant 15 fois plus nul à dix, il devrait finir par 1 cinquième. Ensuite, nous allons l'imprimer. Et voilà. Alors, tu y vas. Vous savez maintenant comment faire quelques calculs de base en C plus. Et si nous le voulions, nous pourrions même demander ces numéros à l'utilisateur. Par exemple, au lieu de les installer ici, je peux les supprimer. Et nous allons simplement laisser notre résultat égal à 0 pour commencer. Et puis ici, nous dirons que résultat est égal à num1 plus num2. Mais juste avant cela, nous allons voir. Ensuite, entre guillemets, on dira type. Personne numéro deux. leur a ajouté un flux qui indiquera à nouveau C. Deuxième commande ajoutée. Et puis, entre les deux, nous allons devoir dire « CAN one » pour le premier. Et puis en dessous, nous avons déclaré deux variables entières. Nous avons déclaré et initialisé une variable de résultat. Ensuite, nous l'imprimons et nous voulons que l'utilisateur saisisse le premier numéro à ajouter. Et en fait, je vais commencer et mettre un espace deux-points ici juste pour le rendre un peu plus beau qu'une fois qu' ils ont pris leur premier numéro et appuyé sur Entrée. Il va leur demander un deuxième numéro. Et si nous le voulons, nous pouvons aller de l' avant et créer une nouvelle ligne comme ça. Ensuite, ils peuvent saisir leur deuxième numéro et appuyer sur Entrée. Et puis, ici, il va automatiquement procéder et additionner ces deux chiffres ensemble. Et en bas, on peut dire quelque chose comme ça. C sort, puis cite et met sur une nouvelle ligne. Nous dirons que le résultat est un espace deux-points comme ça. Assurez-vous qu'il s'agit d'un point-virgule à la fin. Et avant d'oublier, je vais mettre ces deux-points et cet espace ici. Après avoir également demandé le deuxième numéro, nous allons exécuter notre code. N'oubliez pas de le faire sans déboguer. Je ne veux pas simplement dire 105 ou vous pouvez taper les chiffres que vous voulez pour vous donner votre résultat ici. Donc, pour moi, cela indique que mon résultat était 15. Et nous y voilà. Et ensuite, si je voulais nettoyer cela encore plus parce que mon avocat m'a demandé d' appuyer sur un bouton avant de continuer. Je pourrais juste montrer sur une nouvelle ligne à la fin, comme ça. Et ça va très bien fonctionner. Et voilà. Ça a l'air très joli. Quoi qu'il en soit, c'est tout pour cette vidéo. Dans la vidéo suivante, je vais vous montrer quelques opérateurs supplémentaires. Alors merci de m'avoir écouté, et à bientôt. 19. Chapitre 5 (Opérateurs) : augmentation et Decrement: Dans cette vidéo, je vais vous montrer quelques nouveaux opérateurs que vous n'avez peut-être jamais vus auparavant. Mais ceux-ci sont assez courants dans les langages de programmation. Donc, le premier est l'opérateur d'incrémentation étant composé de deux symboles plus, il suffit d'en ajouter un à tout ce sur quoi vous l'utilisez. Dans l'opérateur de décrémentation, qui consiste simplement à en soustraire un de ce sur quoi vous l'utilisez. Permettez-moi donc de vous montrer comment ils fonctionnent. abord, nous allons créer une variable entière. Donc, nous allons simplement dire que int num un est égal à cinq. Ensuite, nous allons continuer et utiliser réellement ces opérateurs. Donc, par exemple, allons-y et utilisons l'opérateur d'incrémentation. Pour ce faire. Nous allons dire un plus, un plus, puis un point-virgule à la fin. Et voilà, vous l'avez. Il va maintenant en ajouter un à num un et les épaules à vous. Nous allons procéder à l' impression du numéro un. Non, juste comme ça et lance notre programme. Comme tu peux le voir, ça dit sexe. Et si nous faisions le contraire ici et que nous disions moins, moins et que nous exécutions à nouveau notre programme. Il dira pour l'instant c'est exactement la même chose que si nous faisions ce qui suit. Je vais donc le commenter rapidement et dire « numéro un ». Pas un moins un. Juste comme ça. Et quand j'y vais, comme vous pouvez le voir, encore une fois, si j' avais mis un plus, j'en aurais envoyé six. Comme vous pouvez le voir, c'est exactement la même chose. C'est juste beaucoup plus rapide et beaucoup propre de dire num un moins, moins ou plus, plus. Ensuite, faire num un équivaut à 91, puis plus ou moins, puis un. Et vous aurez souvent besoin de simplement en soustraire ou ajouter un à quelque chose, en particulier en programmation. C'est donc une autre raison pour laquelle il est disponible pour vous et pourquoi c'est un bon outil à avoir. Maintenant, une autre chose que je veux vous montrer , c'est que vous pouvez placer ces opérateurs de l'autre côté de la variable et cela fait quelque chose de différent. Donc, si nous effaçons la ligne que nous venons de créer, puis annulons les commentaires ou que nous numérotons un avec l' opérateur de décrémentation. Si je place le moins, le moins de l'autre côté ou l'opérateur de décrémentation et que je lance notre code, il affichera la même chose. Vous pourriez penser, oh, eh bien, cela fonctionne de la même manière alors, mais en fait, il se passe quelque chose de différent ici. Et je peux te montrer ce que c'est. Alors allons-y et créons une autre variable. Nous l'appellerons numéro deux et lui donnerons la valeur. Également. Juste pour vous montrer quelque chose rapidement pendant que nous sommes ici, juste au cas où vous le verriez ailleurs, vous pouvez procéder comme suit. Au lieu de dire int num deux est égal à cinq, vous pourriez simplement dire int num deux, puis entre parenthèses, vous pourriez avoir cinq. Et c'est exactement pareil. Vous pouvez également le voir entre crochets, comme ceci. C'est exactement la même chose que si je disais juste que num deux est égal à cinq. Je veux juste te montrer ça au cas où tu le verrais. Mais personnellement, je le trouve moins éligible et je ne le vois pas souvent. Donc j'aime juste dire que ma variable est égale à n'importe quoi. OK ? Donc je vais juste y aller et dire que num deux est égal à 0 pour l'instant. En bas, si vous vous souvenez bien, nous avions r moins moins, puis zéro un, au lieu de mettre notre opérateur de l'autre côté. Et lorsque nous avons exécuté notre code, il a fait exactement la même chose qu'avant. soustrait un de notre variable num un, puis nous l'avons imprimé. Mais c'est en fait différent. Et vous vous demandez peut-être en quoi est-ce différent ? Eh bien, en bas, si je dis que num deux est égal à moins, moins num un, puis que j' imprime num deux et que nous exécutons notre code. On dirait que tu l'as vu juste avant parce que j'avais quatre ans. Mais si nous allons vraiment de l'avant et que nous remettons cela de l'autre côté, vous verrez quelle est la différence. Donc, si nous le supprimons à nouveau et que nous le déplaçons l'autre côté où nous l'avions à l'origine et exécutons notre code. En fait, ça va dire cinq. Et si on imprime le numéro un ici, je vais le mettre sur une nouvelle ligne, juste pour qu'il soit un peu plus lisible. Ensuite, si je lance un code, vous pouvez voir qu'il va s' imprimer pour être nul. Et puis il va imprimer cinq étant zéro deux. Pourquoi ça ? Eh bien, laisse-moi te dire. Donc, num un moins moins moins soustraira un de num un. Aucun ne sera égal au résultat de cela. Donc, num un est égal à quatre, mais il renvoie en fait la valeur avant que cette opération ne se produise. Donc c'est fondamentalement la même chose que si nous disions que num deux est égal à num un. Et vous pouvez le voir comme ceci si nous le surlignons jusqu'à la fin de notre nom de variable num one ici, il dit simplement que num deux est égal à num un. Ensuite, cette opération lieu et nous avons imprimé le résultat. Mais si nous déplaçons cela de l'autre côté et que nous soulignons que la même plage est engourdie jusqu'à zéro. Vous pouvez voir que l'opération se déroule à l'intérieur de celui-ci. Et l'opération se déroule en fait d'abord ici. Donc maintenant, il va dire que num deux est égal quel que soit le résultat de cette opération, num un sera toujours soustrait. Alors allons-y et voyons à quoi cela ressemble. Donc, si nous exécutons à nouveau notre code, vous pouvez voir qu'ici nous avons dit num un égal à cinq, m2 est égal à 0. Et puis num deux était égal au résultat de cette opération, qui était pour num un moins un fait quatre. Ensuite, lorsque nous imprimons num un, il en contient également quatre parce que nous en avons quand même soustrait un de num un. Donc, numéro un est maintenant quatre et M2 est égal à cela pour ceux de l'autre côté. Encore une fois, souvenez-vous simplement que nous leur demandons de le faire, d'être égaux à zéro et que l'opération ait lieu ensuite , accord ? Alors voilà. J'espère que vous savez maintenant comment utiliser les opérateurs d'incrémentation et de décrémentation. Et si vous ne le comprenez pas complètement, ce n'est pas grave. Nous l'utiliserons à nouveau plus tard tout au long du cours. Mais en réalité, la seule chose que vous devez retenir, c'est que l'opérateur plus ou l'opérateur d'incrémentation revient dire que num1 est égal à num un plus un. Donc ça, ici, c'est exactement pareil. Ce serait pareil si je disais moins n, moins un. Cependant, si vous l'utilisez dans une opération, donc si je voulais dire que num est égal à num un plus, plus, par exemple, alors num deux sera égal à num un. Et puis cette opération se déroulera normalement. Ou si je mets le plus plus de l'autre côté, alors num deux sera égal au résultat de cette opération. Quoi qu'il en soit, c'est tout pour cette vidéo, la vidéo suivante, nous allons passer en revue un nouvel opérateur mathématique appelé le modulus. Alors merci de m'avoir écouté, et à bientôt. 20. Chapitre 5 (Opérateurs) : Modulus: Dans cette vidéo, nous allons passer en revue l'opérateur du module, qui est le signe du pourcentage ici. Et cet opérateur vous donne le reste de la division. Donc ce que je veux dire par là, eh bien, allons-y et essayons-le. Nous allons donc d'abord créer quelques chiffres. Donc disons que je suis un égal dix. Et puis int num deux est égal à trois. Ensuite, nous allons utiliser cet opérateur. Dites donc num un module numéro deux. Juste comme ça. Ensuite, il va falloir attribuer le résultat à quelque chose. Nous allons donc créer un autre entier appelé zone. Donc disons que le résultat est égal à 0 pour le moment. Ensuite, ici, nous allons définir le résultat égal à num un module num deux. Alors, qu'est-ce que cela va faire ? Eh bien, il va falloir un bronzage rose et le diviser par 33, en 103 fois, et puis il y a le reste d'un. Donc, si nous allons de l'avant et exécutons notre programme, résultats devraient être égaux à un, mais nous devons quand même l'imprimer. Alors allez-y et dites CL, résultat. J'ai exécuté votre code. Et voilà. C'est le reste de notre division. Et si nous divisions cela et exécutions notre programme, vous pouvez voir que nous obtenons un résultat de trois. Et c'est parce que le résultat est une valeur entière, ce qui signifie qu'elle ne contient que des nombres entiers sur trois, qu'elle n'entre complètement que 103 fois. C'est pourquoi le résultat est trois. Et nous en parlerons un peu plus en détail dans une prochaine vidéo ici. Quoi qu'il en soit, c'est tout pour cette vidéo. la vidéo suivante, nous allons passer en revue Dans la vidéo suivante, nous allons passer en revue différents opérateurs d'assignation. Alors merci de m'avoir écouté, et à bientôt. 21. Chapitre 5 (Opérateurs) : l'attribution: Dans cette vidéo, nous allons passer en revue certains opérateurs d'assignation. Dans le passé, si nous voulions ajouter un nombre à une variable actuelle, nous devions dire quelque chose comme ceci. Un, par exemple, est égal à dix. Ensuite, pour faire notre calcul, nous devrions dire que num est égal à num un plus cinq, par exemple. Et cela nous donnera le résultat 15. Donc, nul, nous sommes maintenant égaux 15 parce que notre opérateur d'affectation prend tout ce qui se trouve sur le côté droit et l'assigne à ce qui se trouve sur la gauche. C'est pourquoi on l'appelle l'opérateur d'assignation. Maintenant, une autre chose que nous pouvons faire, et qui est plus rapide, est la suivante. On peut dire que num un plus est égal. Bonjour. Cela va faire exactement la même chose que ce que nous avons ici ci-dessus, c'est-à-dire plus rapidement. Alors laisse-moi te le prouver. Nous avons donc dit int num un est égal à dix, puis num un est égal à num un plus cinq, ce qui devrait être 15. Donc, pour voir cela, nous allons commencer et dire « C ». Ensuite, allons-y et créons également une nouvelle ligne. Ensuite, en dessous, on dira que num un est égal à dix, juste pour le remettre à ce qu'il était à l'origine. Et ensuite, ici, nous l'imprimerons à nouveau. Donc je vais dire CL one. Encore une fois. Allez-y, lancez un programme. Alors on y va. Nous en avons imprimé 15 deux fois. Comme je l'ai dit, ceux d'ici. Et voici exactement la même chose. C'est juste de la sténographie. Et vous pouvez en fait remplacer ce symbole plus ici par n'importe lequel de nos autres opérateurs. Je pourrais donc dire que moins est égal à cinq, par exemple, je sais qu'il a été imprimé, imprimé 15 à partir de ce premier, puis cinq d'ici. C'est juste un moyen beaucoup plus rapide de le faire. Et juste pour vous montrer qu'il fonctionne même avec l'opérateur modulus. Et quand un programme dans le reste des dix divisé par cinq 0. Bref, c'est tout pour cette vidéo. Dans la vidéo suivante, nous allons parler de ce qu' on appelle la concaténation. J'espère donc vous y voir. Merci de m'avoir regardé et je te verrai la prochaine fois. 22. Chapitre 5 (Opérateurs) : la concaténation: Dans cette vidéo, nous allons parler de la concaténation de chaînes. Cela indique essentiellement la possibilité de prendre deux chaînes différentes et les combiner en une seule nouvelle chaîne. Alors allons-y et voyons comment procéder. d'abord, créons deux chaînes différentes à combiner. Nous allons donc dire que la chaîne FirstName est égale, puis nous allons ajouter le nom que vous voulez. Ensuite, nous ferons la même chose pour LastName. Ensuite, nous allons faire une chaîne de plus pour obtenir un nom complet. Nous allons donc dire chaîne pour moi. Et nous allons simplement déclarer celui-ci au lieu de l' initialiser. Juste comme ça. Ensuite, allons-y et concaténons et/ou combinons ces chaînes ensemble. Donc, nous allons simplement dire que le nom complet est égal au prénom, au nom de famille. Bien, maintenant, si nous allons de l'avant et que nous l'imprimons, nous pourrions simplement dire CL, nom complet. D'ailleurs, si vous utilisez Visual Studio et que vous avez une faute d'orthographe, ou si vous souhaitez simplement renommer une variable, vous pouvez simplement cliquer dessus avec le bouton droit de la souris. Puis cliquez sur Renommer. Ensuite, allez-y et mettez le nouveau nom ici. Ensuite, vous pouvez continuer , cliquez sur Aperçu. Et cela vous montrera en fait tous les endroits où il va remplacer le nom de cette variable. Et vous pouvez continuer et parcourir votre code ici pour voir à quoi il ressemblera, puis appuyer sur Appliquer. Et vous y voilà. Très bien, donc maintenant, si nous lançons notre programme, vous pouvez voir qu'il réunit les deux noms. Et supposons que nous voulions les séparer par un espace. Eh bien, nous pouvons simplement mettre un espace ici et notre prénom ou notre nom de famille, ou nous pouvons simplement le mettre ici. Nous pouvons donc y mettre un espace vide comme ça, ajouter un autre signe positif comme ça, et c'est parti. Donc, comme vous pouvez le voir, il est imprimé ou nom complet et même à travers notre chaîne littérale juste là. Et vous y voilà. C'est probablement le moyen le plus simple de combiner deux chaînes ou plus. Et n'oubliez pas que cela s'appelle en fait la concaténation de chaînes. Et il y a un autre moyen. Je vais y aller et te montrer. Cette méthode est techniquement plus rapide que la première. Mais je ne l'utilise pas aussi souvent simplement parce que je trouve cela beaucoup plus facile à lire et parce qu'il est plus facile de combiner plus que deux choses. Mais je vais quand même te montrer ça. Aussi, juste un avertissement. Nous aurions pu faire la même chose ici quand nous avons déclaré notre nom complet. Donc, si nous le voulions, nous pourrions simplement copier tout cela ici. Et puis, là-haut, nous aurions pu dire « égaux », le coller au travail comme à la maison. Je vais donc lancer mon code ici juste pour que vous puissiez voir que vous y êtes. Aucune différence. Alors, à quoi correspond cette autre voie à laquelle je faisais référence ? Donc, au lieu d'utiliser le signe plus pour combiner deux ou plusieurs rétractions ensemble, eh bien, nous pouvons simplement supprimer cela en dehors de notre prénom ici, juste comme ça. Ensuite, nous allons simplement dire « point append » en minuscules. Et puis, entre parenthèses, nous pouvons simplement ajouter la variable ou la chaîne que nous voulons combiner à cela. Et encore une petite note pour ceux d'entre vous qui utilisent Visual Studio, cette petite boîte qui apparaît et vous montre ce que cette méthode recherche. Vous pouvez en fait cliquer sur les flèches qui s'y trouvent et cela vous montrera les différentes options dont vous disposez. Donc, juste un avertissement à ce sujet. Quoi qu'il en soit, nous allons commencer et taper le nom de famille ici. Comme ça. Et ce qu'ils vont faire, c'est qu'ils vont prendre notre prénom et y ajouter le nom de famille. Maintenant, si nous exécutons notre code, vous pouvez voir qu'il fait exactement la même chose. Cependant, comme je l'ai dit, je trouve personnellement cela un peu moins lisible et plus ennuyeux si je voulais ajouter plus d' une chose ensemble, d'accord, nous pourrions simplement mettre un espace ici et notre nom de famille, et ça marchera. Mais que se passerait-il si nous obtenions ces informations de l'utilisateur et que nous ne les saisissions pas directement, ce serait un peu gênant de l' utiliser de cette façon. Nous allons donc simplement continuer et laisser les choses comme ça. Et vous y voilà. Il y a deux manières principales de concaténer ou combiner des chaînes en C plus plus. Alors merci de m'avoir écouté, et à bientôt. 23. Chapitre 5 (Opérateurs) : coulée et tronçonnage: Dans cette vidéo, nous allons parler casting et de troncature. Maintenant, le casting consiste essentiellement prendre un type de données et à le convertir en un autre. Et tronquer, c'est essentiellement couper la fin de quelque chose. Et je vais vous montrer ce que je veux dire par là dans une seconde. OK, donc d'abord, allons-y et examinons la troncature. Nous allons donc simplement créer un flux de base, disons que float num1 est égal à 5, puis entrer le nombre décimal de votre choix. Et puis Dumbo ça. Nous allons commencer et dire int num two et le mettre égal à num un. N'oubliez pas non plus de mettre un F à la fin d' ici, une valeur flottante ici, afin de dire à notre programme qu'il s' agit en fait d'un flottant et non d'un double. Très bien, donc maintenant, si nous allons de l' avant et que nous imprimons numéro deux, il n' en imprimera que cinq. Et je vais aller te le montrer maintenant. Comme vous pouvez le voir, il vient d'en imprimer cinq. Vous pensez peut-être que ce chiffre est simplement arrondi à la valeur inférieure, mais je vais vous montrer maintenant que ce n'est pas le cas. Donc, même si je devais mettre quelque chose comme 5.99999 et réexécuter notre code. Ça ne va quand même que dire cinq. Et c'est parce qu'une valeur entière ne peut pas contenir de précision après un point décimal, n'est-ce pas ? Il ne contient que des nombres entiers. Et ce qui se passe réellement en C plus, c'est que tout sera tronqué après la virgule décimale. Comme je l'ai dit au début de la vidéo, tronquer signifie simplement couper quelque chose. Donc, en gros, n'importe quel nombre que vous avez que vous convertissez en entier, et il gardera simplement le nombre entier et ignorera le point décimal et tout le passera complètement. Donc, quel que soit ce nombre, peu importe ce qui se trouve au-delà de la virgule décimale, il enregistrera simplement le nombre entier. Et ce type de casting où nous convertissons un type de données constituant notre flux ici vers une autre main. Nous n'avons rien eu à faire de plus. Vous venez de l'écrire car nous définirions une variable égale à une autre, c'est ce que l' on appelle le casting implicite. Il est modifié automatiquement sans aucun travail supplémentaire de notre part. Maintenant, je vais vous montrer un exemple de x plus un casting où nous indiquons à notre programme que nous voulons passer d'un type de données à un autre. Plus précisément, je vais vous montrer comment cela vous sera utile. plupart du temps, votre programme va aller de l'avant et simplement implicitement quelque chose ou le convertir d'un type de données à un autre. Et allez-y et courez normalement. Et il n'y aura aucun problème à le faire. Comme je l'ai dit, si nous devions gérer cela, tout se passerait très bien. Aucun problème. Cela va simplement tout couper au-delà de la virgule décimale, car un entier ne peut pas contenir un nombre entier. Et même si nous faisions un double ici au lieu d'un flux et mettions un nombre incroyablement long après la virgule décimale comme celui-ci, puis que nous le remplacions par un flux. Donc, notre numéro deux est maintenant un flux et il va transformer ce double ici en une valeur flottante. Et si nous exécutons notre programme, vous pouvez voir qu'il a juste tenu ce qu'il pouvait. Et la façon dont elle effectue cette conversion est un peu confuse et elle ne fonctionnera pas toujours comme elle l'a fait ici, où l'on dirait qu'elle vient d'être arrondie au-delà d'un certain point. Je ne recommanderais pas vraiment de le faire , sauf si vous ne vous souciez pas vraiment de la précision supplémentaire car la façon dont elle est traitée, comme je l'ai dit, peut être assez confuse et parfois vous pourriez obtenez un numéro complètement différent de ce à quoi vous vous attendiez. Donc, juste pour l'instant, laissez-moi vous montrer un exemple de cas où vous voudriez convertir explicitement quelque chose en un autre type de données. Alors allons-y et effaçons tout cela. On va y aller et dire que int num un est égal à dix. Et puis int num deux est égal à trois. Juste comme ça. Ensuite, allons-y et créons un float appelé résultat. Mettez-le égal à num un divisé par num, commençant par dix, en le divisant par trois. Et puis en bas, allons-y, imprimons ou volons. Disons que C sort et lançons un programme. Comme vous pouvez le constater, il vient d'en imprimer trois, même si dix divisé par trois ne sont pas exactement trois. Et la raison en est que ces deux valeurs sont ici des valeurs entières. L'équation est faite avec des entiers, et les entiers ne peuvent pas contenir un nombre entier. Donc, il nous en a juste donné trois , puis nous avons défini le résultat ici égal à cela. Mais si nous voulons obtenir la valeur flottante appropriée de cette division, nous pouvons en fait convertir explicitement ces deux nombres en virgule flottante. Et la façon la plus simple de le faire, que vous verrez dans de nombreux langages de programmation basés sur le langage C, est la suivante. Nous allons donc commencer et mettre des parenthèses avant notre variable ici. Ensuite, à l'intérieur de ces parenthèses, nous allons simplement mettre le type de données que nous voulons, cette variable ici, ou le type standard ici, en lequel NOUS la convertissons. Nous allons donc continuer et dire «  flottez » comme ça. Et puis, ici, nous ferons de même. Maintenant, nous devons faire flotter des variables, une étant dix et l' autre trois, et elles vont être divisées. Ensuite, le résultat de cette équation sera placé dans notre variable de résultat ici, qui sera ensuite imprimée sur la console. Nous allons donc lancer un programme. Et comme vous pouvez le constater maintenant, nous avons la bonne valeur. Et c'est parce que l' équation a été faite avec des flotteurs. Il a été stocké dans une valeur flottante. Et notre résultat ici a été égal à cela. Et si nous supprimions l'une de ces conversions d'un type de données à l'autre de notre équation ici, puis que nous exécutions à nouveau notre programme. Comme vous pouvez le constater, cela a toujours fonctionné. Et même si nous le faisions simplement avec l'autre, comme ça et lançons notre programme. Je travaillerais aussi. Cependant, je ne le ferais pas juste pour être prudent, même s'il s'agissait d'une équation assez basique et qu'elle a fonctionné, je recommande de le faire avec les deux chiffres. Un autre exemple de cette fonctionnalité serait comme si nous travaillions avec un type de données char. Ainsi, par exemple, si nous changeons notre premier entier ici en char num1 et définissons comme égal à dix à cause du graphique tabulaire A-S-C-I-I, ce n'est pas vraiment dix. Et je peux vous montrer que si nous devions l'imprimer, si je sous-c sur num one, juste comme ça et que je lançais notre programme, imprimais en fait un onglet radical, je crois. Permettez-moi de le remplacer par un autre numéro. Voici un meilleur exemple. Comme vous pouvez le voir, il a imprimé z et c'est à cause du graphique tabulaire dont nous avons parlé lorsque nous avons parlé de caractères, que 122 n'est pas vraiment la valeur 122. Mais si nous voulions imprimer 122 à partir de notre variable char ici, nous aurions pu simplement le convertir ici. Supposons que nous voulions transformer cela en un int qui, une fois de plus, en mettant simplement entre parenthèses le type de données que nous voulons et en exécutant notre programme. Et vous y voilà. Et maintenant, j'ai imprimé la valeur entière de notre caractère étant 122. Maintenant, C plus plus offre une manière différente de convertir explicitement un type de données à un autre. C'est différent de nombreux langages de programmation basés sur le langage C. Donc, la façon dont cela a été fait, comme si nous allions de l'avant et que notre coût précédent ici et que statique tout au cas, soulignement, casting. Ensuite, à l'intérieur d'un symbole inférieur à et supérieur à, placez le type de données vers lequel vous souhaitez le convertir. Donc, par exemple, puis la variable que nous voulons convertir entre parenthèses. Ainsi, si nous exécutons notre programme, vous pouvez voir que cela fonctionne très bien. Maintenant, si tu veux le faire de cette façon, tu peux. Techniquement, il est beaucoup plus sûr de le faire de cette façon. Et il est également plus visible que nous changeons cela pour un type de données différent en utilisant Casting Ever. Comme je travaille également avec d'autres langages de programmation C, je préfère le faire dans l'autre sens. Et je ne trouve pas non plus que les risques cela comporte soient si dramatiques que je n' aurais pas envie de taper tout cela à chaque fois que je veux simplement passer d'un type de données à un autre. Personnellement, je trouve cela beaucoup plus facile. Je pense que c'est beaucoup plus propre et beaucoup plus rapide à taper. Et à moins que vous ne fassiez beaucoup de conversions ou que vous ne fassiez quelque chose de très spécifique. Comme je l'ai dit, si vous êtes plus curieux à ce sujet, n'hésitez pas à rechercher les différences et à savoir pourquoi l'autre type est disponible sur C plus plus en premier lieu. Mais pour moi personnellement et tout au long du cours, chaque fois que nous faisons un casting, je vais le faire de cette façon parce que je trouve que c'est beaucoup plus facile et c' est fait de la même manière et les autres langages de programmation C. J'aime donc travailler d'une seule façon, quelle que soit la langue que j'utilise. Alors, tu y vas. Vous savez maintenant comment convertir d' un type de données à un autre de manière explicite, comme ceci. Et implicitement, comme lorsque nous l'avons fait passer d'un nombre flottant à un entier, et cela s'est fait automatiquement. Nous n'avons pas eu à mettre de choses supplémentaires. De toute façon. C'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 24. Chapitre 6 (conditionnels) : portée: Dans cette vidéo, nous allons parler des variables, de l'étendue des variables. Scope est essentiellement une section de votre code où vous pouvez accéder à une variable. Et d'une manière générale, il existe trois endroits principaux où une variable peut être déclarée. Le premier se trouve à l'intérieur d'une fonction comme nous l'avons fait, ou à l'intérieur d'un bloc de code, qui est indiqué par un crochet bouclé ouvert et fermé comme celui-ci. Le second serait à l'intérieur de la définition d' un paramètre de fonction et de l' endroit où il se trouverait. Par exemple, dans notre fonction principale il y a entre ces parenthèses. Nous allons maintenant aborder les paramètres des fonctions lorsque nous parlerons des fonctions et/ou des méthodes plus tard dans le cours. Et le troisième endroit principal où vous verrez une variable déclarée est complètement en dehors de votre fonction. C'est ce que l'on appelle une variable globale. Je vais donc vous le montrer maintenant et vous montrer les différences entre une variable déclarée à l'intérieur d'un bloc de code ou d' une fonction ici et une variable déclarée en dehors de celui-ci. Maintenant, les vraies variables rapides déclarées incitatives, un bloc de code ou une fonction seront généralement appelées variables locales, veulent, déclarons-la en dehors de cela, seront appelées globales variable. Alors laissez-moi vous le montrer maintenant. Donc, un exemple de variable globale serait si nous disions à Louisville, simple » et que nous la mettions à cinq. Maintenant, nous allons vous montrer un exemple de variable locale, avec laquelle nous avons travaillé tout au long de ce cours. Nous allons simplement dire int numéro local. Celui-ci est égal à cinq également. Très bien, alors vous y voilà. Il s'agit ici d'une variable globale. Celle-ci, en bas, est une variable locale. Quelles sont donc les principales différences entre les deux ? Eh bien, comme cette variable se trouve en dehors de tout bloc de code, encore une fois représentée par des crochets ouverts et fermés, elle est accessible n'importe où dans notre programme. D'accord, n'oubliez pas que le code est lu de haut en bas. Donc, n'importe où en dessous, nous pouvons utiliser et accéder à cette variable normalement. Ainsi, par exemple, ils peuvent l' imprimer ici. Et si nous exécutons notre code, vous verrez qu' il fonctionne parfaitement. Cependant, notre variable locale n'est pas accessible en dehors du bloc de code dans lequel elle a été créée ou au-dessus, car le code est lu de haut en bas. heure actuelle, nous ne travaillons qu'avec une seule fonction qui est notre fonction principale. Mais au fur et à mesure que nous travaillerons avec des programmes de plus en plus importants, nous aurons de multiples fonctions. Ainsi, en dehors de notre fonction principale, il y aura également fonctions que nous avons créées nous-mêmes, par exemple. Et cette variable locale ne serait pas accessible en dehors de notre fonction principale ici. C'est parce que, d'une part, il n'a pas été déclaré ou créé nulle part au-delà de cela. Et comme il est local et uniquement disponible dans ce bloc de code, dès que nous avons du code en dehors de ce bloc ici, il n'est plus accessible. manière générale, il se peut qu'il n' existe tout simplement pas en dehors du bloc dans lequel j'ai été créé. Et maintenant, pour récapituler, une variable locale telle qu'elle a été créée, essentiellement dans une fonction ou dans un bloc de code. Et une variable globale créée en dehors de cela. Et d'une manière générale, une variable gobo sera disponible partout dans votre code. Et une variable locale ne sera disponible que dans le bloc dans lequel elle a été créée et c'est la façon la plus simple d'y penser. L'un est local au bloc qui a été créé et quand il est crédule et disponible partout. Quoi qu'il en soit, si vous ne comprenez pas parfaitement ce concept, ne vous inquiétez pas. Nous allons beaucoup travailler avec cela, donc vous aurez une tonne de choses sur la pratique et d'exemples. Mais je veux juste vous faire prendre conscience de ce concept. Quoi qu'il en soit, c'est tout pour cette vidéo. Dans la vidéo suivante, nous allons enfin parler des déclarations conditionnelles, nous ne pourrons pas vérifier les différentes conditions, ce qui élargira à l' infini les possibilités que vous avez avec votre code. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 25. Chapitre 6 (conditionnels) : Intro aux conditionnements: Dans cette vidéo, je vais juste vous donner une brève introduction aux déclarations conditionnelles. Donc, en gros, une déclaration conditionnelle qui vérifie si la condition est vraie ou fausse. Et seulement si cette condition est vraie, eh bien, il exécute le bloc de code qui lui est associé. N'oubliez pas qu'un bloc de code est généralement représenté par un crochet bouclé ouvert et fermé. Donc, par exemple, si nous disons que cinq est supérieur à un ? Eh bien, oui, parce que cinq est supérieur à un, cette condition serait vraie et cela imprimerait Hello. Cependant, si nous demandions si cinq est inférieur à un, cette condition serait fausse car ce code serait complètement ignoré. C'est donc essentiellement ce qu' est une déclaration conditionnelle et comment elle fonctionne. En gros, il suffit de vérifier si une condition est vraie. Et si c'est le cas, il exécutera le bloc de code qui lui est associé. Dans le cas contraire, ce bloc de code est ignoré. Nous allons maintenant travailler sur ce sujet dans les prochaines vidéos et créer nos propres déclarations conditionnelles. Vous allez donc avoir une tonne de pratique. Comment peuvent-ils être utilisés pour une tonne de choses différentes ? Imaginons, par exemple, que vous créiez un jeu. Vous voudrez peut-être voir si quelqu'un est le premier joueur ou s'il appuie sur le bouton ou s' a terminé un certain niveau ou quelque chose comme ça. J'espère donc que c'était assez facile à comprendre. Si ce n'est pas le cas, comme je l'ai dit, ne t'inquiète pas. Vous allez avoir beaucoup d'entraînement et plus d' informations, ainsi que les vidéos à venir. Je voulais juste vous donner une brève introduction au concept des déclarations conditionnelles avant de passer à l'étape suivante. Alors merci de m'avoir écouté, et à bientôt. 26. Chapitre 6 (conditionnels) : opérateurs relationnels et égaux: Dans cette vidéo, nous allons passer en revue les opérateurs conditionnels. Désormais, les opérateurs conditionnels sont là pour vous aider à vérifier les différentes conditions. Alors allons-y et examinons les six types différents. Donc, le premier que nous avons ici, qui est créé en utilisant deux signes égaux, vérifie si quelque chose est égal à autre chose. Donc, par exemple, cinq égale cinq. Et il est important de se rappeler que cela nécessite deux signes égaux, car il s'agit de l' opérateur d' affectation avec lequel nous avons travaillé dans les vidéos précédentes. Donc, si vous voulez vérifier si quelque chose est égal à un autre, nous utiliserons un double signe égal comme celui-ci. Maintenant, celui en dessous, qui utilise un point d'exclamation puis un signe égal vérifie si quelque chose n'est pas égal à autre chose. Et puis, en passant à cela, je vais vous donner un exemple de la façon dont cet opérateur créerait une véritable condition. On peut donc dire que cinq est égal à cinq. Et puis ici, pour ce qui n'est pas égal à un, on obtient, disons, trois pas égal à cinq. Et ce sera vrai car trois n'est pas égal à cinq. Maintenant, il ne s'agit que d'un point d'exclamation suivi d'un signe égal. Et ne vous inquiétez pas, nous les utiliserons dans les prochaines vidéos, partagerons et nous nous entraînerons à les utiliser. Je voulais juste vous présenter chacun des différents opérateurs conditionnels. Le suivant est le symbole supérieur à, que beaucoup d'entre vous ont sûrement vu dans le passé, qui est tout simplement le symbole plus grand que et quelque chose comme cela serait vrai. Alors, dix est supérieur à trois ? Oui, oui, ça l'est. Ce serait donc vrai. Ensuite, nous pourrions faire le contraire ici. Disons trois, moins de dix. Et celui-ci est juste le symbole « moins que » que vous avez probablement vu auparavant. Maintenant, celui-ci est un peu différent de ce que vous avez vu par le passé, où vous auriez normalement la ligne sous le symbole supérieur à. Mais c'est assez simple. Vous allez simplement être le symbole supérieur suivi d'un signe égal. Nous allons juste vérifier si ce qui se trouve à gauche est supérieur ou égal à ce qui est à droite. Et tout ça va aller de gauche à droite, juste pour que tu saches. Ainsi, par exemple, nous pouvons dire que dix est supérieur ou égal à cinq ? Et cela serait vrai parce que dix est supérieur ou égal à cinq et pourrait donc même être dix, et ce serait également vrai. Et puis en bas, nous avons le symbole inférieur ou égal à, qui est juste un symbole inférieur à, suivi du signe égal ici. Et nous pouvons avoir quelque chose comme cinq, moins ou égal à dix. Maintenant, ce ne sont que quelques exemples très basiques, mais notez simplement qu'au lieu d'ajouter des valeurs réelles ici, nous pouvons ajouter des variables que nous avons créées, ce qui élargit vraiment les possibilités car nous pourrions alors faire des choses en fonction des entrées de l'utilisateur, par exemple. Donc voilà, ce sont tous les différents opérateurs conditionnels que vous pouvez utiliser lorsque vous travaillez avec des instructions conditionnelles. Dans la vidéo suivante, nous allons passer revue quelques opérateurs supplémentaires. Ensuite, nous allons créer notre toute première déclaration conditionnelle. Alors merci de m'avoir écouté, et à bientôt. 27. Chapitre 6 (conditionnels) : opérateurs logiques: Dans cette vidéo, nous allons parler des trois opérateurs logiques différents et de C plus plus. Et voici quelques opérateurs supplémentaires que vous pouvez utiliser lorsque vous travaillez avec des instructions conditionnelles. Le premier que nous avons est l'opérateur et, qui est créé en utilisant deux symboles n ou des signes d'esperluette. Et la façon dont celle-ci fonctionne, car elle vérifiera si l' expression de gauche et l'expression de droite sont toutes les deux vraies, et si c'est vrai, alors cette condition dans son ensemble sera vraie. Par exemple, cinq est-il supérieur à trois ? C'est trois de moins que bien, parce que les deux sont vrais. Cela ne serait vrai que si les deux expressions sont vraies. Eh bien, ce serait une vraie condition. Maintenant, celui ci-dessous est l'opérateur or. Et cela a été créé avec ces deux symboles radicaux ici. Et la façon dont celui-ci fonctionne est que je vais simplement vérifier si l'expression gauche ou si l'expression de droite est vraie, si au moins l'une d'entre elles est vraie, la condition dans son ensemble sera vraie. Donc, par exemple, on peut dire, est-ce que cinq est supérieur à trois ? Eh bien, oui, est-ce que trois sont plus que cinq ? La réponse est non. Parce que celui-ci est vrai. Toute cette condition est vraie parce que nous voulions juste savoir si l'une ou l' autre était vraie. Enfin, nous avons cet opérateur NOT que vous avez vu dans la dernière vidéo avec l'opérateur non égal à présent, qui ne renvoie vrai si la condition ici est fausse. Parce que cinq, c'est moins que trois, ce qui est faux. Et nous nous demandons si ce n'est pas vrai essentiellement, alors toute cette condition serait vraie. Donc, juste pour récapituler que la façon dont cela fonctionnerait ici en tant que f, ce qu'il y a ici est faux. La condition dans son ensemble retournerait vraie, car elle récupérerait essentiellement le contraire à partir de cet opérateur NOT. Et une autre façon d'y penser, comme nous le disons essentiellement, n'est-ce pas vrai ? Et à cause de ce faux, ce n'est pas vrai. Bref, c'est tout pour cette vidéo. la vidéo suivante, nous allons créer nos toutes premières instructions conditionnelles . Vous pourrez enfin vous entraîner à utiliser ces différents opérateurs et à créer déclarations conditionnelles. Alors merci de m'avoir écouté, et à bientôt. 28. Chapitre 6 (conditionnels) : si les déclarations: Dans cette vidéo, nous allons créer et utiliser notre toute première instruction conditionnelle , l'instruction if. Et c'est l'instruction conditionnelle la plus élémentaire que vous verrez en programmation. Alors allons-y et voyons comment cela a été créé. Donc, d'abord, je vais vous montrer la syntaxe pour créer une instruction if et vous pouvez les copier si vous le souhaitez. Sinon, vous pouvez simplement suivre. Ok, alors tu y vas. En gros, nous allons dire f puis m entre parenthèses. Nous allons mettre une condition que nous voulons vérifier pour voir si elle est vraie ou non. Et si c'est vrai, nous allons tout faire dans notre bloc de code. Et vous avez peut-être remarqué que c'est essentiellement ce que je vous ai montré lorsque je vous ai présenté pour la première fois des déclarations conditionnelles. Alors allons-y et créons notre premier. Ici, en bas. Nous allons continuer et dire si cinq est supérieur à trois. Et puis entre crochets ici, nous allons dire C à la fin. Cinq est supérieur à trois. Ça ressemble à ça. Maintenant, si nous exécutons notre programme, nous verrons que cinq sont crédités plutôt que trois seront imprimés sur la console. Et c'est parce que notre condition ici était vraie. Donc, en gros, nous disons simplement que si cette condition est vraie, exécutez ce code. Et juste pour vous montrer que cela ne fonctionnerait pas si cette condition était fausse, nous allons procéder et inverser la tendance. Donc on va dire que c'est cinq, moins de trois. Et quand notre code est à nouveau, et vous pouvez voir que rien ne se passe. Et c'est parce que tout ce qui se trouve à l'intérieur ce bloc de code sera entièrement ignoré. De plus, vous pouvez faire autre chose, plutôt que de mettre une expression ici, c'est simplement la supprimer complètement. Je peux juste dire si c'est vrai, et cela fonctionnera très bien. Comme vous pouvez le voir, notre code a fonctionné. Et vous pouvez aussi faire le contraire en disant que c'est faux. Et vous y voilà. Maintenant, je ne peux pas vraiment penser à un bon exemple de cas où vous utiliseriez cela dans une instruction if. Mais je veux juste vous montrer que vous pouvez mettre le vrai ou le faux directement dans la condition. Et juste pour vous montrer un exemple rapide de la façon d' utiliser l'opérateur NOT dont nous avons parlé dans la dernière vidéo. Nous allons simplement mettre ces faux ici, entre parenthèses, puis placer notre opérateur NOT à l'extérieur. Donc, nous disons essentiellement que si ce qu' ici n'est pas vrai, c'est à cause de cela faux, nous exécutons notre code. Vous verrez que notre code à l'intérieur de notre bloc de code s'exécutera. Et ils s'en vont. Maintenant, allons-y et supprimons ce clic. Et je vais juste mettre vrai ici juste vous sachiez que notre code doit fonctionner. Et je vais en fait supprimer ces crochets frisés juste pour vous montrer quelque chose que vous pouvez faire, si vous le souhaitez. Maintenant, si nous devions exécuter ceci, ce code s'exécuterait sans nos crochets. Et si je devais le changer en faux, comme ça. Et exécutez à nouveau notre code, cela serait en fait ignoré. Et c'est parce que C plus plus vous permet en fait de supprimer les crochets lorsque vous ne faisiez qu' ajouter une déclaration comme celle-ci. Personnellement, je ne le recommanderais pas. Je pense que c'est une façon très compliquée d'écrire du code, mais je ne voulais pas vous montrer que c'est possible au cas où vous le verriez un jour dans le futur. OK, alors allons-y, remettons nos crochets et remettons notre code à l'intérieur. Quoi qu'il en soit, vous y voilà. Vous savez maintenant comment créer une instruction if est devenue l' instruction conditionnelle la plus élémentaire que vous puissiez créer. Très rapidement, juste pour vous montrer que cela fonctionne avec des variables. Nous allons en créer un couple ici. On peut donc dire qu'un est égal à cinq. Et bon sang, c'était le numéro deux égal trois. Ensuite, ici, on peut simplement dire que num un est supérieur à deux ? Et parce que c'est le cas, notre code s'exécutera. Une autre chose que je veux vous montrer, c'est que vous pouvez simplement les mettre sur la même ligne, comme je l'ai fait ici. Donc, comme vous pouvez le voir, cela fonctionnera très bien. Et la plupart du temps, je le ferai si j'ai quelque chose de très petit à exécuter dans mon instruction if, mais normalement, je trouve qu'il est beaucoup plus propre d'avoir mes crochets bouclés sur des lignes séparées. De plus, pour ceux d'entre vous qui utilisent Visual Studio, vous pouvez simplement le taper, puis appuyer sur onglet et il le remplira automatiquement pour vous. C'est donc un moyen très pratique de créer immédiatement une instruction if. Il y a d'autres choses comme ça que vous pouvez avoir créées automatiquement et Visual Studio. Mais au cours de ce cours, je vous recommande de simplement le taper afin de vous entraîner. Maintenant, il y a une autre chose que je voulais vous montrer à tous, parce que vous pouvez en fait mettre des expressions beaucoup plus larges ici. Ainsi, par exemple, nous pourrions dire num un supérieur à num deux. Et nous allons juste dire dix de plus que 35, plus d'un. Et parce que tout cela est vrai, cela devrait s'exécuter, exécuter un code. Vous pouvez voir qu' il a très bien fonctionné. Mais si je devais le remplacer par un échantillon de secrétaire à la fin et exécuter à nouveau notre code. Parce que tout cela n' était pas vrai. Cela ne fonctionne pas. Vous pouvez les mélanger et les associer à des signes ET, ou, OU, et nous faire exprimer aussi longtemps que vous le souhaitez. Mais plus vous faites cela de long, de gros et de complexité, je vous recommande d'utiliser des parenthèses, comme vous le feriez pour les expressions mathématiques pour définir l'ordre de vos opérations. Par exemple, je pourrais vouloir mettre ces deux éléments ici au lieu de parenthèses. Cela a donc été vérifié d'abord, puis vérifié ensuite. Ou je peux même mettre le signe ou ici et dire que dix supérieur à 35 est supérieur à six. Et parce que ce serait faux, alors cela devrait être vrai parce que je voudrais savoir si cela ou tout ce qui se trouve à l'intérieur d'ici est vrai. Donc parce que celui-ci s' affichera ici, même si celui-ci est faux, sinon le code s'exécutera. Parce que nous sommes en train de vérifier si c' est vrai ou si c'est vrai. Notez également que si vous ne mettez rien entre parenthèses ici, vous obtiendrez une erreur. Et il vous demandera de mettre une sorte d'expression. Quoi qu'il en soit, juste pour résumer rapidement, ce que je veux que vous retiriez de cette vidéo, c'est de créer une déclaration if. Vous allez simplement dire si, en minuscules, puis entre parenthèses, vous allez mettre une condition selon laquelle vous voulez vérifier si elle est vraie ou non. Ensuite, entre crochets, vous attendez de mettre tout le code que vous souhaitez exécuter si cette condition est remplie. Alors, vous l'avez. C'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 29. 28: Dans cette vidéo, nous allons parler de l'imbrication des instructions if. Maintenant, qu'est-ce que je veux dire par là ? Eh bien, en gros, c'est juste un à un si une déclaration s' imbrique ou s'insère dans une autre. Alors allons-y et à quoi cela ressemblerait. Donc, d'abord, nous allons créer une instruction if de base comme celle-ci. Ensuite, nous allons créer une autre instruction if à l'intérieur du bloc de code pour cette instruction if. Juste comme ça. Et ensuite, ici, nous allons passer à faux, comme ça. Et puis, ici, nous allons commencer et dire « C ». Et nous allons imprimer la deuxième déclaration comme ça. Ensuite, nous allons copier toute cette ligne de code et la mettre également dans notre première instruction if. Juste comme ça, nous allons changer celui-ci pour dire « d'abord ». Donc, en gros, la façon dont cette première déclaration si va fonctionner est tout aussi normale que de vérifier. Cette condition est-elle vraie ? Et si c'est le cas, tout ce qui se trouve dans ce bloc de code fonctionnera. Et si ce n'est pas le cas, il va simplement aller l'avant et l'ignorer complètement. Ensuite, cette seconde instruction if va également vérifier si la condition à l'intérieur de cette instruction est vraie. Et si c'est le cas, il n' exécutera le code qu'à l'intérieur de son bloc de code qui se trouve ici. Si elle est fausse, elle est appelée bloc et sera complètement ignorée. Ensuite, le reste du code de l'instruction first step s' exécutera normalement. Parce que si vous êtes membre, code est lu de haut en bas. Donc, comme je pouvais être rouge, ça va vérifier si cette condition est vraie. Si c'est génial, il va commencer à lire ce code. Ensuite, il va vérifier si cette condition est vraie. Si c'est L, lisez tout le code qu'il contient, puis continuez. Si ce n'est pas vrai, ce bloc de code sera simplement ignoré et continuera normalement. Donc, si nous exécutons notre code maintenant, il s' imprimera d'abord l'instruction if. Et si le code qu' il contient était également vrai. Donc, si nous changeons simplement cela en vrai pour l'instant, exécutez, notre code indiquera deuxième instruction if , puis la première instruction if. Et la raison pour laquelle il est dit second if statement first est que mon code est lu de haut en bas. Donc, même si cette première affirmation était vraie, il fallait d'abord lire si la seconde était vraie et faire tout ce qu'elle contenait d' abord, si c'était vrai, avant de continuer ici pour montrer vous que c'est le cas. Si je devais couper ce code et le placer au-dessus de cette première instruction if comme celle-ci et réexécuter notre code. Vous pouvez voir qu'il l'a fait maintenant dans l'autre sens. Alors, vous l'avez. Vous savez maintenant comment imbriquer des déclarations. Et vous pouvez le faire autant de fois que vous le souhaitez. Maintenant, avant de terminer cette vidéo, revenons également à un sujet précédent, lorsque nous avons parlé variables locales et globales. Rappelez-vous comment j'ai dit qu' une variable locale n' est disponible que dans son périmètre ou dans le bloc de code à partir duquel elle a été créée. Donc, si nous créons une variable globale ici, appelons-la une base basse et définissons-la à cinq. Donc, comme nous avons cette variable globale ici, elle est disponible partout dans votre code en dessous. Donc, ce que cela signifie, c'est au lieu de notre première déclaration, nous pouvons dire « premier si ». Ensuite, nous pouvons imprimer dans le monde entier. Allons-y et créons une nouvelle ligne. Et puis, même dans notre deuxième déclaration, nous avons également accès à global. Cela fonctionnera également. Donc, si nous exécutons notre code, il indiquera d' abord si l'instruction 5 est notre variable globale. Deuxième déclaration. Et aussi juste pour vous montrer que c'est également possible. Et notre variable globale, nous pourrions la déclarer ici, puis l' initialiser ici. N'oubliez pas que vous devez vous assurer de donner une valeur initiale à une variable avant de l'utiliser. Donc, avant de l'imprimer ici, disons global, puis donnez-lui une valeur initiale, trois. Et cela fonctionnera exactement comme d' abord si l'énoncé 3. Deuxième de la déclaration 3. Mais maintenant, allons-y et examinons certaines variables locales. Donc, si nous nous en débarrassons, tout d'abord, vous remarquerez qu'il ne sait plus ce qu'est le global. Supprimez simplement qu' ils le sont d'une manière ou d'une autre. Si nous devions créer une variable dans notre fonction principale, elle serait également disponible dans nos deux instructions if. Et c'est parce que, par exemple si nous disons num un ici, et qu'il cherche égal à cinq, par exemple, cela sera désormais disponible partout dessous dans son bloc de code. Donc, jusqu'à ce support bouclé fermé, ici pour cette méthode, dans ce cas, c'est notre méthode principale. Donc, pour résumer, notre variable locale sera disponible partout en dessous, car le code est lu de haut en bas dans le cadre de sa portée, étant donné que notre variable locale sera disponible partout en dessous, car code est lu de haut en bas dans le cadre de cette méthode complète est ici. Mais que se passerait-il si nous devions créer une variable locale dans l'une de ces instructions if ? Eh bien, il ne sera disponible que dans son bloc. Donc, si nous disons que num un est égal à cinq, en dehors du fait que ce bloc de code se trouve ici, parce que le bloc de code s'exécute d'ici à ici, nous ne pouvons plus y accéder. Cela pourrait tout aussi bien ne pas exister. Donc, num un est égal à dix, ça ne marche pas parce que nous ne savons pas ce qu'est num un. Il n'est pas défini. Cette variable n'existe pas car sa portée se trouve ici. Cependant, cela existerait dans notre deuxième déclaration. Donc, ici, nous pouvons toujours imprimer numéro un parce que c'est dans le champ d'application. Alors, vous l'avez. Je voulais juste vous donner un meilleur exemple de ce dont je parlais lorsque nous avons parlé de variables locales et globales. N'oubliez donc pas qu'une variable globale est une variable créée en dehors du bloc de code ; une variable locale est une variable créée à l'intérieur. Une variable globale sera disponible partout après sa création, une variable locale ne sera disponible partout qu' après sa création jusqu'à la fin de son bloc de code. Alors, vous l'avez. J'espère que cela a du sens. Si ce n'est pas le cas, allez-y et jouez un peu avec les variables locales et globales juste pour voir si leur disponibilité est étendue. Quoi qu'il en soit, c'est tout pour cette vidéo, la vidéo suivante, nous allons examiner un autre type d' instruction conditionnelle connue sous le nom d'instruction if else. Alors merci de m'avoir écouté, et à bientôt. 30. Chapitre 6 (conditionnels) : déclarations à d'autres: Dans cette vidéo, nous allons examiner la déclaration if else. Permettez-moi donc de vous montrer la syntaxe de l'instruction ou les règles de création de cette instruction. Donc, comme avant, vous allez créer une instruction IF de base dans laquelle vous allez dire f, puis des parenthèses. Vous allez mettre la condition que vous souhaitez vérifier. Si c'est vrai, alors votre code bloque après. Cependant, juste après cela, vous allez entrer le mot clé else, qui est également entièrement en minuscules, tout comme F ici. Et puis, juste après avoir dit le contraire, vous allez mettre juste un autre bloc de code sans condition. Donc, en gros, nous disons que si cette condition est vraie, nous voulons le faire comme d'habitude, ou vous pouvez penser à cela comme si vous le faisiez autrement. Alors allons-y et voyons comment cela fonctionne. Donc, ici, nous allons créer une instruction if de base. Donc, nous dirons si, disons, cinq est supérieur à trois, puis après ce bloc de code, nous dirons le contraire et remarquerons et Visual Studio ici, comment il met automatiquement en évidence les deux pour me montrer ils sont liés. Vous pouvez également simplement appuyer sur la touche de tabulation et le reste sera automatiquement créé pour vous. Sinon, vous allez simplement mettre un autre support bouclé ouvert et fermé comme celui-ci. Nous avons donc créé notre déclaration FL, mais allons-y et voyons de plus près comment cela fonctionne. Alors, allons-y et voyons dans quelle mesure l'état d'impression était vrai. Ensuite, dans notre instruction else ou notre bloc de code else ici, allons-y et disons condition CL. Et la raison pour laquelle je nous ai fait les écrire spécifiquement , c'est pour nous faire comprendre comment cela fonctionne. Donc, en gros, nous allons vérifier cette condition comme d'habitude. Mais si cette condition est fausse, ce bloc de code s'exécutera ici si une condition fixe est vraie. Ce code s'exécutera ici. Donc, en gros, vous voulez utiliser une instruction if else lorsque vous voulez exécuter quelque chose uniquement si la condition est vraie, mais vous voulez également exécuter quelque chose si la condition est fausse. Et maintenant, si nous exécutons notre code ici, vous allez voir qu' il va dire que la condition est vraie parce que cinq est supérieur à trois. Mais si nous allons de l'avant et que nous renversons la situation maintenant, je dirais que c'est cinq, moins de trois. Et quand ils seront à nouveau coupés, cela indiquera que leur état était faux. Ainsi, tout ce qui se trouve sur votre bloc de code F fonctionnera si la condition est vraie et tout le reste. Le bloc de code s'exécute si la condition est fausse. Je sais que nous n'avons mis qu'une seule déclaration ou qu'un seul morceau de code à l'intérieur de ces blocs de code. Mais cela peut être aussi grand que vous le souhaitez. heure actuelle, certains d'entre vous se demandent peut-être pourquoi ne pas simplement le prendre et le mettre ici ? Eh bien, nous n' aurions peut-être pas voulu dire que notre état était faux si ce n'était pas le cas, n'est-ce pas ? Donc, cela nous permet simplement d'avoir un bloc de code spécifique qui ne s' exécutera que si c'est vrai dans un bloc de code spécifique qui ne s' exécutera que s'il est faux. Alors, vous l'avez. Vous savez maintenant comment créer une instruction if else. la vidéo suivante, nous allons regarder ce que l'on appelle des déclarations fictives. Alors, comme toujours, merci de m'avoir écouté et je vous verrai dans la prochaine. 31. Chapitre 6 (conditionnels) : autres déclarations: Dans cette vidéo, nous allons voir comment créer une instruction else dans laquelle nous pouvons essentiellement vérifier si une condition est vraie, puis vérifier si une ou plusieurs autres conditions sont vraies, alors nous pouvons toujours faire fonctionner quelque chose si aucune de ces conditions n'est remplie. Alors allons-y et voyons comment cela fonctionne. Donc, la syntaxe de base pour cela est créer une instruction if comme nous l'avions fait par le passé. Et si cette condition est vraie, ce code s'exécutera et tout le reste sera ignoré jusqu'à la fin. Mais nous pouvons jeter cela d'ici pour voir si une autre condition est vraie au cas où la première ne l'était pas, puis si c'est vrai, seul ce code s' exécutera et le reste sera ignoré. Ensuite, nous pouvons toujours avoir une autre déclaration où nous pouvons dire que si rien de tout cela n'était vrai, nous voudrions quand même le faire. Et vous y voilà. C'est la syntaxe de base d'une instruction else. Alors allons-y et créons l'un de nos très jeunes enfants. Et juste pour nous amuser, allons-y et créons également un programme simple pour cela. Nous allons donc dire « nul ». Et puis en dessous, nous allons dire int num deux. Ensuite, allons-y et obtenons commentaires des utilisateurs à ce sujet. Nous dirons donc qu'ils ont envoyé un coup qui dira péché. Ensuite, à la fin de tout cela, nous créerons notre autre déclaration. Donc, disons que si engourdi un est supérieur à deux, alors nous voulons faire ce qui suit. Alors dites C sur un. Et puis, entre guillemets, nous dirons est supérieur à. Ensuite, nous ajouterons également. Pour faire ça. Nous allons continuer et souligner. Et je vais ajouter quelques espaces ici, juste pour que cela soit beaucoup plus propre une fois imprimé. Ensuite, en bas, nous dirons autre chose. Et encore une fois, tout cela est en minuscules, moins que numéro deux. Ensuite, nous voulons imprimer le contraire. Donc, dites CL num un, num deux. Et puis ci-dessous, nous dirons autre chose. Et puis n'oubliez pas que nous ne mettons pas de condition, nous disons simplement le contraire. Vous voulez dire qu'un est égal à deux mètres ? Juste comme ça. En gros, nous allons prendre deux et des animaux de compagnie et saisir une entrée pour eux, puis mettre le numéro deux. Ensuite, nous allons dire que si numb un est supérieur à num deux, alors nous allons simplement imprimer num un est supérieur à num deux. Sinon, si num un est inférieur à num deux, alors nous voulons imprimer num un est inférieur à num deux. Sinon, si aucune de ces affirmations n'est vraie, eh bien, elles doivent être égales. Nous avons donc dit que, sinon, num un est égal à num deux. Ensuite, si nous voulons nettoyer cela, afin que cela soit un peu mieux pour l'utilisateur ou pour nous dans cet exemple ci-dessus, nous pouvons procéder comme suit. On peut dire C hors nombre, espace deux-points comme ça. Ensuite, nous allons simplement le copier et le coller en dessous de notre instruction cin num one, comme si nous allions taper a, un autre chiffre. Ensuite, je vais faire un zoom arrière rapide pour que vous puissiez regarder le code en entier, pour m'assurer que le vôtre correspond au mien. Ensuite, nous allons exécuter notre code pour nous assurer qu'il fonctionne. Et assurez-vous de l' exécuter sans déboguer ou d'ajouter un tas de ces sin dot getline. Alors allez-y et entrez un chiffre. Ensuite, pour votre deuxième numéro, entrez un nombre plus petit que le premier. Et je dois dire que notre premier chiffre était supérieur à notre deuxième. Ensuite, nous pourrons recommencer à exécuter notre programme. Mais cette fois, saisissons un plus petit nombre pour le premier. Et voilà, c'est prêt. Notre premier chiffre était inférieur à une seconde. Et si nous le lançons à nouveau, nous pouvons en saisir deux du même nombre exact. Et il faut dire qu'ils sont égaux. Et voilà, tout fonctionne. Et juste un petit mot avant de terminer la vidéo, je tiens à vous faire savoir que vous pouvez en avoir plusieurs autres. Si les conditions sont présentes dans votre instruction, vous pourriez dire qu'Alice num un est égal à num deux par exemple, et ensuite avoir un bloc de code pour cela également. Et cela fonctionnera très bien. Maintenant, évidemment, dans cet exemple, nous pourrions tout aussi bien utiliser autre chose. Mais tu comprends ce que je veux dire. Vous pouvez avoir autant de déclarations ou de conditions que vous le souhaitez. De plus, vous n' avez même pas besoin de cette autre déclaration en bas. C'est juste quelque chose que vous pouvez avoir, mais vous pouvez vous en débarrasser complètement car votre code fonctionnera toujours normalement. Donc, si je lance mon programme, vous pouvez voir qu'il est opérationnel , pas de problème. Alors, quand voudriez-vous utiliser une instruction else if ? Eh bien, chaque fois que vous voulez vérifier la présence de plus d'une affection et qu'elles sont toutes liées, comme si elles étaient ici. Vous pouvez utiliser une instruction else. Vous pouvez en avoir autant que vous le souhaitez, comme je l'ai dit. Et puis vous pouvez même utiliser votre instruction else pour exécuter un morceau de code si tout était faux. Et si je reviens à ce que nous avions, souvenez-vous simplement que dès que l'une de ces conditions sera remplie, tout le reste qui , dans le cadre de cette autre déclaration, sera ignoré. Si cette condition est vraie, il va simplement lire le contenu de ce bloc de code , puis sauter tout en bas. Si le premier est faux et que le second est vrai, il lira simplement le contenu de ce bloc de code et ignorera tout le reste. Et ensuite, si rien n'était vrai, alors notre autre déclaration sera valide si nous en avons une. Alors méfiez-vous de cela, mais cela se lit de haut en bas et seule la première déclaration qui se réalise aura de l'importance. Donc, même si et sinon déclaration ici, nous inversons la tendance et nous avons dit que c'est supérieur ou égal à. Et puis lancez notre code , nul un, j'en mets dix. Pour le numéro deux, j' en ai mis cinq, par exemple. Et il n'y aura qu'un stylo à imprimer qui est supérieur cinq et moins parce que dès que l'une de ces conditions est vraie, il ne se soucie pas du reste quel que soit le nombre de déclarations que vous avez avoir. Donc, méfiez-vous de cela et assurez-vous que si vous voulez d'abord vérifier la présence d'une affection, celle-ci est au sommet. Voilà, vous l'avez. J'espère que vous avez maintenant une bonne compréhension de la façon dont les déclarations « sinon » et « sinon » fonctionnent. Et sinon, je vous recommande vivement revenir en arrière et de revoir la vidéo sur laquelle vous rencontrez des difficultés et jouer avec elle un peu plus pour mieux comprendre comment tout cela fonctionne. Cela étant dit, vous les verrez davantage tout au long du cours. Vous aurez ainsi une pratique plus naturelle. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 32. Chapitre 6 (conditionnels) : Changer les déclarations: Dans cette vidéo, nous allons examiner la création de ce que l'on appelle une instruction switch. Et cela prend essentiellement une valeur entière , puis exécute un bloc de code en fonction de cette valeur. Donc, ici, j'ai la syntaxe de base pour vous. Donc, en gros, nous allons dire switch et tout en minuscules. Ensuite, entre parenthèses, nous allons mettre notre valeur entière. Et cela peut même être le nom d' une variable qui est une valeur entière. Ensuite, nous allons avoir des crochets bouclés ouverts et fermés. Et à l'intérieur de cela, nous allons écrire des majuscules, toutes en minuscules, suivies du chiffre. Nous voulons vérifier si c'est bien ce numéro. Nous pouvons donc dire que si ce chiffre est un, nous voulons le faire. Ensuite, nous allons dire « pause » avec un point-virgule pour séparer cette section de code. Et ensuite, ici, nous pouvons parler du cas deux, nous voulons le faire et ensuite nous interrompons cela également. Et nous pouvons continuer à le faire encore et encore. Ensuite, nous pouvons également avoir une valeur par défaut, ou nous pouvons simplement dire par défaut en minuscules suivies de deux-points. Alors on pourrait le faire. Ensuite, nous pouvons également faire une déclaration de pause à la fin de celle-ci, bien que celle-ci ne soit pas nécessaire. Fermez ensuite un crochet, et vous pouvez simplement avoir un exposé de cas ici, ou deux ou trois, ou comme je l'ai dit, autant que vous le souhaitez. J'en ai juste deux ici pour vous montrer que nous pouvons en avoir plus d'un. J'espère donc que ce n'était pas trop confus pour vous. Si c'était le cas, nous allons commencer et en créer un à partir de zéro. Tu peux avoir une meilleure idée de la façon dont ça fonctionne. Maintenant, très rapidement, certains d'entre vous ont peut-être déjà indiqué que cela ressemble beaucoup à notre autre déclaration. Eh bien, c'est parce que les seules vraies différences ici sont que, pour commencer, cela prend une valeur entière. Plutôt que de pouvoir mettre en état de défaut notre expression que nous voulons vérifier pour voir si elle est vraie, nous faisons simplement quelque chose en fonction de ce que ce nombre est. Donc, vous pouvez voir cela comme si vous dites f , entrez notre numéro et puis autre chose, Ceph les chiffres, ce nombre est celui-ci, puis notre autre déclaration. Mais je veux juste vous faire savoir qu' une instruction switch est plus rapide. Et dans de nombreux cas, si vous essayez juste de voir ce qu'est un nombre, ce sera beaucoup plus lisible. Alors allons-y et créons l'un des nôtres. Donc, ici, nous allons continuer et dire que réponse int est égale à 0. Ensuite, allons-y et disons que le PDG dira, veuillez choisir une option. Et je dirais l'espace entre les deux points. Et ensuite, nous y mettrons également une ligne en ligne. Ensuite, ci-dessous, vous allez créer une autre instruction c out. Nous allons par exemple en saisir un pour le bouton du menu principal et une ligne de fin ici, ou créer une nouvelle ligne. Je vais juste dire backslash n. Pour celui-ci, nous allons faire la même chose ci-dessous, disons du ruban adhésif sur quatre options. Juste comme ça. Et je vais créer à nouveau une nouvelle couche et en dessous, je créerai notre switch. Mais avant cela, allons-y et acceptons la réponse de l'utilisateur. Nous allons donc dire correspondance. Ensuite, le changement de créancier, si vous vous en souvenez, nous allons dire switch et tout en minuscules. Ensuite, entre parenthèses, nous allons mettre un entier ou notre variable, dans ce cas, la réponse. Et ensuite, je vais avoir des crochets bouclés ouverts et fermés. Et ensuite, entre ces crochets, nous créerons nos étuis. Ou ce que nous voulons vérifier pour voir si notre réponse ou notre entier ici est égal à. Ainsi, par exemple, nous allons dire majuscules et minuscules, soit dit en passant, un espace pour la valeur que nous voulons vérifier, puis deux points. Ensuite, nous dirons menu principal CL. Alors, eh bien, nous allons continuer et dire « casser tout en minuscules » avec un point-virgule à la fin. Ensuite, nous allons créer un autre cas pour deux, et nous dirons «  options ». Alors dis Case. Options de référencement Coleman. D'ailleurs, pour ceux d'entre vous qui utilisent Visual Studio, vous avez peut-être remarqué que des guillemets seront automatiquement placés pour vous. Cependant, si vous finissez par taper une autre citation par vous-même, il sautera simplement cela. Cela ne posera aucun problème. Il n'y en aura pas une seconde et vous pouvez continuer à taper. Mais c'est bien que cela crée un changement pour vous au cas où vous oublieriez. Ensuite, nous allons mettre un point-virgule à la fin et nous dirons encore une fois. Et en fait, je vais aller de l'avant et mettre notre C sur une ligne séparée. Tuons. Je trouve que ça a l'air un peu plus propre. Ensuite, ici, si nous le voulions, nous pourrions continuer à ajouter d'autres valises à vérifier. Ou nous pouvons même ajouter un défaut si nous le voulons également. Et allons-y et faisons-le juste pour le fun. Donc, dites par défaut. Ensuite, nous dirons que CL dira que option est en fait qu'elle ira de l'avant et dira votre choix. Comme je l'ai dit, vous pourriez ajouter une autre analyse ici. Si vous le souhaitez, certains d'entre vous trouveront peut-être que cela semble plus symétrique ou autre, mais ce n' est pas nécessairement le cas, essentiellement, le SprayC vous sort simplement de cette section de code puisqu'il ne les tient pas entre crochets, comme nous l'avons vu par le passé. Et aussi, même si nous n'avons qu'une seule ligne de code, c'est sympa, et que vous pouvez en avoir autant que vous le souhaitez, comme n'importe quel autre bloc de code. Maintenant, je vais faire un zoom arrière rapide, afin que vous puissiez vous assurer d'avoir copié tout cela vers le bas. Et grandissez rapidement pour ceux d'entre vous qui se demandent quels étaient ces petits blocs négatifs. Pour ceux d'entre vous qui utilisent Visual Studio et de nombreux autres programmes, vous pouvez également cliquer dessus et cela réduira tout ce qui se trouve à l'intérieur de ce que c'est. C'est sur If Statements, sur les méthodes et autres choses de ce genre, mais cela vous laissera toujours ce que c'est. Et puis il y aura même les crochets frisés composés de trois points ici. Et si vous passez la souris dessus, vous pouvez voir quel code est minimisé en ce moment. Maintenant, le code fonctionnera toujours. Le code s'exécutera toujours. En gros, il s'agit simplement de minimiser. Je veux dire, vous pouvez simplement cliquer sur ce bouton plus maintenant et minimiser cela pour vous. Donc, si vous travaillez avec beaucoup de code à un moment donné et que l'écran semble soudainement un peu désordonné. Vous pouvez simplement le fermer une fois que vous avez fini travailler sur quelque chose ou si vous essayez de travailler sur autre chose. Quoi qu'il en soit, je voulais juste te le montrer rapidement. Quoi qu'il en soit Maintenant, si je lance notre code, vous pouvez le voir. Choisissons donc une option, tapons-en une pour moi, plusieurs options de type deux. Alors allons-y et saisissons-en un pour voir ce qui fonctionne. Tu y vas. Il est écrit Menu principal. Et je vais en fait ajouter une nouvelle ligne sur les deux, juste pour clarifier un peu les choses, ou sur toutes, devrais-je dire comme ça. Et exécutez à nouveau notre code. Si on en prend deux et qu'il y aura des options. Et si nous le lançons encore une fois ici et que nous saisissons simplement n'importe quel nombre entier en dehors de ce que nous avons plaidé et que nous appuyons sur Entrée. Vous pouvez voir qu'il indiquera vos choix et est valide car aucun de nos cas n'était vrai. Comme vous pouvez le voir, cela fonctionne de manière très similaire à une instruction else if, sauf qu'à l'intérieur de ces parenthèses, vous aurez besoin d'une valeur entière. Et si nous le voulions, nous aurions pu simplement saisir un nombre comme celui-ci et exécuter notre code. Et il attend toujours que nous saisissions quelque chose pour obtenir une réponse. Vous pouvez donc aller de l'avant et le faire. Mais peu importe ce que nous saisissons, cela indiquera menu principal, car ce qui était sur notre interrupteur en était un. Et vous y voilà. Maintenant, évidemment, il n'y a pas vraiment de bonne raison pour laquelle tu ferais ça. Normalement, vous allez simplement ajouter votre variable ici et prendre quelques entrées, car un commutateur sera généralement là pour vérifier plusieurs options, n'est-ce pas ? Vous allez donc prendre quelque chose qui peut varier. Maintenant, je voulais vous avertir, en particulier pour ceux d'entre vous qui peuvent provenir un autre langage de programmation, si vous supprimez l'une de ces instructions de rupture. Donc, dans notre cas, si je l' ai supprimé, il exécutera tout ce code jusqu'à ce qu'il atteigne une autre instruction break, que notre réponse soit deux ou non. Et si nous exécutons notre code ici, vous pouvez voir que c'est vrai. Donc, si j'en tape un, par exemple et que j'appuie sur Entrée, cela enregistrera le menu principal et les options même si nous en avons saisi un. C'est parce que sans cette interruption, il fait quelque chose appelé fall-through, où il va simplement parcourir et exécuter tout le code à l'intérieur de votre commutateur jusqu'à ce qu'il atteigne une instruction break ou à la fin du commutateur. Et si je sortais notre autre déclaration de pause ici, vous pouvez voir qu'elle imprimerait même vos choix et qu'elle serait valide si nous en saisissions une. Cependant, cette erreur ne commencera que là où elle était vraie. Donc, si je tape, si je lance à nouveau un programme ici, je devrais dire Options, puis vos choix et votre équilibre. Alors, tu y vas. Maintenant, il peut y avoir des cas où vous souhaitez que cet automne soit adopté. Peut-être que vous avez une idée intéressante de ce qui sera utile. Et C plus plus est l'un des rares langages que je connaisse qui vous permettra de le faire, du moins par défaut. Mais normalement, ils ne voudront probablement pas que cela se produise. Donc, vous voulez vous assurer de lancer la pause après chacun de ces éléments en dehors du sens par défaut, il s' arrêtera automatiquement une fois qu'il aura atteint ce crochet bouclé fermé de toute façon. Enfin, je vais juste vous montrer à quoi cela ressemblerait. S'il s'agissait d'une autre déclaration, juste pour vous montrer les similitudes ici. Nous aurions donc pu dire si la réponse est égale à un, puis la mettre dans notre code ici en dehors de la pause. Et ensuite, en dessous, nous allons définir que la police est égale à deux. Ensuite, en dessous, nous pouvons simplement dire le contraire et le mettre dedans. J'espère donc que vous pourrez voir les similitudes ici. Comme je l'ai dit, ils fonctionnent essentiellement de la même manière. Cependant, cela nous permet de le mettre dans un état beaucoup plus grand. Nous voulons vérifier si c'est vrai ou si cela vient de mettre une valeur entière. Et personnellement, si c'est ce que vous faites, c'est simplement vérifier une valeur entière et vouloir voir à quoi elle est égale. Je pense que cela a l'air beaucoup plus propre et qu'il fonctionne plus rapidement. Alors, tu y vas. Vous savez maintenant comment créer une instruction switch. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 33. Chapitre 6 (conditionnels) : Opérateur ternaire: Dans cette vidéo, nous allons voir comment travailler avec ce que l' on appelle l'opérateur ternaire. Et vous pouvez également le voir appelé opérateur conditionnel. La syntaxe d'un opérateur ternaire est donc la suivante vous allez avoir une condition selon laquelle vous voulez vérifier si elle est vraie ou fausse. Ensuite, cela sera suivi d'un point d'interrogation. Ensuite, vous aurez une expression ou un morceau de code que vous souhaitez exécuter. Si cette condition est vraie, suivi de deux points. Ensuite, une deuxième expression ou un morceau de code que vous souhaitez exécuter si cette condition est fausse. Enfin, vous allez le fermer par un point-virgule. Maintenant, ci-dessous, j'ai déjà un exemple pour vous montrer comment cela fonctionne. Et ne vous inquiétez pas, nous allons créer l'un des nôtres. Je voulais juste vous montrer à quoi cela pourrait ressembler en écriture ou en code. Donc, mon état est supérieur à cinq, suivi d'un point d'interrogation et ensuite de ma première expression, ou d'un bout de code ici. Donc dans ce cas, j'ai dit « C » bonjour, puis j'ai eu mon côlon. Et puis la deuxième expression ou morceau de code que je veux qu'il exécute si la condition était fausse. Donc, ce C est sorti. Donc, comme celui-ci n'est pas supérieur à cinq, ce morceau de code s'exécutera. Si je lance mon programme ici. Vous pouvez voir qu'il est écrit « acheter ». Mais si on change la donne et qu'on se demande si un est inférieur à cinq ? Parce que c'est vrai. Ensuite, notre premier morceau de code ici, qui se trouve sur le côté gauche de notre deux-points, exécutera à nouveau le code. Vous pouvez voir qu'il est écrit « Bonjour ». De plus, je tiens à vous faire remarquer que je n'ai pas mis point-virgule après mes guillemets. Et c'est parce que c'est la fin de la déclaration, pas ça. Très bien, alors allons-y et créons l'un de nos très jeunes. Je vais donc procéder et supprimer cela. Ensuite, nous allons en dire un. Et en dessous, nous dirons le numéro CN, non ? Nous allons donc prendre un numéro que nous saisirons. Et puis allons-y et créditons l'opérateur ternaire. Nous allons donc dire num un supérieur à 0. Et ce sera notre condition. Ensuite, nous allons poser notre point d'interrogation, puis nous allons suivre avec une expression ou un morceau de code que nous voulons exécuter si cette condition est vraie. Nous allons donc dire C dehors, pas un seul. Ensuite, entre guillemets, allons-y et disons que c'est un nombre positif. Ensuite, nous allons suivre cela avec un deux-points. Ensuite, nous prononcerons à nouveau C. Num un. Et puis cette fois, nous dirons que c'est négatif. Notez que j'ai mis un espace avant les deux parce qu'il n'y en aura pas par défaut une fois notre num one sera imprimé ou qu'il y aura un entier. Maintenant, si nous exécutons le code, je pourrais dire environ cinq. Disons que cinq est un nombre positif. OK ? Mais si on recommence, et que je place moins cinq au centre, ils diront que moins cinq est un nombre négatif. Et c'est parce que nous avons dit ce nombre 1 supérieur à 0. Alors si c'est le cas, nous avons dit que nous voulions imprimer num one is a positive ». Et s'il n'était pas supérieur à 0, nous voulions imprimer que zéro est un nombre négatif, n'est-ce pas ? Tu y vas. C'est la méthode de base pour utiliser un opérateur ternaire. Et la plupart du temps, vous verrez cela utilisé la place d'une instruction if else. Allons-y et créons ce à quoi cela ressemblerait en tant que déclaration FL. Nous aurions pu simplement dire si l'un est supérieur à 0. Et puis, à l'intérieur, il y a un nombre positif imprimé. Je vais donc simplement copier et coller ceci par le haut. Et en dessous, nous dirons autre chose et collerons ceci. Et nous devrons nous assurer de mettre un point-virgule à la fin de nos deux instructions C out. Et vous y voilà. C'est ainsi que nous aurions pu faire la même chose avec une déclaration « if else ». Mais il existe plusieurs autres façons de l'utiliser. Alors allons-y et jetons un coup d'œil à cela. Et je vais aller de l'avant et supprimer notre déclaration « si c'est le cas ». Maintenant, allons-y et voyons une autre façon d'utiliser l'opérateur ternaire. Donc, en bas, allons-y et disons résultat de chaîne. Et nous allons le définir comme un opérateur ternaire. Donc, ici, nous allons dire num un supérieur à 0, suivi d'un point d'interrogation. Et puis, selon ce que c'est, nous voulons simplement définir notre chaîne comme deux est un nombre positif ou un nombre négatif, un peu comme nous le faisions auparavant. C'est juste ici. Ensuite, suivez-le avec deux points, puis insérez cette autre chaîne ici. Puis notre point-virgule à la toute fin. Nous avons maintenant créé une chaîne appelée result et nous la définissons comme égale au résultat de cet opérateur ternaire, toute cette opération ici. Donc, il va dire que num un est supérieur à 0. Si c'est le cas, notre chaîne sera égale à cela. Et si ce n'est pas le cas, alors notre chaîne sera égale à cela. Et maintenant, en bas, allons-y et imprimons ça. Donc on va dire C sur num one. Ensuite, j' imprime le résultat, vais créer une nouvelle ligne comme celle-ci. Ensuite, supprimons notre opération ternaire précédente et exécutons notre code. Maintenant, vous pouvez voir que cela fonctionne à peu près de la même manière qu'auparavant, à la seule différence que nous avons utilisé cet opérateur ternaire ici pour définir quelque chose d'égal à un résultat sur la base de cela ici. Et allons-y et remettons-le dans une déclaration si c' est le cas. Donc, disons que si numb one est supérieur à 0, alors nous voulons définir un résultat égal à celui-ci ici. Sinon, Alice définira le résultat égal à deux est un nombre négatif. Comme ça. Vous pouvez maintenant utiliser ce que vous voulez, ce que vous jugez préférable à votre situation actuelle dans votre programmation. Je voulais juste vous montrer les différentes manières dont vous pouvez l'utiliser. Et il y a en fait une dernière méthode que nous allons examiner, à savoir que vous pouvez réellement imbriquer des opérations ternaires. Donc, tout ce qui est en dehors de notre déclaration entière et de notre ligne de péché, allons-y et débarrassons-nous de tout. Alors. Allons-y, créons une chaîne et appelons-la résolue. Et nous n'allons pas donner de valeur à cela pour le moment. Donc, ici, nous allons aller de l'avant et voir le résultat. Réglez cette valeur à. Allons-y et mettons en place la condition d'un opérateur ternaire. Donc, entre parenthèses, nous allons en fait dire que num un est égal à 0. Ensuite, nous allons suivre cela avec un point d'interrogation entre guillemets , juste comme ça. Ensuite, nous ajouterons un deux-points , puis une autre opération ternaire. Alors allez-y et mettez une parenthèse ouverte. Et nous dirons num un supérieur à 0, suivi d'une parenthèse fermée. Ensuite, nous allons le mettre sur un autre point d'interrogation. Et nous y dirons des citations positives. Ensuite, nous y mettrons un deux-points suivi d'un négatif entre guillemets. Ensuite, nous allons mettre parenthèses et un point-virgule. Et puis de retour ici où nous avons dit num un supérieur à 0, nous allons mettre des parenthèses ouvertes. Très bien, alors allons-y et décomposons tout cela. Personnellement, je pense que cela semble confus, mais si vous voyez cela dans le code de quelqu'un, je veux que vous puissiez le lire et savoir comment cela fonctionne. Très vite, juste pour le mentionner. Oui, on aurait pu mettre tout ça ici. Je ne voulais juste pas en ajouter plus à cette série de choses déjà folles. granitiques veulent juste définir une chaîne. Quoi qu'il en soit, allons-y et passons en revue cela. Nous avons donc défini un résultat égal, puis nous avons voulu le mettre égal quel que soit le résultat de toute cette histoire folle. Nous avons dit, est-ce que num un est égal à 0. Si c'est le cas, alors nous voulons dire que le résultat est égal à 0. OK, cool. Donc, si num un est égal à 0, nous allons dire 0. Mais si ce n'est pas égal à 0, alors nous allons faire une autre opération ternaire ici. Donc, I est num un supérieur à 0. Nous voulons donc définir un résultat égal à positif et si rien n' est égal à négatif. Ensuite, nous mettons toutes ces parenthèses juste pour assurer que l'ordre des opérations était correct. Il a donc dit que num un égal à 0 si oui, alors nous avons dit 0. Si ce n'est pas le cas, nous voulions définir un résultat égal à ce qu'il y avait entre parenthèses que nous voulions faire pour l'ensemble de cette opération. abord, nous avons dit num un supérieur à 0 pour cette condition, si c'est le cas, nous commencerons par le positif. Si ce n'est pas le cas, nous le définirons sur négatif. Nous l'avons donc simplement placé entre ses propres parenthèses pour nous assurer que le résultat était égal au résultat complet de cette opération, n'est-ce pas ? Alors, vous l'avez. Vous savez maintenant comment utiliser l'opérateur ternaire. Personnellement, je ne l' utilise pas beaucoup, mais je l'ai vu dans une tonne de code d'autres programmeurs. Je voulais donc m' assurer de proposer ce cours pour que vous sachiez ce que c'était, ce que cela signifiait et comment cela fonctionne. Et qui sait. Personnellement, il se peut que vous l'aimiez vraiment et que vous souhaitiez l'utiliser vous-même. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 34. Chapitre 7 (Boucles) : Intro aux boucles: Dans cette vidéo, je vais juste vous donner une brève introduction aux boucles et à la programmation. Dans les prochaines vidéos, nous allons créer différents types de sauts qui nous sont propres. Donc, ici, j'ai la syntaxe de base ou une règle pour le fonctionnement d'une boucle. En gros, vous allez avoir une condition, et cette condition fonctionne la même manière que dans une instruction if. Donc, essentiellement, si cette condition est vraie, nous allons exécuter un certain bloc de code. Ensuite, une fois ce bloc de code exécuté, il va revérifier si cette condition est vraie. Et si c'est le cas, nous allons le refaire. Et il va continuer à le faire encore et encore et encore jusqu'à ce que notre état soit faux. Et puis, une fois que cette condition est fausse, elle sortira de la boucle et continuera à lire le code. Là-dedans, tu l'as. En gros, nous allons avoir la condition, et cette condition est vraie. Nous allons exécuter du code et continuerons à exécuter ce code jusqu'à ce que la condition soit fausse. J'espère donc que cela a du sens. Si ce n'est pas le cas, vous en verrez plusieurs exemples dans les prochaines vidéos. Donc, comme toujours, merci de m'avoir écouté, et à bientôt. 35. 34: Dans cette vidéo, nous allons parler de la boucle while, qui est probablement la boucle la plus basique que vous verrez. J'ai la syntaxe pour cela ici. Donc, ce que tu vas faire, c'est écrire correctement et tout en minuscules. Et puis entre parenthèses, vous allez mettre une condition que vous voulez vérifier pour voir si elle est vraie, alors ouah, cette condition est vraie. Vous allez faire tout ce que vous avez dans votre bloc de code ou entre crochets. Ensuite, il continuera à exécuter ce bloc de code jusqu'à ce que cette condition soit fausse. Alors allons-y et écrivons l'un des nôtres. Et je vais également parler de certains des problèmes que vous pourriez rencontrer si vous ne faites pas attention. Donc, pour l'instant, allons-y et créons un entier. Je vais appeler cet itérateur et le mettre à zéro. Alors, eh bien, cela créera notre boucle while. Alors on va dire, ouah. Et puis entre parenthèses, nous dirons que l'itérateur est inférieur à 100. Ensuite, placez cela entre crochets pour créer un bloc de code que nous voulons exécuter. Alors allons-y et disons quelque chose comme CL iterator. Alors en ligne. Maintenant, ne nous devancez pas et exécutez ce bloc de code car cela pourrait faire planter votre programme, sinon votre ordinateur et Jenna, et je vais vous expliquer pourquoi. Nous avons donc un itérateur int égal à zéro. Et puis nous avons dit, eh bien, notre itérateur est inférieur à 100. Nous voulons l'imprimer. Mais cette condition ne sera jamais fausse, non ? Donc, il va fonctionner , il va imprimer l'itérateur. Et puis il va dire, d'accord, revoyons notre état. La condition est toujours vraie. Faisons-le encore et encore et encore. Donc ce que nous devons faire, c'est faire en sorte notre condition soit fausse. Parce que si vous ne le faites pas, ce code s'exécutera à l'infini. Donc, en bas, nous allons le dire, itérateur plus, plus. Je vais mettre un point-virgule à la fin. Donc maintenant, notre itérateur va augmenter d'une unité à chaque fois que ce bloc de code s'exécute, puis il vérifiera la condition et continuera faire jusqu'à ce que l'itérateur soit égal à 100 car alors il ne sera plus inférieur à 100. Alors allez-y et exécutez le code. Comme vous pouvez le constater, il a immédiatement imprimé différentes lignes de code à partir de zéro jusqu'à 99. Et si nous voulions imprimer de un à 100, par exemple, nous pourrions simplement changer l'apparence de notre itérateur en un et faire cela soit inférieur ou égal à 100. Nous l'avons relancé, nous allons en imprimer un jusqu'à 100. Maintenant, une chose à noter est qu'il ne vérifiera à nouveau la condition qu'à la fin du bloc de code. Il exécutera donc tout ce qui se trouve à l'intérieur votre bloc chaque fois que cette condition est vraie, puis vérifiera à nouveau la condition. Et seulement une fois que cette condition est fausse, que vous pouvez sortir de là et continuer à lire votre code. Donc, par exemple , ici, nous avons dit C out, terminé, jeté une ligne N là-bas et réexécutons notre code. Vous pouvez voir que dès qu'il atteint 100, impression est terminée. Maintenant, je voudrais vous faire prendre conscience d'une autre chose, qui fonctionne aussi bien avec les déclarations que cela, parce que l'une est vraie, parce que ce n'est pas un héros. Essentiellement, en mettre un ici revient à dire vrai. Et mettre le zéro ici revient à dire faux. Donc, zéro est identique à faux, et un est identique à vrai. Tout, vous ne voudriez jamais le mettre tant que c'est vrai ici. Parce que même si cela est possible, vous ne pourrez pas faire en sorte que cela dise faux. Alors, tu y vas. Je sais comment créer et utiliser une boucle while. Et oui, tu peux. Vous aidez à y placer des boucles et des instructions if ou tout autre code que vous voulez. Donc, pour récapituler, pour créer une boucle while, vous allez simplement dire, eh bien, vous allez mettre une condition qui peut éventuellement devenir fausse et deviendra fausse dans le contexte de votre boucle. Donc, avant, nous avions un itérateur inférieur ou égal à 100, puis nous avions un moyen pour que cette condition devienne fausse si elle ne l'était pas déjà lors de notre première découverte du monde. Parce que si celui-ci est faux, il aurait été ignoré en premier lieu. Vous allez donc dire, entre parenthèses, que vous aurez une condition qui peut devenir fausse dans le contexte de votre boucle si elle ne l'est pas déjà. Enfin, vous aurez votre bloc de code. Ce que nous avons fait ici, où nous avions un itérateur à parcourir à chaque fois. Notre marque Loop est un moyen très courant de sortir d'une boucle à un moment donné. Maintenant, avant de terminer, examinons un autre cas d'utilisation pour cela. Passons donc au milieu de tout cela et nous dirons int response. Réglez cette valeur sur un. Et puis Dumbo, qui dira, wow, entre parenthèses, enverra une réponse qui n'est pas égale à zéro. Et puis entre crochets, dites C out. Veuillez prendre zéro et utiliser ce qui indiquera Voir en réponse. Nous créditons maintenant un lien appelé réponse et ce n est égal à un. Ensuite, nous avons dit qu'une réponse n' est pas égale à zéro, ce qui ne sera certainement pas la première fois. Nous allons imprimer, tapez zéro et appuyez sur Entrée. Et si l'utilisateur ne tape pas zéro, ce code s'exécutera à nouveau. Cependant, une fois qu'ils ont tapé zéro, indiqueront simplement terminé. Donc, si nous exécutons un programme, il va dire « Veuillez prendre zéro » et appuyer sur Entrée. Et nous pouvons prendre n'importe quel numéro et appuyer sur Entrée. Et il nous demandera de le refaire. Nous pouvons le faire pour toujours si nous le voulons. Sinon, si nous tapons zéro et que nous appuyons sur Entrée, le message est terminé, et c'est parti. n'est donc qu'un autre exemple de la façon dont nous aurions pu utiliser notre boucle while et en sortir sans utiliser d'itérateur. Maintenant, très rapidement, je tiens à clarifier quelque chose de très clair. Si nous étions là-haut, définissez une réponse égale à zéro, par exemple , dans notre condition de boucle while, ladite réponse est égale à un, cela fonctionnerait en fait pour toujours. Et cela s'explique par le fait que nous en attribuerions une à la réponse. Nous disons donc que la réponse est égale à un. Et à cause de cela, la boucle while considérerait cela comme ceci. Et comme nous le savons, cela revient à dire vrai. Donc, cela pourrait aussi bien dire : « Eh bien, c'est vrai ». Même si nous voulions dire vérifier si la réponse était égale à un. Ainsi, chaque fois que vous travaillez avec une condition , assurez-vous de ne jamais utiliser simplement l'opérateur d'affectation. Et vous dites toujours égal à en mettant deux signes égaux, car vous ne voulez certainement pas faire planter votre programme, surtout s'il s'agit d'un morceau de code sur lequel vous travaillez depuis longtemps et Je n'ai pas enregistré ou quelque chose comme ça. Cela peut être assez traumatisant. Je voulais juste te donner un aperçu à ce sujet. J'espère donc que vous savez maintenant comment écrire et utiliser une boucle while et que vous pouvez même penser à quelques exemples et à votre tête où cela serait utile. Quoi qu'il en soit, ce que je veux vraiment que vous fassiez c'est d'aller de l'avant et de sauvegarder ce que vous avez ici. Nous allons donc l'utiliser dans la prochaine vidéo lorsque nous parlerons d'une boucle do while. Donc, comme toujours, merci de m'avoir écouté, et à bientôt. 36. Chapitre 7 (Boucles) : faire pendant que les boucles: Dans cette vidéo, nous allons parler de ce qu'on appelle une boucle do while. Et si vous vous souvenez que dans la dernière vidéo, je vous ai demandé de sauvegarder tout ce que vous aviez. Cependant, si pour une raison quelconque vous ne l'avez pas fait, ne vous inquiétez pas. Allez-y et mettez la vidéo en pause. Copiez ce petit bout de code ici, et vous devriez être prêt à partir. J'ai donc la syntaxe de base pour une boucle do-while ici. Ça vaut le coup de savoir comment en écrire une. Vous allez le faire en minuscules. Ensuite, entre crochets, vous aurez votre bloc de code que vous souhaitez exécuter au moins une fois. Et il n'y aura qu'une seule course, quoi qu'il arrive. Après cela, vous allez dire, eh bien, comme nous l'avons fait par le passé, et puis entre parenthèses, vous aurez une condition. Si cette condition est vraie, votre bloc de code s' exécutera encore et encore jusqu'à ce que la condition soit fausse Vous aurez alors également besoin d'un point-virgule après cette condition. Donc, la principale différence entre une boucle do while et une boucle while autre que la façon dont elle est écrite votre bloc de code s'exécutera une seule fois quoi qu'il arrive. Ensuite, je ne répéterai que tant que la condition sera vraie. Très bien, alors allons-y et voyons comment le créer et en créer un pour nous-mêmes. Donc, ici, nous allons transformer notre boucle while en une boucle do-while, juste pour vous montrer à quel point elles sont réellement comparables. Donc, ici, nous allons dire « faire » en minuscules. Ensuite, nous allons supprimer notre bloc de code de notre boucle while précédente et placer devant le mot do. Et après un certain temps de boucle, nous allons simplement mettre un point-virgule comme ça. Et vous y voilà. Nous avons maintenant créé une boucle do while. Donc, ce qu'il va faire maintenant est de dire S'il vous plaît tapez 0 et appuyez sur Entrée. Ensuite, je vais laisser l'utilisateur entrer une réponse en tant que nous dans ce cas. Et puis, alors que la réponse n' est pas égale à 0, ils vont de l'avant et changent cela, il va continuer à se répéter. Et puis, une fois que nous aurons terminé , nous dirons Allons-y et changeons cela par quelque chose comme merci. Maintenant, si nous exécutons notre code, il va dire « Veuillez taper ici et appuyer sur Entrée pour obtenir la réponse ». Et tant que cette réponse n'est pas 0, elle va continuer à se répéter. Ce qui est a est 0, il dira merci. Donc, si nous exécutons notre code ici, vous pouvez voir qu'il dit s'il vous plaît tapez 0 et nous pouvons taper ce que nous voulons et continuer à appuyer sur Entrée et encore et encore et encore jusqu'à ce que nous saisissions réellement 0. Puis nous entrons, il dira merci, et c'est parti. Notez donc que ce code s'est exécuté même si la réponse était égale à 0 dans cette condition était fausse car la réponse était 0. Cela aurait seulement été vrai et ce n'était pas égal à 0. Donc, comme je l'ai dit, la seule différence entre une boucle while et une boucle do while est la syntaxe ou la façon dont vous allez l'écrire là-bas, et le fait que votre code s'exécutera une fois. Donc, quelle que soit la réponse précédente, ce code ne sera exécuté qu'une seule fois. Ensuite, il va vérifier que la réponse est 0 avant de sortir de ce code. Parce que nous avons dit que si la réponse n' est pas égale à 0, nous voulions continuer à exécuter ce code. Et voilà, vous l'avez. Vous savez maintenant comment créer une boucle do while. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 37. Chapitre 7 (Boucles) : Pour les boucles: Dans cette vidéo, nous allons voir comment créer et utiliser ce que l' on appelle une boucle for. J'ai la syntaxe de base pour vous ici. Donc, tout d'abord, vous allez économiser pour toutes les lettres minuscules, puis entre parenthèses, nous allons avoir différentes choses. Tout d'abord, il va y avoir une initialisation des variables. Et ne vous inquiétez pas, je vais vous montrer ce que je veux dire par là dans un instant. Ensuite, vous allez suivre cela par un point-virgule. Et ensuite, tu vas avoir une maladie. Let's Condition fonctionne comme dans n'importe quelle autre boucle. Ainsi, tant que la condition est vraie, votre code continuera à se répéter. Ensuite, vous allez avoir une mise à jour de variables, où vous mettrez à jour la variable que vous créez. Alors laissez-moi vous montrer quoi cela ressemble très rapidement. Je voulais vous faire savoir que tous ces éléments peuvent techniquement être supprimés d'une boucle pour sans aucune erreur, à condition de laisser les deux points-virgules dedans. Cependant, si vous n'avez pas la condition qui se situe au milieu, cela sera toujours considéré comme vrai. Et vous auriez une boucle infinie, ce que, comme je l'ai dit par le passé, vous voulez toujours éviter. Alors allons-y et créons une boucle pour contourner le problème. Et les femmes créent une boucle. En fait, nous allons essayer d'obtenir le même résultat que avec notre boucle while dans une vidéo précédente, où nous en avons imprimé une à 100 sur des lignes séparées. Juste pour que je puisse vous montrer les différences entre une boucle for et une boucle while. Alors éteignez, nous allons dire quatre. Et puis entre parenthèses, nous allons dire que int I est égal à 0, le point-virgule à la fin. Et voilà, vous l'avez. Juste là, notre toit d'initialisation des variables a été créé et initialisé une variable. Et tu peux le nommer comme tu veux. Vous pouvez également le définir comme vous le souhaitez, mais la plupart du temps, le définir à 0 et le voir appelé I est le plus courant étant l'abréviation d'itérateur. Et vous comprendrez pourquoi dans un instant. Ensuite, nous allons connaître notre état. Nous allons donc dire que je suis inférieur ou égal à 100. Je ne mets pas de point-virgule après ça. Et juste après cela, notre variable sera mise à jour partout où vous allez mettre à jour la valeur de notre variable. Disons que je suis en plus, en plus. Ensuite, nous aurons notre bloc de code à l'intérieur. Nous allons simplement imprimer, je dirais C0. Ensuite, nous allons créer une nouvelle ligne comme celle-ci. Et cette boucle est prête à être parcourue telle quelle. Alors allons-y et résumons ce qui se passe ici. Nous avons donc dit pour, pour déclarer que nous créons une boucle for. Et puis entre parenthèses, nous avons toutes les choses qui sont basiques pour la boucle Nous avons entendu parler de variable où nous avons dit int I égal à 0. Ensuite, nous mettons un point-virgule pour séparer cela de la condition, disons que je suis inférieur ou égal à 100. C'est la condition qui doit être remplie pour qu'une boucle for fonctionne en premier lieu. Et s'il veut continuer à fonctionner, cela doit continuer d'être vrai. Et puis après chaque exécution de notre code, il augmentera I d'un. Et nous aurions aussi pu simplement dire « I plus est égal à un ou « I égal à I plus un ». Ça n'a vraiment pas d'importance. C'est juste l'espace dont vous avez besoin pour mettre à jour votre variable. Donc, la plupart du temps, c'est ainsi que vous allez voir une boucle pour classée I égale à 0, I avec une condition et puis I plus, plus ou plus I. Comme je l'ai dit, je suis l' abréviation d'itérateur, mais vous Je peux l' appeler comme tu veux. Et puis, au lieu de le mettre en boucle, nous l' avons simplement imprimé. J'ai ensuite créé une nouvelle ligne. Et ce que cela va faire, c'est imprimer de 0 à 100. Mais si nous le changeons en un ici, je vais juste en imprimer 100. Alors allons-y et exécutons notre code. Et voilà, une de toutes les 100. Ainsi, lorsque vous créez une boucle for, vous allez normalement créer une sorte de variable avec laquelle travailler. Vous aurez la condition que vous voulez être remplie. Et si cette condition est remplie, elle sera exécutée dans votre code. Et puis, une fois qu'il aura parcouru votre code, il ira dans votre variable jusqu'ici, fera ce qu'on lui dit de faire. Donc, dans ce cas, nous avons dit I plus plus. Je vais donc augmenter d' un point parce que c'est ce que fait I plus plus, comme nous le savons par un point parce que c'est ce que fait I plus plus, le passé. Ensuite, après la mise à jour de cette variable, il vérifiera notre état. Encore une fois. Si notre condition n' est toujours pas remplie, il parcourra à nouveau ce bloc de code. Ensuite, une fois que cette condition est fausse, il continuera à utiliser notre code. Et nous le savons par le passé. Et si on le voulait, on pourrait dire C0, fait ici et une ligne comme ça. Et ce qu'il a fait, il sera imprimé. OK. Et si nous ne voulions pas l'augmenter d'un seul ? Comme je l'ai dit, tu sais, mets ce que tu veux ici. Mais c'est l'endroit que vous souhaitez avoir pour mettre à jour votre variable. On pourrait donc dire que je suis égal à 1 plus deux. Et nous y voilà. Et il va en imprimer un parce que notre état était vrai. Je trouve toujours qu'il en a imprimé un, puis qu'il l'a ajouté au I. J'avais donc trois ans maintenant. Cela fait toujours moins de 100 exemplaires imprimés, et ainsi de suite. Et si nous les modifiions en 0 ici, cela imprimerait essentiellement tous les nombres pairs. Donc, comme vous pouvez le voir, 24681012 et ainsi de suite. D'accord, alors quand utiliseriez-vous une boucle for au lieu d'une boucle while ? Eh bien, d'une part, une boucle pour est plus rapide qu'une boucle longue. De plus, vous voulez normalement utiliser une boucle for lorsque vous savez exactement combien de fois vous voulez parcourir une boucle, faisons quelque chose comme ceci. J'ai moins de dix ans. Nous allons l'imprimer et l' augmenter d'une unité. Maintenant, si on le passe en revue, il passera exactement dix fois. Nous avons donc obtenu 12345678910. Ainsi, lorsque vous savez combien fois vous souhaitez parcourir une boucle, vous utiliserez normalement une boucle for lorsque la condition selon laquelle vous devez être remplie pour arrêter de courir en direct. Comme c'est plus complexe, vous voudrez généralement utiliser une boucle while. Et puis, pour une boucle do-while, vous ne devez l'utiliser que lorsque vous savez un morceau de code s'exécute au moins une fois, puis que vous voulez qu'il se répète si une condition est remplie. Mais la plupart du temps, vous utiliserez probablement uniquement des boucles pour les boucles et des boucles while. Maintenant, pour terminer cette vidéo, je voudrais revenir rapidement à ce dont j'ai parlé plus tôt où j'ai dit que nous pouvions avoir une boucle pour comme celle-ci. Et cela sera tout à fait valable. Cependant, sans condition, il fonctionnera à l'infini. Mais cela étant dit, c'est valable et vous pouvez y mettre ce que vous voulez. Très vite, passons en revue un exemple de retrait de tout sauf de notre état de santé. Nous aurions donc pu dire int i. Ensuite, lors de l' initialisation de notre variable, nous pourrions simplement mettre i égal à 0, ou nous aurions pu le supprimer complètement et dire que I est égal à 0 ici et simplement ne pas avoir de initialisation de variables. Cependant, nous avons toujours besoin du point-virgule pour le séparer de la condition ici. Ensuite, nous avons indiqué l'intention d'iOS et nous pourrions même supprimer notre mise à jour variable. Pas de problème. Cependant, si nous le faisons , comme je l'ai dit, vous voulez toujours vous assurer qu' il existe un moyen pour que votre boucle s'arrête dans le domaine de votre boucle. Donc, à l'intérieur de notre boucle, nous aurions pu dire I plus code. Et comme vous pouvez le voir ici comme avant, aucun problème. Vous n'avez pas besoin de tout avoir dans la même ligne ici, et cela fonctionnera très bien. Assurez-vous simplement que vous avez encore un moyen de sortir de la boucle et que vous avez une variable avec laquelle vous pouvez réellement travailler. C'est pourquoi nous l'avons créé ici. Maintenant, je voulais juste te montrer que c'était possible. La plupart du temps, vous ne le ferez probablement pas, mais c'est une option. Et si vous voyez cela dans le code de quelqu'un d'autre, vous saurez pourquoi, vous saurez comment cela fonctionne, etc. Mais la plupart du temps, vous le ferez probablement comme nous le faisions auparavant. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 38. 37: Dans cette vidéo, nous allons parler de boucles d'imbrication. Et les boucles imbriquées sont fondamentalement le même concept que lorsque nous avons passé en revue et imbriqué des instructions. Il s'agit essentiellement d'une boucle dans une boucle. Et vous pouvez continuer à le faire encore et encore, comme vous le feriez avec ces déclarations ou quoi que ce soit d'autre. Alors allons-y et voyons comment cela pourrait fonctionner. Nous allons donc créer quelques boucles pour cet exemple. Donc, nous dirons que pour int, je suis égal à zéro I inférieur à dix, puis I plus plus. N'oubliez pas que c'est à peu près à que ressembleront toutes vos boucles de base. Bref, à l'intérieur d' ici, je vais dire CL. J'aime juste ça. Ensuite, en dessous, nous allons créer une autre boucle pour. Donc je vais dire que pour j est égal à zéro, j est inférieur à dix. J et plus. Et le bloc de code pour cela, je vais juste dire cl j. Et avant de lancer un code, supprimons la ligne M d'ici. Ou on a dit CRI et je vais y aller. Jetons donc un coup d'œil à ce qui s'est passé ici. Donc, nous avons d'abord imprimé zéro parce que c'est ce que j'étais. Et puis on saute dans notre autre pour la boucle. Et nous allons simplement l'appeler notre pronom j pour boucle. Il est également possible que vous entendiez parler de boucles appelées boucles intérieures et extérieures lorsque vous avez des boucles d'imbrication. abord imprimé I, c'était zéro, puis il l'imprime j, qui était également nul. Ensuite, J a été augmenté d'un. Donc j était égal à un, ce qui est toujours inférieur à dix. Il a donc imprimé à nouveau J sur une nouvelle ligne parce que nous avons cette ligne N ici. Et je le ressens jusqu'à neuf heures. Une fois que j'ai atteint neuf ans, Jay n'avait plus que dix ans. Il n'a donc pas imprimé à nouveau j. Ensuite, j'ai été augmenté d'un. Donc j'en étais un maintenant et ça l'imprime. Après cela, notre boucle for a démarré sur j étant égal à zéro. J est inférieur à dix. Imprime j, j vaut zéro et passe à nouveau jusqu'à neuf. Et j'ai continué à faire ceci et faire ceci et à faire cela jusqu'à ce que j'aie finalement neuf ans. Elle est repassée à zéro, les a imprimées jusqu'au bout. Et puis une fois que j'ai toujours atteint dix, ça s'est arrêté. Maintenant, si nous voulions que cela soit un peu plus beau, par exemple, nous aurions pu l'imprimer avec lui. Donc, en bas, allons-y et disons C out I. Ensuite, nous imprimerons j. Ensuite, allons-y et supprimons la CLI ici. Et maintenant, quand nous exécutons notre code, il va en fait dire 00 parce que i et j sont tous les deux nuls, puis zéro pour i , un pour j, zéro Froude pour j. Et il va continuer à le faire jusqu'à neuf . Je vais juste en imprimer un pour l'IA parce que IA va augmenter de 10 pour j et ainsi de suite. Et même si nous imprimons deux numéros différents, nous avons simplement imprimé zéro jusqu'à 99. Et une façon intéressante d'en imprimer 100 est à l'intérieur de notre boucle J4. Nous aurions pu dire que si I est égal à neuf et j est égal à neuf, alors nous voulons en sortir 100. Ensuite, si nous exécutons à nouveau notre code, vous pouvez voir que nous avons imprimé de zéro à 99, comme avant, sauf qu'une fois que j'étais égal à neuf et que j était égal à neuf, nous avons également imprimé 100. Alors, tu y vas. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 39. Chapitre 7 (Boucles) : les déclarations de rupture: Dans cette vidéo, nous allons parler de la déclaration de rupture. L'instruction break est quelque chose que vous avez déjà vu lorsque nous travaillions avec des commutateurs et que nous tapions quelque chose comme cette ligne de rupture avec un point-virgule. Maintenant, l'instruction break, comme vous pouvez le voir ici, ne peut être utilisée que dans une boucle ou un commutateur. Et nous avons déjà vu comment cela fonctionne au sein d'un switch. Aujourd'hui, je vais vous montrer comment l'utiliser avec des boucles. Maintenant, le tronc cérébral qu'il fait, c'est vous sortir automatiquement de la boucle, et il le fait instantanément et ne continue pas avec le reste du code. Alors allons-y et voyons comment cela fonctionne. Donc, ici, nous allons commencer et créer un entier. Nous allons simplement l'appeler i et le mettre à 0. Ensuite, en dessous, nous allons créer une boucle while infinie. Maintenant, je sais que je l'ai dit, normalement, vous ne voulez pas créer une boucle infinie parce que vous n'en sortirez jamais. Mais avec une déclaration de rupture, vous pouvez vraiment le faire. Je vais donc vous montrer comment cela fonctionne dès maintenant. Nous allons donc dire « wow ». Et puis à l'intérieur de cela, nous allons dire vrai et créer un bloc de code. Donc, pour l'instant, cette boucle fonctionnerait à l'infini, mais nous allons en fait faire en sorte de pouvoir en sortir. Et à l'intérieur, nous allons dire « je plus », plus », juste comme ça. dessous, nous allons créer une instruction if. Je vais dire que je suis égal à dix. Ensuite, nous voulons sortir de la boucle. Et vous allez juste dire break et tout minuscules avec un point-virgule à la fin. Et cela nous permettra de sortir de la boucle. Ok, donc ici, on va dire CL loop. Juste comme ça. Notez également que j'ai mis notre itérateur étant moi, dans ce cas, en dehors de notre boucle. Et l'opérateur final est essentiellement quelque chose que vous utilisez pour itérer dans une boucle x fois. Donc, si nous voulions le mettre ici à la place, ce serait à l'infini car chaque fois que nous parcourons une boucle, j'aurais été créé et mis à 0. J'aurais été augmenté d'une main, cela n'aurait jamais été égal à dix. Et cela se produira encore et encore et encore. Mais si nous la plaçons à l'envers de notre boucle, cette variable est stockée et enregistrée en dehors de la boucle. N'oubliez pas que nous l'augmentons d' une unité la prochaine fois dans la boucle, elle augmentera d'une unité. Encore une fois, un peu comme quand nous avons mis cet intérieur pour boucle et que nous l'avons retiré. Alors, que va-t-il se passer ? Nous allons créer un entier appelé i, lui donner la valeur 0. Ce sera notre itérateur pour notre prochain live. Ensuite, nous avons créé une boucle infinie quand nous avons dit : « Eh bien, c'est vrai. Mais chaque fois que nous traversons une boucle, nous allons augmenter d'un point. Donc, ça va commencer à 0 et aller à 1234, etc. Ensuite, une fois que je serai égal à dix, nous aurons cette déclaration de rupture ici pour nous sortir de la boucle. Et puis en dessous, veux vraiment imprimer, j'aime bien ça. Et nous mettrons en place une nouvelle ligne à chaque fois. Et je vais vous montrer pourquoi dans une seconde. Maintenant, allons-y et exécutons notre code. Comme vous pouvez le voir, nous sommes passés au 123456789, mais nous n'en avons pas imprimé dix. Une fois. J'étais égal à dix d' entre nous en l'augmentant d'un, juste ici, cela a vérifié dans notre déclaration if. J'ai dit oui, puis cela nous en a fait sortir et n'a pas continué avec le reste du code et notre boucle, nous en sommes immédiatement sortis dès qu'il atteint cette instruction de rupture et que cela continue avec le code. C'est pourquoi nous n'en avons pas imprimé dix. Alors, vous l' avez. Vous savez maintenant comment utiliser l'instruction break. En gros, vous allez juste faire une pause , lancer un point-virgule, et cela vous fera sortir d'une boucle ou un bloc de code lorsque vous l'utilisez avec des commutateurs, comme nous l'avons vu par le passé. Et c'est essentiellement la seule façon de vous sortir d'une boucle infinie, comme vous le voyez ici. Mais vous pouvez l'utiliser d'autres manières et pas seulement dans des boucles infinies, non ? Nous aurions pu simplement dire que si j'avais moins de 100 ans, cela aurait été répété 100 fois et arrêté. Mais une fois que nous aurons atteint dix, ou que nous aurons réglé ça à environ 30, ça ira de l'avant et nous expulsera de toute façon. Donc, comme vous pouvez le voir, une fois que nous avons reçu le 30, il nous a virés et nous n'avons pas pris la peine de l'imprimer. C'est ainsi que vous pouvez utiliser l'instruction break pour vous sortir de la boucle plus tôt. Il existe plusieurs raisons pour lesquelles vous pourriez avoir envie de le faire. Ici, cela semble évidemment un peu redondant, mais vous pouvez faire une boucle un certain nombre de fois jusqu'à ce qu' une certaine condition soit remplie, puis continuer et en sortir immédiatement et là. Et pour vous montrer un exemple, nous aurions pu dire chaîne de mots de passe et lui attribuer la valeur de, nous allons la définir comme nulle pour l'instant. Et puis à l'intérieur, nous aurions pu dire : « Eh bien, mot de passe n'est pas égal à. Ensuite, nous allons simplement dire le mot de passe 123 parce que nous avons le mot de passe le plus sécurisé au monde, le droit. Et puis ici, nous allons dire le mot de passe cin, juste comme ça. Et ensuite, si le mot de passe est égal à, disons simplement stop. Allons-y et changeons cela pour sortir. Nous allons aller de l' avant et sortir de la boucle. Donc, bien que le mot de passe ne soit pas égal au mot de passe 123, nous allons continuer à demander un mot de passe. Et vous pouvez réellement faire ici, en disant, s'il vous plaît, tapez le bon mot de passe. Juste comme ça. Ensuite, nous vous demanderons un mot de passe. S'ils l'ont mis dans le bon mot de passe ici, je dirais. Et allons-y et réduisons cela. Et dans notre boucle, nous dirons que le mot de passe est égal à. Ensuite, nous allons dire mot de passe. 123, nous allons vous dire félicitations. Sinon, si le mot de passe est égal à exit, nous irons de l'avant et nous en sortirons. Et je vais continuer et imprimer la sortie. Dira quelque chose comme sortir ou sortir. Maintenant, évidemment, ce n'est pas parfait. Nous n'avons rien trouvé après cela, mais ce n'est qu' un exemple de la façon dont vous pourriez utiliser une boucle while et pourquoi vous pourriez avoir d'une instruction break pour d'autres options. Alors allez-y et lancez-le. Maintenant, il va demander un mot de passe. Je peux taper ce que je veux qui sera enregistré dans la chaîne. Si ce n'est pas le mot de passe. Ça va juste continuer à me dire que si on et exit, ça dira « sorti », et c'est parti. Maintenant, si je le lance à nouveau et que je prends le mot de passe 123, je vais vous dire félicitations. Et si nous voulions donner à l'utilisateur un nombre limité de tentatives ? Eh bien, après avoir fait cela et vérifié si le mot de passe était égal à 123, nous pourrions même ajouter une autre pause. Si nous le voulons ici, nous dirons que le mot de passe est correct. Ensuite, nous dirons « oui » et ensuite nous essaierons. Mot de passe incorrect. Tentatives. Et puis, à l'extérieur de notre lèvre, il y aura un vide. Réglez-le à. Donc, en fait nous allons aller de l'avant et le fixer à, accord, parce que je ne veux pas qu'ils fassent un certain nombre de tentatives. Et puis en bas, juste en dessous d'elle, juste au-dessus de notre ligne CL, on dira I moins moins, puis on met un point-virgule. Il va donc voir en quoi le mot de passe est incorrect. Ensuite, je vais imprimer mes essais, non ? Commençons donc par cinq. Ne fais pas les choses correctement. Je dirais que mot de passe est incorrect pour les tentatives à gauche, au centre, à droite ? Alors allez-y et exécutez notre code. Nous avons pris quelque chose, disons que mot de passe est incorrect pour les tentatives restantes, veuillez saisir le mot de passe correct, 3210. Et malheureusement, ça va continuer à devenir négatif à moins que nous ne fassions quelque chose pour y remédier. Donc, ici, nous pouvons dire que si I est égal à 0, vous devez vous imprimer dans breakout plus tôt, comme ça. Ensuite, allons-y et créons une nouvelle ligne pour qu'elle nettoie un peu mieux notre code en cas d'échec. C'est juste ici. S'il vous plaît, pour que le mot de passe correct soit saisi dans une erreur. Serveurs incorrects. Il vous reste quatre fois, il vous reste trois thèmes à dix fois. Jeunesse, Ben, enfermé , et voilà. Nous avons maintenant créé une idée très basique pour un programme de mots de passe. J'espère donc que vous avez une bonne idée de ce qui les casse et de la façon de les utiliser. Et peut-être avez-vous maintenant quelques idées pour l'utiliser. J'espère donc que vous avez apprécié la vidéo comme toujours, merci de l'avoir regardée , et à bientôt dans la prochaine. 40. Chapitre 7 (Boucles) : poursuivre les déclarations: Dans cette vidéo, nous allons jeter un œil à la déclaration continue. Maintenant, comme l'instruction break dont nous avons parlé dans la dernière vidéo, l'instruction continue est également utilisée lorsque vous travaillez avec des boucles. Alors allons-y et voyons comment cela fonctionne. abord, nous allons créer une boucle pour. Nous allons donc dire que pour int I, mettez-le à 0. Alors s'il y en a moins de dix, en plus, en plus, juste comme ça. Ensuite, à l'intérieur de notre boucle, nous allons l' imprimer. Donc, nous allons dire que je crée une nouvelle ligne par la suite, comme ça. Ensuite, au-dessus de notre instruction c out, allons-y et créons une instruction if. Nous allons donc dire qu'il est égal à. Et allons-y et mettons quelque chose comme cinq ici. Ensuite, nous voulons faire ce qui suit. Nous allons le faire, c'est mettre dans la déclaration de suite. Nous allons donc dire «  continuez », tout en minuscules. Et cela permet d'ignorer l'itération en cours d'une boucle. Et je vais également vous montrer comment cela fonctionne et aussi une boucle temporelle. Alors, que va-t-il se passer ici ? Eh bien, si nous n'avions pas cette déclaration if, nous savons que nous imprimerions normalement de 0 à 9, mais comme nous l' avons ici, dès que je suis égal à cinq, elle lira ceci continuer déclaration. Nous allons simplement sauter tout le reste par la suite. Mais contrairement à une instruction break, qui nous mettrait complètement hors de portée, ce qui va se passer à la place, car elle va monter ici et lire notre mise à jour de variables. Il va donc mettre à jour I par un dans ce cas. Ensuite, il va vérifier à nouveau l'état , puis continuer. Donc, ce qui va se passer, c'est que nous allons imprimer de 0 4, puis passer au sexe et ainsi de suite. Et si nous exécutons notre code ici, vous pouvez voir que c' est ce qui s'est passé. Il a donc imprimé 01234. Ensuite, une fois que j'ai eu cinq ans, je continue. Ensuite, je suis allé de l'avant, je ici à notre mise à jour des variables, l'ai lue une par une. J'avais donc six ans, puis ça a continué comme d'habitude. Alors, tu y vas. C'est ainsi que fonctionne l'instruction continue dans une boucle pour. Très rapidement, d'ailleurs, avec l'instruction continue et l'instruction break, si vous avez une boucle imbriquée. Supposons que nous ayons eu une autre boucle en dehors de celle-ci. Donc, si nous avions quelque chose comme ça, maintenant, vous n'avez pas à le copier ici. J'essaie juste de vous montrer à quoi je fais référence. Mais en gros, si vous avez une boucle imbriquée ici, votre instruction continue et/ou votre instruction break affecteront uniquement la boucle en tant que telle. Et donc cela affecterait simplement cette boucle et non la boucle extérieure. Et si c'était une déclaration de rupture, cela ne ferait que nous sortir de la boucle intérieure et non de la boucle extérieure. Donc, si j'imprime, j'aime bien ça et j'imprime j. Je reçois ma nouvelle ligne ici et j'exécute mon code. Donc maintenant, si vous regardez notre code ici, vous pouvez voir que nous avons imprimé 0 pour r I, puis pour la variable J, nous sommes passés à 01234, passés à l' itération suivante de notre boucle, qui a augmenté j d'un dans ce cas, puis a continué. Et il l'a fait à chaque fois grâce à notre déclaration continue. Et comment pouvons-nous faire une déclaration de rupture ici, comme nous l'avons utilisé dans la dernière vidéo et exécuter notre code. Vous pouvez voir qu'il ne sort que de la boucle actuelle. Nous ne passons donc que de 0 à quatre avec notre variable j, et elle continue de le faire à chaque fois. Alors, tu y vas. Alors, comment poursuit-il l' énoncé des travaux, la boucle while ? Eh bien, cela fonctionne exactement de la même manière sauf que nous n'avons pas de mise à jour variable. Donc, si c'est quelque chose comme int, je suis égal à 0 ici. Et puis dans notre boucle while, nous avons dit que tant que j'ai moins de dix ans et qu'à l'intérieur de notre bloc de code, nous allions simplement imprimer Je crée une nouvelle ligne. Ensuite, nous voulons aussi nous assurer d'avoir un moyen de sortir de cette boucle, n'est-ce pas ? Je ne veux pas que ça dure éternellement. Alors dis « je plus », « plus » comme ça. Donc, sans qu'on y fasse quoi que ce soit, nous savons qu'il va imprimer un code de un à dix degrés Fahrenheit ici. Nous pouvons voir que c'est le cas. Mais que se passerait-il si nous ajoutions notre déclaration continue ? Donc, si nous disons si je suis égal à cinq, encore une fois, faites attention à ce que cela soit égal à. Et puis ici, nous allons simplement dire « continuez ». Comme ça. Une fois que nous aurons atteint notre déclaration continue ici, cela ne fera que revérifier l'état et ne rien faire de plus. Et c'est une autre raison pour laquelle nous voudrions que I plus ou notre itérateur soit ici avant le maintien. Parce que si c'était après, comme ça, d'abord, il passerait à travers, augmenterait ça d'un. Disons un, imprimez-le et continuez à le faire jusqu'à mes cinq ans. Maintenant, une fois que j'avais cinq ans, cela continuait et vérifiait à nouveau notre état. Et cinq, c'est moins de dix. Donc, pour recommencer et continuer à courir et à courir et à courir pour toujours. Nous voulons donc nous assurer que la cause fin de notre boucle while se produise avant cela, moins dans ces cas, afin de ne pas créer une boucle infinie qui bloque notre programme. Donc, si je lance le code ici, vous pouvez voir que nous avons imprimé 1234. Une fois que nous avons atteint F5, nous continuons et restituons la condition six. Ce n'est donc plus égal à cinq, puis il a continué à s' imprimer. Alors, tu y vas. Vous savez maintenant comment créer et utiliser l'instruction continue. Et n'oubliez pas qu'il ne fait que sauter l'itération en cours de la boucle. Et avec une boucle temporelle, ça va juste revérifier l'état. Et avec une boucle for, si vous avez une mise à jour variable dedans, elle le fera d'abord et vérifiera votre état de toute façon, c'est tout pour cette vidéo. Comme toujours, merci de m'avoir écouté et je vous verrai dans la prochaine. 41. Chapitre 7 (Boucles) : valider l'intrant des utilisateurs: Dans cette vidéo, je vais vous montrer comment nous pouvons réellement valider les entrées des utilisateurs. Jusqu'à présent, dans ce cours, nous nous sommes simplement assurés saisir les bonnes valeurs. Ainsi, par exemple, si l'un des utilisateurs ou nous-mêmes, dans ces cas, pour saisir un entier, nous avons simplement saisi un nombre entier. Mais si nous devions vraiment taper quelque chose comme « bonjour », nous rencontrerions des problèmes. Maintenant, selon le type de programme qu'elle va créer, cela peut ou non être un problème pour vous, car vous n'aurez peut-être jamais besoin de saisir entrées utilisateur aléatoires dont vous avez besoin pour vous assurer qu'elles sont correctes. Mais je veux vous montrer comment cela se fait au cas où vous en auriez besoin, ou au cas où vous voudriez l'implémenter dans des programmes que vous pourriez bien créer, essayant d'apprendre et de comprendre le langage. Et juste pour que vous l'ayez à votre disposition et que vous puissiez reconnaître si vous le voyez dans le code de quelqu'un d'autre. Maintenant, juste un petit avertissement, je ne l'utiliserai probablement pas du tout pendant le reste de ce cours. Cette vidéo ne sera là qu'à titre de référence et pour que vous puissiez apprendre à le faire, utilisez Choose. est la principale raison de cela. Nous le serons simplement à cause de la complexité supplémentaire, mais j'ai l'impression que cela ajoute au code. Et personnellement, je ne l'utilise pas beaucoup dans le code que je crée en utilisant C plus plus. Et laissez-nous simplement parce que je travaille habituellement le développement de jeux et que les utilisateurs ne se contentent pas de taper des choses au hasard pour remplir une variable. Mais parce que nous travaillons avec une application console et demandons à l'utilisateur de saisir ce qu'il veut pour remplir une variable. Je pense qu'il est juste pertinent de vous apprendre comment cela fonctionne. Désolée pour cette petite diatribe, mais allons-y et commençons. Donc, tout d'abord, nous allons aller de l'avant et dire que j'aime bien ça. Ensuite, nous allons créer une boucle while infinie pour obtenir les commentaires des utilisateurs. Alors on va dire « wow ». Et puis à l'intérieur d'ici, nous dirons simplement vrai. N'oubliez pas qu'une autre façon de créer une boucle infinie est de créer une boucle for comme celle-ci et de le faire ensuite. Et c'est ce que nous faisons pour toujours parce qu'il n'y a aucune condition là-dedans. Et cela supposera simplement que la condition est essentiellement vraie. Mais j'aime utiliser le Wiley personnellement parce que je trouve qu'il est un peu plus lisible qu'un circuit vide à quatre boucles. Nous allons donc procéder et demander à l'utilisateur de saisir un chiffre. Nous allons donc dire C, veuillez saisir un nombre entier. Nous allons faire l'espace entre les deux points comme ça. Et ensuite, en dessous, nous allons créer une instruction if. Nous allons donc voir comme ça. Maintenant, nous allons saisir un tas de code qui n'aura aucun sens pour vous. Mais pour l'instant, allez-y, suivez et je vais passer en revue tout cela avec vous à la fin et essayer de le rendre aussi facile à comprendre que possible. Très bien, désolée, ici, nous allons dire pause comme ça. Je vais donc faire une déclaration de rupture. Et puis ci-dessous, nous allons dire autre chose. Ensuite, dans le bloc de code de notre instruction else, nous allons continuer et enregistrer ce qui suit. Nous allons dire « C ». Cette entrée était valide, veuillez saisir un espace numérique. Et puis Dumbo que nous allons dire cn point Clear, puis ouvrir et fermer des parenthèses, puis un point-virgule. Ensuite, en dessous, nous allons dire c m point ignorer. Et puis entre parenthèses, nous allons dire numérique. Tout en minuscules, d'ailleurs, le trait soulignement limite le symbole inférieur à la taille du flux. Un seul mot, en minuscules. Et puis le symbole supérieur à suivi de deux deux-points. Voilà, je vais dire max, tous les espaces entre minuscules, entre parenthèses ouvertes et fermées. Ensuite, nous allons mettre un guillemet simple comme celui-ci, barre oblique inverse, suivi un autre guillemet ou de parenthèses fermantes, puis d'un point-virgule à la fin. Et c'est tout ce dont nous avons besoin pour valider. Personnellement, notre contribution est un peu importante , mais c'est la façon de procéder en C plus plus. Alors allons-y. Donc, juste en haut, nous avons dit, s'il vous plaît, tapez un nombre entier. Ensuite, ici, nous avons dit si CNI, donc qu'est-ce que cela va réellement faire, c'est prendre entrée comme d'habitude et ensuite la mettre en haut. Et si l'opération fonctionne, cela redeviendra vrai. Ensuite, il va entrer dans le bloc de code artistique ici, ce qui va nous sortir de la boucle car nous avons finalement obtenu l' entrée que nous recherchions. Cependant, si cette opération échoue, nous avons notre autre déclaration ici pour nous couvrir. Nous disons donc à l'utilisateur : « Hé, cette entrée n'est pas valide, veuillez saisir un nombre entier. Ensuite, nous avons dit « cn point clear » en tant que méthode pour clarifier les choses qui se seraient dégagées en essayant de mettre tout ce que l'utilisateur avait saisi dans I. Ce n'était pas un nombre entier. . Très bien, c'est en gros la façon la plus simple de penser à cette méthode, car nous ne faisons que clarifier les choses qui se seraient produites lorsque l'utilisateur aurait essayé de mettre le mauvais type de données dans I. Un petit commentaire ici, clair pour essayer de saisir le type de données incorrect dans notre entier. Et je vais juste dire variable. Alors voyez, vous savez, que cela fonctionnerait avec n'importe quel autre type de données en gros. Ensuite, ici, nous avons dit cin.ignore. Ensuite, vous entrez essentiellement le nombre de caractères que vous souhaitez ignorer. Et donc tout cela ici, jusqu'à ce que ce maximum indique en gros que nous voulons ignorer le nombre maximum de caractères qui ont été saisis jusqu' à ce caractère de barre oblique inverse. Maintenant, la raison pour laquelle nous ignorons tout. Jusqu'au nouveau caractère de ligne, qui dans ce cas serait lorsque l'utilisateur a tapé «  enter », car nous savons qu'à la fin de ce que l'utilisateur a décidé de saisir, disons qu'il a saisi un livre de mots entier. Lorsque nous leur demandons de taper un nombre entier, que notre programme est ici, il ignorera tout ce qu'ils viennent de taper. Parce qu'à la fin de tout ce qu'ils ont tapé, ils appuient sur la touche Entrée, qui est identique à un nouveau caractère de ligne. Ignorez tout jusqu' à la nouvelle ligne de caractère. Entrez. Maintenant, pourquoi avons-nous fait cela ? Eh bien, tout d'abord, nous avons effacé l'erreur survenue par l'utilisateur lors de la saisie d' type de données incorrect dans une variable. Ensuite, si nous avions parcouru à nouveau notre boucle sans cette ligne de code ici, nous aurions simplement eu exactement la même erreur et cela ne fonctionnerait jamais et nous serions simplement coincés là-dedans boucle. En gros, ce que nous avons fait c'est dire à notre programme, Hé, ignorez simplement tout ce qui n'était que du type, nous allons repartir à zéro. Donc, en ignorant l' air et en demandant à notre programme d'ignorer tout ce qui était serré, nous repartons de zéro. Très bien, alors j'espère que c'est logique. De plus, une autre chose que je tiens à mentionner rapidement , car chaque fois que vous travaillez avec quelque chose comme ça, cela pourrait provoquer une boucle infinie, comme toute sorte de pause dans votre programme lorsque vous utilisez un boucle infinie. Eh bien, la plupart du temps, soyez une bonne solution de sécurité pour le crash de votre programme. Mais je dirais toujours, juste pour m'assurer que nous en avons déjà vu beaucoup auparavant. La seule différence est que vous savez maintenant que vous pouvez saisir quelque chose comme ça. Nous pouvons donc dire CAN suivi d'une variable comme nous l'avons fait par le passé. Et cela retournera vrai ou faux selon que cela a fonctionné ou non. OK, et puis ici, nous avons notre déclaration de rupture que nous avons vue dans le passé qui nous permettra de sortir complètement de cette boucle. C'est ainsi que nous pouvons sortir de notre boucle infinie. Et en bas, nous avons ceci juste ici qui dit simplement, hé, votre entrée n'était pas valide si cela renvoyait faux. Ensuite, nous avons ces deux lignes de code qui nous permettent de faire table rase. Alors allons-y et exécutons notre programme. Et il a demandé un chiffre entier. Et je vais juste prendre quelque chose comme un bonjour. Et remarquez que notre programme ne s'est pas écrasé, qu'il n'a pas rencontré d' erreurs insensées. Et en fait, juste pour vous montrer une dernière chose ici dans notre déclaration if, allons-y et imprimons-la. Je vais créer une nouvelle ligne comme celle-ci. Faisons de même à l'intérieur de notre bloc de code else ici. Regardez dans la file d'attente pour que vous sachiez que nous pouvons les utiliser pour le mois d'avril et que nous n'avons aucune erreur. OK ? Je peux donc taper ce qu'ils veulent et entrer et cela ne posera aucun problème. J'ai imprimé, je connais le problème. Et juste pour être sûr, même si ce message mort imprime 0, je recommande de l'initialiser ici. Personnellement, je vous recommande de faire attention à la valeur initiale avant de faire quelque chose comme ça. Mais comme vous l'avez vu, cela a fonctionné, il a imprimé 0 dans ce cas. Mais en général, pour être sûr, c'est quelque chose que je recommande. OK. Vous pouvez donc taper ce que vous voulez. Et après cela, vous pouvez voir que nous avons imprimé Je sers, ils utilisent l'IA, pas de problème. Et ici, nous avons dit qu' ils imposent le valide, s'il vous plaît, dites le nombre entier. Et si nous avions voulu nettoyer tout cela, nous aurions pu faire ce qui suit. On peut juste retirer notre C. Veuillez prendre le numéro et le mettre ici en dehors de notre boucle. Et cela fonctionnera très bien. Donc, là-bas, tout ce que nous voulons. Nous pouvons continuer à le faire autant que nous le voulons car nous avons une boucle infinie. Voici un bon exemple de cas où une boucle infinie est utile lorsque nous essayons d' obtenir des informations de ce type. Et nous ne savons vraiment pas quand nous allons vouloir que cela cesse. Maintenant, d'accord, c' est un infini, c'est un bon exemple de cas où vous voudriez utiliser une boucle while plutôt qu'une boucle for lorsque la condition que vous voulez être remplie est plus compliquée et que vous ne connaissez pas le nombre exact de fois que vous voulez parcourir la boucle, n'est-ce pas ? Parce que normalement, avec une boucle pour, vous allez dire que lorsque notre itérateur ou beaucoup de température à laquelle vous êtes habitué dans le passé tant que raccourci pour itérateur, est inférieur ou supérieur à un certain nombre ou quelque chose comme ça. Quoi qu'il en soit, si nous saisissons un nombre entier comme nous l'avons demandé, imprimerons et nous sortirons de notre boucle et nous serons tous prêts à partir. Mais il existe un autre moyen de le faire. Donc, si vous dites quelque chose comme CAN, ici, bas dans l'instruction if, pouvez réellement dire c n point fail. Cependant, pour notre bloc de code dessiné ici, nous voulons vraiment voir s'il n'a pas échoué. Nous pourrions simplement dire, sinon échouer comme ça. Et si nous exécutions notre code. Vous pouvez voir que cela fonctionne de la même manière qu'auparavant. Et si je tape un nombre entier, BAM, ça nous met à la porte. Juste comme ça. Tout est prêt à partir. Alors, tu y vas. Vous pouvez également utiliser la méthode CN point fail pour voir si cette opération a échoué ou non. Donc, si nous ne voulions pas faire cela, coupez-le simplement ici, collez-le ci-dessous, coupez-nous tous ici, mettez-le dans une instruction if et supprimez-le. Et cela fonctionnerait très bien tant que nous mettions une déclaration continue ici, n'est-ce pas ? Donc, chaque fois que cela échouait, nous sautons simplement la condition de backchecker, qui est vraie et exécutée. Et si ça n'échouait pas, eh bien, nous en sortirions. Donc, pour mon code, encore une fois, voyons si nous prenons quelque chose. Je vais juste y aller. Répéter. Mais nous sommes toujours au courant, non ? Parce que nous voyons juste que ce noir contient une déclaration dont nous avons parlé dans une vidéo précédente pour revenir en arrière, vérifier son état et sauter le reste du code. Mais si nous saisissons réellement un chiffre, vous y voilà. Débarrasse-le comme on pouvait s'y attendre. Maintenant, très rapidement pour ceux d'entre vous qui se demandent, comme nous avons vu le flux de mots à plusieurs reprises, nous avons reçu du code à partir du fichier d'en-tête iostream. Nous parlons ici de la taille du flux. Si je passe la souris sur C n et C out, ils proviennent tous de ce fichier de flux. Alors, qu'est-ce qu'une chaîne ? Et ne vous inquiétez pas, vous n'avez pas vraiment besoin de bien comprendre cela pour ce cours. Je voulais juste te dire ce que c'est. Maintenant, en gros, en C plus, plus, un flux est juste un flux de caractères qui sont transférés entre le programme et la sortie d'entrée. Ainsi, notre sortie C et notre C n sont ce que nous utilisons pour interagir avec l'entrée et la sortie. Et lorsque nous avons cela ici, c'est essentiellement notre flux. Ce sont nos personnages qui sont transférés entre les programmes. Et comme nous le savons, ils ne sont transférés vers le programme que lorsque nous appuyons sur Entrée et sur tout ce texte ici, la fois la sortie du code R et l'entrée de notre part. Le personnage est donc transféré entre notre programme et l'utilisateur fait partie de ce flux d'entrée et de sortie. Donc, quand nous avons dit « Hey », nous voulons que notre programme ignore la taille du flux bancaire des caractères, du type ou qu'il dise tout ce qu'ils auraient pu saisir dans notre console ici, allez-y et ignorez-le. C'est ainsi que nous avons commencé sur une table rase. Nous n'avons pas à nous inquiéter de la réapparition de l'erreur, etc. C'est à peu près ça. C'est ainsi que vous validez la saisie de l'utilisateur essentiellement avec ces deux lignes ici. Et en veillant à ce que l'entrée soit acceptée. Quoi qu'il en soit, laisse tomber la vidéo. Je vais juste récapituler rapidement tout ce dont nous venons de parler. Il y avait une nouveauté dans cette vidéo. Donc, tout d'abord, nous savons que nous pouvons utiliser notre instruction CN ici directement dans une condition et qu'elle renverra «  vrai » si l'insertion de ce que l'utilisateur a saisi dans la variable a réussi et « faux ». sinon, nous avons également découvert la méthode de remplissage des sièges et des points, qui retournera vrai si cette opération échoue et faux dans le cas contraire, puis nous avons découvert ces deux méthodes ici. Et rappelez-vous simplement que le point cn clear ici efface simplement l'erreur qui survient lorsque l'utilisateur essaie de saisir des données incorrectes dans la variable. Ensuite, nous avons la méthode cin.ignore, qui ignore essentiellement le nombre de caractères que nous lui demandons jusqu'à ce que nous lui demandions de s'arrêter, qui correspond dans ce cas tout ce que l'utilisateur dactylographié. Et c'est juste pour empêcher l'air de revenir tout de suite. Très bien, alors j'espère que ce n'est pas trop compliqué. Comme je l'ai dit, je ne l' utiliserai pas beaucoup tout au long du cours, car je crois que c'est beaucoup de code qui alambique un peu les vidéos sur un sujet spécifique. Mais dans les cas où j' ai un programme complet, je vais le lancer juste pour vous montrer que c'est quelque chose que nous devrions faire si nous demandions l'avis des utilisateurs et pour vous rappeler comment pour le faire et quand. tout cas, j'espère que vous avez apprécié la vidéo. Merci de m'avoir écouté , et à bientôt. 42. Chapitre 7 (boucles) : Opérateur de résolution: Dans cette vidéo, je vais vous parler de l' opérateur de résolution de portée et de ce qu' est cet opérateur pour accéder à une variable globale portant le même nom, une variable locale. Donc, d'une manière générale, je ne vous recommande pas avoir deux variables du même nom. Mais dans les rares cas où vous l'avez pour une raison quelconque, je vais vous montrer comment vous pouvez accéder à la globale et à la variable locale séparément. Mais d'une manière générale, je ne le recommande pas et je recommande d'avoir des noms de variables plus spécifiques. Ainsi, vous savez toujours exactement avec quoi vous travailliez. Parce que même si nous avons vu des choses comme int x, par exemple, si j' utilisais ceci, le graphique, le score dans un match de football, je voudrais appeler ce score et non quelque chose de générique comme celui-ci, où je ne vais pas savoir ce que contient cette variable. Très bien, alors allons-y et voyons comment utiliser l'opérateur de résolution de la lunette. Donc, tout d'abord, normalement, si nous avons deux variables du même nom comme celle-ci et que nous essayons d'exécuter notre code, nous allons obtenir une erreur. Et c'est parce que vous avez deux variables portant le même nom. Et si vous regardez en bas, j'ai en fait une erreur qui indique la redéfinition de int x. J'ai essayé de trouver la même variable deux fois. Cependant, il vous permettra d'avoir deux variables du même nom. Si, par exemple, l'un est global et l'autre local. Et comme vous pouvez le voir, si j'essaie d'exécuter mon code maintenant, il fonctionne très bien et nous n'y sommes pas arrivés. Maintenant, et si je voulais accéder à cette variable via cette variable ou vice versa ? Alors allons-y et séparons-les avec une sorte de valeur afin voir à laquelle nous accédons. Cette valeur est à dix, et je vais lui donner une variable locale, une valeur de cinq. Ensuite, nous allons commencer et dire x, juste comme ça, et exécuter notre code. Et comme vous pouvez le voir, il en imprime cinq. Et c'est parce que par défaut, vous accéderez à la variable locale. Mais avec l'opérateur de résolution de portée, vous pouvez accéder à la variable globale. Donc, s'ils le voient à nouveau, comme nous l'avons fait avant puis avant notre variable, si nous le mettons simplement dans Colin comme ça et exécutons notre code, vous pouvez voir alors nous en imprimons cinq et nous avons également imprimé sur dix. Et cela est dû au fait que ces deux colonnes constituent l' opérateur de résolution de portée qui vous permettra d'accéder à la variable globale plutôt qu'à la variable locale. Et c'est à peu près tout ce qu'il y a à cela. Donc, si vous le faites avec deux variables portant le même nom, vous utilisez deux deux-points qui constituent l'opérateur de résolution de portée pour accéder à l'opérateur global. Et vous ne faites rien de différent pour accéder à la version locale. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 43. Chapitre 8 (chiffres aléatoires) : Intro aux chiffres aléatoires: Dans cette vidéo, je vais vous donner une introduction aux nombres aléatoires dans la programmation dans son ensemble. Ensuite, dans la vidéo suivante, nous allons générer des nombres aléatoires dans une plage souhaitée en C plus plus. Alors allons-y. abord, lorsque nous voulons générer des nombres aléatoires, vous devez ajouter ces deux fichiers à votre programme. Donc, en haut, nous allons dire que le hashtag inclut à l'intérieur d'un symbole inférieur à et supérieur à. Nous allons dire C std LIB. Et c'est juste la bibliothèque standard C comme avec les autres abréviation de. Et puis la prochaine fois, nous allons faire la même chose, sauf que nous allons mettre du temps C. Et celui-ci est avec lequel nous travaillons, accord, donc je vais aller de l'avant et le déplacer ici. Maintenant, en ce qui concerne les nombres aléatoires dans la programmation, parce que les ordinateurs font simplement ce qu'on leur dit on ne peut pas vraiment obtenir un nombre aléatoire. Ce n'est pas possible, quels que soient les programmes et applications que vous avez vus, cela ne génère pas réellement un nombre aléatoire. Cependant, pour l'utilisateur, cela semble aléatoire. Et laissez-moi vous expliquer comment cela fonctionne. Donc, tout d'abord, il y a cette équation très compliquée dans laquelle vous pouvez mettre un chiffre pour commencer. Et il vous donnera ce qui semble être un nombre aléatoire basé sur ce que vous lui avez donné. Cependant, si vous continuez à lui donner le même numéro, il vous redonnera le même numéro. Donc, dans la programmation, vous voulez réellement donner à cette équation un nombre différent à chaque fois. Donc, si un utilisateur pense qu'il obtient toujours un nombre aléatoire comme nous le faisons, c'est en donnant cette équation l'heure actuelle. Et comme il prend la date et l'heure, ce nombre sera toujours différent. Une autre chose que je veux vous montrer dans cette vidéo est ce qu' on appelle le débordement. Donc, tout d'abord, une variable entière a ceci comme nombre maximum. Et une autre façon d'y parvenir sans simplement nous souvenir et sans dire int underscore max et juste un avertissement. Il existe d'autres mots clés de ce type nous ne parlerons pas dans ce cours. Donc, si cela vous intéresse, c'est quelque chose que vous pouvez toujours examiner. Quoi qu'il en soit, ce que je vais faire ici, disons que x est égal à un point-virgule à la fin. Ensuite, nous allons dire x plus plus. Nous allons donc en ajouter un , puis l'imprimer. Et pour vous montrer ce qui se passe, allons-y et téléphonons. Et voici la gamme CL. Et puis les hommes, comme ça, et ça va nous donner la valeur entière minimale. Comme vous pouvez le voir, c'est exactement la même chose. Et la raison en est qu'une fois qu' un entier, il passe en tant que valeur maximale, provoque ce que l' on appelle le débordement , c' qu'il revient à une valeur minimale. Ensuite, nous compterons à partir de là. Maintenant, qu'avons-nous pour en faire un entier non signé ? Ensuite, nous dirions int max, et cela nous donnera la valeur maximale pour un entier non signé. Ensuite, exécutez un programme , restez un nombre positif et revenez à 0, puisque c'est la plage minimale pour un entier non signé. Quoi qu'il en soit, je voulais juste vous montrer ce qu' était un débordement très rapidement et vous comprendrez mieux pourquoi je vous ai montré cela dans la vidéo suivante. De plus, c'est une bonne chose à savoir pour l'avenir. Quoi qu'il en soit, la principale chose que je veux que vous retiriez de cette vidéo est que les nombres aléatoires et les programmes ne sont pas vraiment aléatoires et qu'ils sont ce que nous appelons un pseudo-aléatoire, donc ils apparaissent simplement au hasard utilisateur. Et que se passe-t-il réellement lorsque nous saisissons un nombre dans une grande équation qui nous donne un nombre apparemment aléatoire. Et en modifiant ce qu'est ce nombre, nous pouvons obtenir un nombre apparemment aléatoire à chaque fois. C'est pourquoi nous insérons l'heure actuelle dans cette équation car elle utilise la date et l' heure, ce qui nous donne un nombre différent. Quoi qu'il en soit, c'est tout pour cette vidéo. Assurez-vous que vous ajoutez ces bibliothèques et nous les laisserons ici pour le reste du cours car cela ne fera aucun mal. Merci de m'avoir écouté et je vous verrai dans la prochaine. 44. Chapitre 8 (chiffres aléatoires) : générer des chiffres aléatoires: Dans cette vidéo, je vais vous montrer comment obtenir nombres apparemment aléatoires dans C plus plus. Maintenant, ignorez simplement cette ligne de textes que j'ai ici, et je vais vous montrer ce que cela signifie et un petit peu. Quoi qu'il en soit, allons-y et créons un programme qui simule dix fois le fait de rouler dix fois un dé à six faces. Donc, tout d'abord, ce que nous allons faire, c'est dire que pour int I est égal à 0, I inférieur à dix. Moi en plus, en plus. Juste comme ça. Dans notre boucle, nous allons dire CL, rand, toutes les parenthèses minuscules, ouvertes et fermées et mettre un point-virgule à la fin. Et ce que cela devait faire, c'est automatiquement nous donner un nombre aléatoire entre 0. Donc, nombre entre rand max. Maintenant, rand max a une valeur minimale de 32 767. Nous allons donc obtenir cette gamme incroyable de chiffres. Comme je l'ai dit, c'est la valeur minimale, pas la valeur maximale. Donc, avant de lancer notre code, allons-y et mettons-nous tous sur une nouvelle ligne. Ensuite, nous allons l'exécuter. Comme vous pouvez le voir, nous avons obtenu dix nombres apparemment aléatoires. Cependant, allons-y et essayons de mémoriser quelques-unes d'entre elles. Donc, ce premier est pour 1184676334. Ce sont nos trois premiers. Et si nous lançons à nouveau un programme, oh, est-ce que tu regarderais ça ? Nous avons obtenu exactement les mêmes chiffres. Et si nous le faisions à nouveau, nous obtiendrions à nouveau les mêmes chiffres. Et cela continuera de se produire pour toujours car, comme je l'ai dit, ce n'est pas vraiment un hasard. Et on nous donne l'équation dont j'ai parlé dans la dernière vidéo, le même chiffre exact pour commencer à chaque fois. Ils obtiennent donc plus de nombres apparemment aléatoires. Nous devons répondre à une valeur différente dans l'équation qui nous donne un nombre apparemment aléatoire. Maintenant, pour ce faire, nous allons faire tout en haut de notre programme. Et d'ailleurs, ils ne voudront le faire qu'une seule fois. Sinon, vous n'obtiendrez pas de nombres apparemment aléatoires comme vous le pourriez potentiellement. Vous allez dire ce fil, tout en minuscules. Et puis entre parenthèses, nous allons dire l' heure en minuscules. Et encore une fois entre parenthèses, nous allons mettre non. Vous pouvez également voir des gens mettre 0 et c'est essentiellement la même chose. Et si je passe la souris dessus, vous pouvez voir, mais c'est aussi 0. Et puis à la toute fin, nous allons mettre un point-virgule, comme ça va faire, c'est que lorsque notre programme s'exécutera, nous allons mettre l' heure et la date directement dans l'équation qui donne est un nombre apparemment aléatoire. Et puis cette méthode aléatoire va nous en donner le résultat. Bien que cela nous ait donné dix nombres apparemment aléatoires, le problème était, comme vous l'avez vu, une fois que nous l'avons de nouveau fait appel et que nous avons complètement recommencé notre programme. Ces dix premiers chiffres étaient toujours les mêmes. Et nous aurions pu faire 100 numéros et refaire notre programme. Et ils auraient été les mêmes 100 numéros. Encore une fois, même si ces 100 chiffres étaient différents. Donc maintenant, quand un programme s'exécute, car il va utiliser l'heure et la date du premier démarrage du programme. L'équation dont j'ai parlé va nous donner une liste de nombres aléatoires apparemment différents à chaque fois, parce que l'heure devrait être différente chaque fois que nous exécutons notre programme. Très vite, ce que fait cette chose en tant que graine, l'équation aléatoire avec un nombre. Et en fait, vous pouvez simplement entrer un chiffre positif ici, comme cinq. Et ça va marcher. Et comme vous pouvez le voir, si je lance notre programme sur les chiffres et les morts avant. Mais si je le lance à nouveau, il y aura les mêmes chiffres. Je vais donc retourner ici. Quoi qu'il en soit, pourquoi voulons-nous n' avoir cela dans notre programme qu'une seule fois ? Et pourquoi ne l'avons-nous pas simplement mis dans notre boucle pour ? Eh bien, le problème est que votre ordinateur lit si rapidement qu'en ayant cette boucle interne, nous pouvons imprimer le même numéro plusieurs fois parce que nous aurions eu exactement le même numéro intégré à notre équation. Parce que cette ligne de code est ici, elle a peut-être été exécutée deux fois au même moment exact, et donc, les nombres n'auraient pas été aussi aléatoires qu'ils auraient pu l'être si nous ne l'avions exécutée qu'une seule fois au début de notre programme. Et comme cela vous permettra d'obtenir une liste de numéros, vous ne devez le faire qu'une seule fois. Et comme je l'ai dit, il suffit de mettre cela au début de votre programme. Si vous essayez d' obtenir un nombre aléatoire vous serez prêt à partir. Nous pouvons y faire appel autant de fois que nous le voulons. Comme je l'ai dit, lorsque nous pouvons même l'augmenter si nous voulons exécuter notre code, vous pouvez voir que nous obtenons 100 chiffres. Et si on regarde ces trois premiers , on peut les mémoriser très rapidement. Encore une fois, vous pouvez voir qu'ils ne sont plus les mêmes à chaque fois, c'est exactement ce que nous voulons. Maintenant, comme je l'ai dit, nous essayons de créer un programme ici, qui simule un dé à six faces. Et bien, ces chiffres sont insensés. Alors, comment pouvons-nous résoudre ce problème ? Eh bien, souvenez-vous de l'opérateur de module dont nous avons parlé lorsque nous avons parlé des opérateurs mathématiques de base. Eh bien, c'est un excellent exemple du moment où cela sera utile. Donc, ce que nous allons faire, c'est autour de notre méthode aléatoire, appelez ici. Et comme je l'ai dit, nous passerons aux appels de méthode plus tard dans le cours. Nous allons continuer et mettre des parenthèses. Comme ça. Et puis ici, nous allons mettre l'opérateur du module suivi du nombre que nous voulons, donc disons sexe. Et maintenant, nous savons que nous ne pouvons obtenir qu'une valeur comprise entre 05 car cet opérateur, si vous vous en souvenez, nous donne le reste de ce nombre divisé par ce nombre. Mais si nous essayons de simuler un lancer de dés, aurons probablement besoin d'un nombre compris entre 16 et non entre 0 et 5. Et bien, ce n'est pas un problème. Parce qu'après, dites plus un, juste comme ça. Maintenant, nous allons en avoir un à six. Et si nous exécutons notre programme, vous y voilà. 12345678910, nombres apparemment aléatoires entre 16. Et nous pouvons l'exécuter autant de fois que nous le voulons. Et comme vous pouvez le constater, ils semblent être aléatoires à chaque fois. Alors, tu y vas. C'est le moyen le plus simple d'obtenir nombres apparemment aléatoires dans la plage que vous souhaitez. Une dernière chose que je voudrais aborder est que selon ce que nous utilisons, ce nombre aléatoire quatre, il est possible que selon ce nombre, nous en fassions une erreur. Et il peut être difficile pour nous faire remonter ce chiffre, surtout en fonction de la fourchette que nous en tirons. Vous pouvez donc simplement économiser ce temps, aucune valeur quelque part, puis l'imprimer de sorte qu' au moment où vous reprenez l'antenne, vous ayez cette valeur à effacer dans votre programme. Donc, ce que nous pourrions faire, c'est dire quelque chose comme si cette graine n'était pas signée et la mettre sur une durée égale. Juste comme ça. Vous pouvez également voir cela appelé temps 0. Cela fait exactement la même chose. Il n'y a aucune différence entre cette ligne ici et celle-ci. Donc, si vous voyez ça tout à l'heure, c'est pareil. Et ensuite, ici, on peut aller de l'avant et monter. On pourrait donc dire que C out Seed a créé une ligne. Maintenant, si nous exécutons un programme, ce que vous pouvez faire, si vous avez eu une erreur lors de l'exécution de votre programme ici, vous pouvez copier ce numéro exact, revenir dans votre programme. Et je vais juste le supprimer ici rapidement. Et là où nous avons ESR et ici, vous pouvez simplement saisir le même nombre exact que nous avions. Et parce que cela nécessite une valeur entière non signée et non un int pour un moment, attrapez ces deux enzymes. Comme ça. Tu y vas. Maintenant, nous pouvons obtenir le même numéro à chaque fois que nous avons eu notre erreur et la diagnostiquer de cette façon. Donc, c'est juste quelque chose que vous devez garder à l'esprit et que vous voudrez peut-être trouver un moyen d' obtenir la valeur qui a été entrée dans votre programme. Si vous avez joué jeu comme Minecraft ou quelque chose comme ça, où ils génèrent des nombres aléatoires et vous donnent une graine qui vous permet d'obtenir à nouveau la même carte. Eh bien, vous y voilà. C'est parce que la génération de cette carte n'est pas réellement aléatoire. Et vous pouvez simplement remettre la même valeur dans l'équation et obtenir nouveau la même carte. Et vous y voilà. C'est ainsi que vous obtenez des nombres aléatoires dans C plus plus. Et maintenant, vous savez aussi comment obtenir le même ensemble de nombres aléatoires en utilisant du jus. Quoi qu'il en soit, j'espère que vous avez trouvé cette vidéo utile. Merci de m'avoir écouté , et à bientôt. 45. Chapitre 9 (conteneurs) : Intro aux conteneurs: Dans cette vidéo, je vais vous parler des conteneurs. Un contenant est essentiellement un objet qui contient d'autres objets et les objets qu'il contient, ou souvent appelés ses éléments. Un autre aspect des conteneurs est qu'ils possèdent une tonne de fonctions que vous pouvez utiliser pour travailler avec tous les éléments qu'ils contiennent. Maintenant, il y a un tas de conteneurs différents dans C plus plus. Et dans ce cours, nous n'allons passer en revue qu' une poignée d'entre elles. Mais je vous encourage vivement à consulter les différents contenants et à voir au moins ce qu' ils font pour qu'ils soient disponibles si vous en avez besoin. ne traiterons également que de quelques fonctions et de nos méthodes pour chaque type de conteneur que nous allons couvrir. Donc, encore une fois, si vous souhaitez en savoir plus à leur sujet, je vous recommande vivement de consulter les différentes fonctions disponibles afin de voir également ce qui est disponible pour cela. présent, lorsque vous décidez quel conteneur vous souhaitez utiliser pour votre projet, vous devez non seulement en choisir un en fonction de sa capacité à toutes ses différentes fonctions, mais également sur la base des fonctions elles-mêmes. Comme chacun aura quelque chose, ils pourront faire un peu différemment les uns des autres. Comme je l'ai dit, vous devez choisir en fonction de la rapidité avec laquelle chacun s' exécute, d'une tâche ou d'une autre, ainsi que des fonctionnalités disponibles. Et pour ceux d'entre vous qui viennent d' un autre milieu de langage de programmation, vous les avez peut-être également vus sous le nom de collections. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 46. Chapitre 9 (conteneurs) : tableaux: Dans cette vidéo, nous allons parler de tableaux. Maintenant. Les tableaux sont le tout premier conteneur dont nous parlerons dans ce cours et sont souvent considérés comme l'un des types de conteneurs les plus basiques que vous verrez également dans d'autres langages de programmation. Tout d'abord, les tableaux ne sont essentiellement qu'un groupe d' éléments du même type stockés en séquence. Et ils vous permettront également d' accéder à plusieurs éléments à l'aide du même identifiant. N'oubliez pas qu'un conteneur est essentiellement un objet qui contient plusieurs objets. Et les objets contenus dans ce conteneur sont appelés éléments. C'est donc de là que vient ce mot. Alors allons-y et examinons la syntaxe de base d'un tableau. Vous allez donc d'abord avoir le type de données suivi du nom, suivi de crochets ouverts et fermés. Ensuite, vous finirez par un point-virgule. Et puis, à l'intérieur de ces crochets, vous aurez la taille d'un tableau. Maintenant, lorsque vous créez et utilisez un tableau, vous commencez à connaître la taille ou nombre d'éléments que vous souhaitez stocker dans ce tableau, car il est vraiment inefficace de le modifier. Alors allons-y et créons un tableau de base d'entiers. Donc pour ce faire, nous allons aller de l'avant et dire bonjour pour acheter un tableau int comme celui-ci. Ensuite, à l'intérieur de ces crochets, nous lui donnerons une taille de cinq, par exemple. Ensuite, nous allons mettre un point-virgule à la fin. Donc, ceci va créer un tableau int nommé tableau int avec cinq entiers dedans. Et on peut le nommer comme on veut. J'ai juste décidé de l'appeler int array pour des raisons de simplicité. Maintenant, remarquez que si je passe la souris dessus, cela indique qu'ils ne sont pas initialisés. Cela signifie qu'ils n' ont pas encore de valeur initiale. Et il y a plusieurs façons d' aller de l'avant et de lui en donner une. La première serait donc de le mettre avant le point-virgule. Donc, jusqu'à présent, nous venons de déclarer ce tableau, mais nous n'avons donné aucun des entiers qu'il contient ni la valeur initiale. Donc, après cela, nous pouvons dire égal , puis ouvrir et fermer les crochets, comme ça, j'ai remarqué que ces lignes pointillées disparaissaient sur mon écran ici. Et maintenant, chaque entier de notre tableau a une valeur de 0. C'est donc un moyen. Vous pouvez donner à chaque entier la valeur 0, mais nous pouvons également leur donner une valeur exacte et des valeurs différentes entre ces crochets. Donc, pour ce faire, nous pouvons simplement dire quelque chose comme ceci, où vous opteriez pour cent vingt-deux, vingt et un, et soixante-seize ou quelque chose comme ça. Maintenant, les cinq variables entières de notre tableau int ont une valeur initiale que nous avons définie. Donc, le premier sera pour, le second sera un, et ainsi de suite. De plus, dans C plus plus, vous pouvez simplement supprimer ce signe égal et ce sera exactement comme si nous l'avions là. Personnellement, j'aime bien l'avoir là puisque nous utilisons déjà l'opérateur d'affectation ici pour initialiser des éléments tels que des variables et des choses de ce genre. Mais comme je l'ai dit, tu peux le retirer. Donc, il voit le code de quelqu'un sans cela, vous savez que c'est exactement le même qu'avec lui. Et si nous voulions aller de l'avant et imprimer tous les phylums sont des nombres entiers ? Comment y accéder ? Eh bien, allons-y et créons une boucle pour. Donc on va dire quatre, puis on dira int I égal à 0, I inférieur à cinq, I plus, plus. Et puis à l'intérieur de notre bloc de code, nous allons dire C0, je dirais tableau int, parce que c'est le nom de notre tableau, suivi de crochets ouverts et fermés et d'un point-virgule à la fin. Ensuite, à l'intérieur, nous devons mettre l'index de celui que nous voulons imprimer. Et parce que nous avons déjà un itérateur qui va passer de 0 à 4. Nous allons juste le mettre dedans. Maintenant, pour vous montrer quels sont les index en conséquence. De la façon dont les tableaux fonctionnent en tant que toute première variable entière, NRA est à l'indice 0. Donc, si je voulais juste imprimer celui-ci, je mettrais 0 ici comme ça, et puis ça passerait à 01234, etc. Donc on va juste aller de l' avant et mettre un I. Et puis après ça, allons-y et ajoutons une compagnie aérienne et utilisez notre code. Et comme vous pouvez le voir, nous avons imprimé 41520 à 121 en 76, accord, et pour vous montrer que tout cela a une valeur initiale de 0 sans rien ici. Si nous exécutons notre code sans rien dedans, ils imprimeront 0. Très bien, maintenant allons-y et examinons l'autre méthode pour initialiser les valeurs de notre tableau. Alors allons-y et débarrassons-nous de ces égaux et des crochets frisés ici. Et de la même manière que nous avons accédé aux valeurs de notre tableau pour les imprimer. Nous pouvons également accéder aux valeurs pour les initialiser. Nous pouvons donc dire int array. Et puis entre crochets, on pourrait mettre 0, par exemple. Dis juste qu'il égale ce que nous voulons, comme ça. Et puis mettez un point-virgule à la fin. Et cela fonctionnera très bien. Nous pourrions passer ainsi si nous voulions aller jusqu'à 1234 et obtenir à chacune d' elles une valeur différente. D'accord, si nous exécutons un code, vous pouvez voir que cela fonctionne très bien. Et nous sommes allés à 01234. Nous aurions pu les faire dans n'importe quel ordre si nous le voulions. Maintenant, supposons que nous voulions tous obtenir exactement la même valeur, disons 30. Et disons que nous en avions beaucoup plus que cinq et notre gamme. Disons que nous en avons 100. Eh bien, au lieu de faire ça, ce qui nous prendrait pour toujours, nous pouvons simplement aller ici. Donc j'ai moins de 100. Et puis ici, nous allons simplement ajouter une autre ligne au-dessus de l'endroit où nous imprimons les valeurs de notre tableau et disons tableau int. Je vais utiliser i pour l'index une fois de plus ici, et nous dirons qu'il est égal à 30. Et maintenant, il s'imprimera 3000 fois. Et je ne vais pas les compter, mais croyez-moi, il y en a 100. Très bien, il existe donc différentes manières d'initialiser vos tableaux. De plus, nous pouvons continuer et définir la variable égale à la valeur d'un tableau si nous le voulons également. Nous pouvons donc dire que x est égal à tableau int, puis ajouter un index comme to, par exemple. Et si nous devions aller de l'avant et imprimer ainsi, je vais commenter cette ligne. Vous pouvez donc voir que cela fonctionne puisqu'il y a une tonne de 30 ans là-bas et voilà. Alors, vous l'avez. Vous savez maintenant comment travailler avec des tableaux. Maintenant, lorsque vous souhaitez utiliser un tableau, eh bien, tout d'abord, n'oubliez pas que la taille d'un tableau est fixe. Vous devez donc connaître la valeur exacte, mais vous allez y mettre. Et je peux vous le montrer en procédant comme suit. Donc, si nous les effaçons ici et que nous disons que x est égal à 100, puis que nous essayons de mettre x ici pour la taille de notre tableau. Vous pouvez voir que nous obtenons une erreur car il doit s'agir d'une valeur constante qui ne peut pas changer. Maintenant, nous pourrions en faire une constante et cela fonctionnerait très bien. Mais notez simplement que la taille de votre tableau doit être connue à l'avance. De plus, ils sont efficaces pour en récupérer les valeurs, comme nous l' avons fait ici lorsque nous les avons imprimées. Et ils sont parfaits lorsque vous souhaitez mettre l'ordre dans les éléments de votre tableau, comme nous l'avons fait ici également. Maintenant, je suis allé éviter de les utiliser. Eh bien, vous devriez les éviter lorsque vous souhaitez insérer ou supprimer des éléments du tableau, car comme je l'ai dit, ils ont une taille fixe. Donc, si vous ne voulez pas connaître la taille au démarrage de votre programme, c'est un problème. Et un bon exemple de cas où vous ne voudriez pas utiliser I'm I, n'est-ce pas ? Quoi qu'il en soit, c'est tout pour cette vidéo. Dans la vidéo suivante, nous allons parler de ce on appelle un tableau multidimensionnel. Alors merci de m'avoir écouté, et à bientôt. 47. 46: Dans cette vidéo, nous allons parler de tableaux multidimensionnels. Maintenant, la meilleure façon de considérer les tableaux multidimensionnels comme des tableaux de tableaux. De plus, un tableau multidimensionnel peut comporter autant de dimensions que vous le souhaitez ou que vous le souhaitez, mais sachez que la mémoire utilisée augmente considérablement à chaque dimension ajoutée. C'est donc quelque chose dont il faut être conscient. J'ai donc un exemple de tableau bidimensionnel ici pour vous, qui sera créé ici dans une minute. Donc, pour un tableau 2D, vous aurez votre type de données, votre nom comme avant. Mais maintenant, au lieu d'un seul jeu de crochets, vous allez devoir, si vous vouliez créer un tableau tridimensionnel, vous auriez un troisième ensemble de crochets et ainsi de suite. Ensuite, vous avez besoin de la taille pour chacune de ces dimensions. Et je mets simplement des lignes et colonnes pour vous aider à visualiser à quoi cela ressemblerait si vous le visualisez comme une grille 2D où vous avez des lignes et des colonnes, et vous pouvez visualiser les éléments d'un tableau bidimensionnel avec trois lignes et trois colonnes visualisé en tant que tel. Maintenant, pour accéder réellement à chacun de ces éléments, nous ferions ce qui se trouve ici en conséquence. Donc, ce premier sera 000102. Ensuite, nous allons descendre à la première ligne, à la colonne zéro, parce que n'oubliez pas que les index commencent à zéro lorsqu'il s'agit de conteneurs. Ce sera donc 10111220, t1, t2. Très bien, alors allons-y, créons-le et imprimons-le comme il est ici. OK, donc ce que nous allons faire, c'est dire, je vais dire plus de tableau de types. Et puis entre crochets ici, nous allons dire trois après cela. Et nous allons redire trois. Je vais mettre un point-virgule à la fin. De plus, nous pouvons commencer et initialiser notre tableau multidimensionnel la même manière que nous avons fait pour un tableau normal. Nous pouvons donc dire quelque chose comme des égaux et ensuite avoir deux crochets bouclés comme ça. Et tout cela sera initialisé à zéro. Également. Nous pouvons le faire de l'autre manière en saisissant directement une valeur. Donc, si nous voulions que les valeurs ressemblent à ceci ici, nous pourrions dire une virgule deux, une virgule trois, comme ça. Ensuite, créez un autre ensemble de crochets frisés pour la ligne suivante. Tu pourrais dire 456, puis recommencer. Donc sept, neuf. Et maintenant, la dernière chose à faire pour que cela fonctionne est de mettre tout cela et un autre ensemble de crochets bouclés. Donc on va y aller comme ça. Et nous devons également mettre une virgule entre chaque ensemble. Donc, juste comme ça. Et si vous trouvez cela plus facile à visualiser, vous pouvez faire quelque chose comme ça. Quoi qu'il en soit, je vais aller l'avant et les remettre à ce qu'ils étaient. Ensuite, nous allons continuer et imprimer chaque valeur et former un tableau multidimensionnel. Mais avant cela, je vais vous montrer une dernière chose que j'ai oublié de vous montrer dans la dernière vidéo, et je vais également vous montrer comment cela fonctionne avec un tableau multidimensionnel. Donc, juste au cas où vous le rencontreriez, comme je ne le recommanderais pas normalement car vous pouvez rencontrer des problèmes inattendus, vous pouvez dire int mon tableau, par exemple, nous lui donnerons une taille de rien. Ensuite, nous pouvons dire égal et l'initialiser simplement entre crochets comme ceci. Et cela fonctionnera très bien. Et il saura automatiquement qu'il fera la taille de quatre. Maintenant, vous pouvez faire de même ici, mais vous ne pouvez supprimer que cette première valeur. Donc, dans ce cas, ce serait comme supprimer le nombre de lignes, qui sera déterminé par nombre de jeux de crochets que nous avons. Ensuite, le nombre de colonnes que vous devez spécifier, car cela ne fonctionnera pas. Comme vous pouvez le constater, nous recevons immédiatement une erreur, non ? Donc je voulais juste te le montrer rapidement. Après la taille, revenez là-dedans de manière explicite également. Alors allons-y et imprimons notre gamme ici de la manière suivante. Donc, pour ce faire, nous allons en créer deux pour les boucles, ce que nous allons dire pour nos zéros sont inférieurs à trois, r plus. Et puis à l'intérieur, je vais ajouter une autre boucle pour et dire que int c est égal à zéro, moins de trois, C plus, plus. Et nous allons créer des crochets bouclés comme ça. Ensuite, nous allons procéder à l'impression des valeurs. Donc on va dire «  C ». D'accord ? Et puis entre crochets ici, nous allons mettre R et ensuite les autres crochets à la place. Ensuite, nous allons simplement imprimer un espace vide comme suit. Et puis en dessous de cela, pour la boucle , dans notre autre, nous allons créer une ligne blanche. De plus, à titre d'avertissement, ces Hollywood accèdent, initialisent et modifient toutes les valeurs et notre gamme multidimensionnelle. Donc, avant, nous devions simplement taper le nom du tableau suivi de l' indice de l'élément. Ici, notre index ressemblerait ceci, comme je vous l'ai montré plus tôt. Donc, ce qui va se passer, c'est que nous allons passer par notre premier for loop. Et j'ai appelé cette variable , c'est l'abréviation de lignes, mais vous pouvez l'appeler comme vous voulez. Donc, la première fois que R sera égal à zéro et c sera égal à zéro. Donc, il va obtenir l'index 00 et en imprimer un parce que c'est ce que nous avons, non ? Ensuite, il va revenir dans cette boucle et en imprimer deux, puis trois. Et puis un poulet est revenu, les rangées se transformeront en une seule. Nous serons donc à 01h01, 112, et cetera. Alors allons-y, exécutons-le et ils l'imprimeront. 123, McDonald, ligne 456, et encore une fois, 789. Et voilà, vous l'avez. Maintenant, nous aurions également pu créer une boucle double for comme celle-ci pour initialiser toutes ces valeurs de une à neuf, comme nous l'avons fait ici. Alors allons-y et voyons quoi cela ressemblerait si nous copions ces doubles pour boucle et que nous les collions ici, remarquez que nous n'avons pas eu d'erreur parce que les deux sont tous deux locaux à leur bloc de code spécifique et n'existent pas en dehors de celui-ci. Avoir de l'art ici et du C ici, du R ici, et voir ici, ça ne pose aucun problème. Alors allons-y et supprimons notre initialisation initiale ici. Mais nous pouvons les initialiser toutes à zéro. C'est très bien Et puis plus bas, nous allons dire que int i est égal à un. Et puis ici, nous allons dire qu' au lieu de l'imprimer, nous allons dire RNC multidébit, comme avant. Mais au lieu de cela, nous allons dire égaux. Et puis juste en dessous, on dira I plus, sorte qu'il augmente d'un à chaque fois. Très bien, maintenant, allons-y et exécutons notre code. Comme vous pouvez le voir, tout cela a été initialisé, très bien. Et la seule raison pour laquelle il n' y a plus que quelques lignes ici, parce que nous leur avons laissé la nouvelle ligne. Mais comme vous pouvez le constater, la même manière que nous avons pu les imprimer dans l'ordre en utilisant ce double pour boucle. Nous avons pu les initialiser dans l' ordre en utilisant une boucle double for, non ? Parce que c'est fondamentalement la même chose. Mais au lieu de simplement l'imprimer, nous lui avons donné une valeur initiale, augmentant simplement I d'un à chaque fois qu'ils leur donnent une valeur dans l'ordre. Et bien que nous ayons tous ces éléments découpés, je pourrais vous montrer comment créer rapidement une table de multiplication et si nous le voulions. Alors allons-y et changeons-les en dix, par exemple, ou nous pourrions même faire quelque chose comme 30. Et puis ici, ça va changer , passer à 34, notre valeur r. Et les deux, et pareil pour notre propre valeur. Et nous allons les démarrer tous les deux en même temps dans tous les cas ici. Ensuite, comme nous tournions sur les deux à la fois, si nous voulions vraiment que le tableau comporte 30 chiffres complets, nous voudrions les remplacer tous par 31, comme ceci. Ensuite, ici, nous allons supprimer ce I plus, plus. Et donc en le mettant comme égal à i, nous allons dire R fois C, juste comme ça. Maintenant, nous pouvons supprimer le cœur et je varie entièrement. Très bien, maintenant nous avons créé un tableau multidimensionnel de taille 31. Ensuite, nous avons créé une boucle for avec une variable entière qui commence à un et continue de vivre tant qu'elle est inférieure à 31. Et nous augmentons le nôtre d'un à chaque fois, puis nous faisons la même chose avec C ici. Ensuite, nous mettons r et c pour nos index ici et nous définissons simplement l' indice égal à R fois C. Et ensuite nous allons supprimer ceci, l'instruction de ligne ici. Mais on va le laisser dans celui d'en bas. Ensuite, au lieu de simplement mettre un seul espace vide ici, nous allons simplement mettre un onglet. Et un moyen simple de le faire serait de mettre une seule citation comme celle-ci ou un ensemble de guillemets simples, devrais-je dire. Et puis la barre oblique inverse t, ce qui créera un onglet. Au fait, chaque fois que vous avez la barre oblique inverse et un caractère, Let's peut être considéré comme un caractère unique pour un caractère. Très bien, donc je vais très bien courir. Maintenant, allons-y et exécutons notre programme. Et comme vous pouvez le voir, c'est en fait assez gros. Allons-y et réduisons ce chiffre à environ 11 pour chacun d'entre eux. Et exécutez à nouveau notre code. Et ils y vont de 1 à 10 à 12 fois deux fois, c'est quatre. Et si nous regardons ici, six fois 636, et cetera, et que nous avons maintenant créé notre propre table de multiplication avec juste quelques boucles pour et un tableau multidimensionnel. Donc c'est plutôt chouette de toute façon, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 48. Chapitre 9 (conteneurs) : vecteurs: Dans cette vidéo, nous allons parler de vecteurs. Et vous pouvez considérer les vecteurs comme un tableau redimensionnable doté de fonctionnalités supplémentaires. Et c'est parce qu'un tas de fonctions ou de méthodes supplémentaires leur sont associées. Et je vais vous en montrer quelques-unes ici dans cette vidéo. Mais si vous voulez voir toutes les méthodes ou fonctions possibles, je vous recommande vivement de les rechercher car il en existe une tonne. Maintenant, très vite, je suis allé de l'avant et j'ai remis ici la syntaxe d'un tableau. Donc, si vous vous en souvenez, nous allons mettre le type de données, le nom, puis la taille et quelques crochets. Cependant, la syntaxe d'un vecteur est légèrement différente. Nous allons donc dire vecteur et toutes les minuscules, suivis du type de données intermédiaire, un symbole inférieur à et supérieur à. Enfin, nous aurons le nom suivi d'un point-virgule à la fin. Maintenant, avant de voir comment créer et utiliser notre propre vecteur, nous devons ajouter un autre fichier d'en-tête en haut de notre code ici. Nous allons donc dire que le hashtag inclut. Et puis, entre le symbole inférieur et le symbole supérieur à, nous allons simplement dire que le lecteur, comme ça, aura désormais accès à tout ce dont nous avons besoin. Alors allons-y et commençons. Tout d'abord, nous allons dire vecteur. Ensuite, entre le symbole inférieur et le symbole supérieur à, notre type de données sera suivi du nom, et nous l'appellerons simplement mon vecteur, comme ça. Et à l'intérieur, comme pour les autres conteneurs, vous allez mettre une multitude de types de données. Jusqu'à présent, nous avons utilisé des nombres entiers, mais dans ce cas, pourquoi ne pas simplement mettre des chaînes de caractères. Ok, donc on va juste dire chaîne, et au lieu de l' appeler mon vecteur, pourquoi ne pas l'appeler simplement sac à dos, comme ça. Et puis, comme nous le pouvions avec les tableaux, nous pouvons réellement aller de l'avant et placer immédiatement certains éléments dans notre vecteur ici, ici, nous pourrions dire égaux, puis entre crochets. Maintenant, remarquez ici que nous n'avons pas la taille de notre vecteur et c'est parce que j'ai dit qu'il est redimensionnable. Il s'agit essentiellement d'une taille dynamique, ce qui signifie qu'elle peut changer à mesure que notre code s'exécute. Donc, ici, nous pouvons aller de l'avant et lui donner une taille par défaut en ajoutant des valeurs par défaut. Faisons comme si nous étions en train de remplir un sac à dos. Nous allons donc mettre quelques chaînes. Nous pourrions donc dire quelque chose comme livre, Kama, crayon. Et nous ajouterons également un bloc-notes. Ok, maintenant, évidemment, ce sont des mots arbitraires et justes, mais vous voyez l'idée ici. Nous pouvons en fait imprimer des éléments à partir de notre vecteur de la même manière que nous le ferions avec un tableau. Nous pouvons donc simplement dire sac à dos, puis ouvrir et fermer les crochets à l'intérieur. Nous allons mettre l'index et l'index fonctionne exactement de la même manière qu'avec les tableaux, où il va à 012. Nous avons donc dit Biotech One et nous voulions l'imprimer. On dirait un sac à dos C out, comme ça. Et si je lance mon code ici, vous pouvez voir qu'il dit crayon parce que c'est la chaîne qui se trouve à notre premier index ici ou à l'index un. Maintenant, ce qui est intéressant à propos des vecteurs par rapport aux tableaux, c'est que, comme je l'ai dit, il s'agit d'une taille dynamique. Nous pouvons en fait ajouter des choses à cela et il y en aura à la toute fin. De plus, comme je l'ai dit au début, il existe des fonctions ou des méthodes supplémentaires associées aux vecteurs que nous pouvons utiliser. Allons-y et jetons un coup d'œil à l'un d' entre eux dès maintenant. Donc, ici, on peut dire sac à dos ou le symbole de l'époque. Vous allez voir une liste d'options ici, au moins un peu de Visual Studio. Mais en fait, nous allons simplement saisir taille, puis ouvrir et fermer parenthèses et un point-virgule à la fin. Cela va nous indiquer la taille exacte de notre vecteur de sac à dos. Et si nous le voulions, nous pourrions aussi dépenser ce montant. Je dis C avant , juste comme ça. Et allons-y et ajoutons une nouvelle ligne ici. Il y a une date limite pour cela, juste pour que ce ne soit pas sur la même ligne que celle-ci. Et maintenant, lorsque notre code sera exécuté, il imprimera un crayon. Dans ce cas du moins. Et puis, ici, il va imprimer la taille. Et contrairement aux index où elle va à 012, la taille va passer à 123, tout comme on pouvait s'y attendre lorsqu'il voulait connaître la taille de quelque chose, ils sauront exactement combien d'éléments se trouvent dedans. Il devrait donc en imprimer trois. Et si nous exécutons notre code ici, vous pouvez voir que c'est ce qu'il fait. On l'imprime au crayon, puis sur une nouvelle ligne, on en imprime trois. Alors, comment pouvons-nous réellement ajouter des éléments à notre vecteur ? Eh bien, si nous allons ici, nous pouvons simplement la coller à nouveau là-bas pour qu'elle sache à quoi nous faisons référence ou avec quoi nous voulons travailler, qui serait un sac à dos dans ce cas. Ensuite, nous allons dire point et voir cette méthode de refoulement ici. C'est ce que nous allons taper. On va dire « push » et le score en arrière. Ensuite, entre parenthèses, nous allons mettre ce que nous voulons ajouter à notre vecteur. Nous allons donc simplement mettre la valeur que nous voulons ajouter, comme nous avons mis un crayon dans le Bloc-notes là-haut, ajouter une autre chaîne, puisque notre vecteur est composé de chaînes. Donc, ici, prenons quelque chose comme thriller et nous mettrons un point-virgule à la fin. Et maintenant, la règle va être à l'index trois parce que nous avons 012 , puis nous ajoutons celle-ci. Ce serait donc trois. Et ici, on dit le sac à dos CL 3. Et allons-y et assurons-nous qu'il soit placé sur une nouvelle ligne. Nous allons donc simplement dire la ligne M comme ça et exécuter notre code. Vous pouvez le voir comme le crayon de l'étui. Apparaissez, imprimez trois, ajoutez une règle, puis imprimez ce qui se trouvait à l'index trois. Maintenant, il est assez facile pour nous de savoir que cet élément de règle que nous venons d' ajouter se trouve à l'index trois, disant que tout se passe ici dans les fédéraux, juste ici sur notre écran. Mais que se passerait-il si nous voulions simplement imprimer le dernier élément de notre vecteur ? Mais nous ne savions pas exactement de quel indice il s'agissait. Eh bien, parce que nous avons cette méthode de taille, nous pouvons utiliser qui nous indiquera la taille exacte de celle-ci. En fait, nous pourrions simplement dire la taille du sac à dos. Ensuite, après cela, nous devons dire moins un. Maintenant, si nous avons ce moins un ici, c'est parce que même si notre sac à dos ou une fourchette de taille vectorielle quatre articles, il n'a pas d'indice de quatre car il vaut 0123. Et si nous voulons accéder à la valeur réelle ici et l'imprimer, plutôt que d' en imprimer trois ici, nous allons la mettre entre crochets après le nom de notre vecteur, comme nous le ferions si nous essayions d' accéder à toute autre valeur ici. Allons-y et coupons ça. Et nous dirons sac à dos entre crochets. Allons-y et collez-le comme ça. Maintenant, il va imprimer quel est l'index de ce sac à dos quatre moins un ou quelle que soit la taille maximale est moins un, qui sera toujours le dernier article de notre, accord, donc c'est comme ça que vous pouvez obtenir le dernier article, devriez-vous en avoir besoin ? Et si nous exécutons notre code ici, vous pouvez voir du blé qui, en fait, imprime une règle. Maintenant, nous pouvons également supprimer des éléments de notre vecteur et ils seront supprimés dans le même ordre. Donc, tout comme il l'ajoute à la toute fin de notre vecteur, nous pouvons supprimer des éléments à la fin de notre vecteur. Très vite, je vais juste aller avant et retirer ce sac à dos C. Out. Nous avons une ligne ici, nous créons donc un sac à dos. Nous imprimons la taille, qui dans ce cas est trois. Nous ajoutons un article, nous imprimons notre dernier article, puis nous allons supprimer ce dernier article. Donc, ici, nous allons dire cette opération, la souligner à nouveau. Tout est en minuscules, avec des parenthèses ouvertes et fermées et un point-virgule à la fin. Et ce que cela va faire, c'est pousser le dernier élément directement hors de notre vecteur. Donc, si nous copions notre impression du dernier article ici et que nous le collons ci-dessous et ce qui n'est pas de la couche, vous pouvez voir que, eh bien, nous avons d'abord créé une nouvelle ligne, puis nous en avons imprimé trois parce que est la taille de notre vecteur. Ensuite, nous avons ajouté un élément de règle, imprimé le dernier élément étant la règle en disant que nous venons de l'ajouter et que nous nous sommes débarrassés de la règle. Maintenant, notre dernier article est le bloc-notes et nous l'avons imprimé également. Alors, tu y vas. Vous savez maintenant comment créer et utiliser un. Et ces trois méthodes , à savoir la taille, le pushback et la méthode pop back, sont probablement les trois méthodes et fonctions OR les plus courantes que vous utiliserez en ce qui concerne vecteurs. Alors, quand souhaitez-vous utiliser un vecteur ? Eh bien, lorsque vous voulez stocker un tas de données dans ordre, comme c' était le cas avec un tableau. Et lorsque vous ne connaissez pas la taille au moment de la compilation ou lorsque vous exécutez votre code. Nous ne savions donc pas quelle serait la taille et nous n'avons pas eu à saisir une taille comme nous l'avons fait pour un tableau. Il était juste capable de changer dynamiquement à mesure que notre code louait. Donc, si c'est quelque chose dont vous avez besoin, vous pouvez envisager d'utiliser un vecteur. Et si vous prévoyez d'ajouter et de supprimer des éléments à l'extrémité du conteneur que vous utilisez, un vecteur est une autre bonne option car, comme vous l'avez vu ici, il existe une méthode pour cela. Et comme nos informations sont stockées dans l'ordre, nous aurions pu les parcourir et les imprimer comme nous l'avons fait nous aurions pu les parcourir et les imprimer avec notre tableau. Maintenant, quand ne voudriez-vous pas utiliser de vecteur ? Eh bien, si vous essayez d' ajouter ou de supprimer éléments au début du vecteur, c'est-à-dire ici où le livre se trouvait à l'index 0 ou quelque part au milieu. Surtout si vous avez beaucoup plus d'articles ici, alors ce n'est probablement pas pour vous. De plus, si vous connaissez déjà la taille du contenant et que cela ne changera pas. Autant utiliser un tableau. Maintenant, il fait noir ici. Allons-y et imprimons tout dans notre vecteur juste pour vous montrer une autre petite astuce intéressante que nous pouvons faire avec un vecteur grâce à ces fonctions supplémentaires. Donc, ici, je vais dire que pour int, je suis égal à 0, c'est inférieur à la taille de la matrice du sac à dos. Ensuite, je plus, plus, et puis en dessous, entre crochets bouclés vais simplement dire sac à dos. Et puis des crochets. Nous allons dire bonjour, puis nous allons simplement créer une nouvelle ligne comme celle-ci. Et maintenant, elle va tout imprimer dans son sac à dos, quel que soit le nombre d' articles qu'il y a dans notre Peck, Peck, n'est-ce pas ? Parce que c'est dynamique maintenant en fonction de la taille. Et puis allons-y et supprimons tout ce qui se trouve ici, comme avant, notre boucle for et exécutons notre code. Et comme vous pouvez le constater, nous avons imprimé un livre, un crayon, un stylo. Et même si nous modifiions notre taille ici, et que nous pouvions le faire ici, ou nous pourrions le faire à nouveau en utilisant notre fonction push-back. Nous allons donc dire sac à dos Dot Push Back. Ensuite, entre parenthèses, on dira quelque chose comme des dizaines. Et puis, si nous exécutons notre code sans rien changer ici, vous pouvez voir que nous imprimons maintenant des stylos. Alors, tu y vas. Il existe juste un autre cas d'utilisation de la méthode de taille. Et une autre raison pour laquelle vous voudrez peut-être utiliser un facteur pour les fonctionnalités supplémentaires dont nous avons parlé au début. Et c'est parce que, comme vous pouvez le voir, nous pouvons modifier notre vecteur en augmentant la taille et en la diminuant. Et notre système de boucle ne doit jamais changer. Et avant que j'oublie, nous allons laisser ce fichier d'en-tête vectoriel et notre code à partir de maintenant avec le reste. Et nous allons continuer à le faire à partir de maintenant. Chaque fois que nous ajoutons un fichier d'en-tête, nous le laissons simplement sauf indication contraire. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 49. Chapitre 9 (conteneurs) : les files d'attente: Dans cette vidéo, nous allons parler des files d'attente. Désormais, une file d'attente est un autre type de conteneur. Ils disent généralement le type d'arrangement «  premier entré, premier sorti ». Donc, en gros, tout ce qui se trouve devant la file d'attente devait être retiré de la file d'attente en premier. Et vous pouvez en quelque sorte penser à faire la queue pour rendre à la caisse d'une épicerie ou quelque chose comme ça. Celui qui y arrivera en premier sortira le premier. Donc, premier entré, premier sorti. Maintenant, la syntaxe est très similaire à celle d'un vecteur que nous venons de voir dans la dernière vidéo. Mais au lieu de dire vecteur, nous allons simplement dire file d'attente. Encore une fois en minuscules. En haut, nous allons y aller et inclure également le fichier d'en-tête. Et cela s' appellera simplement file d'attente et assurez-vous de le garder là pour le reste du cours. Donc en haut ici, et nous dirons que le hashtag inclut comme ça. Maintenant, allons-y, créons et travaillons avec Acute. Donc, pour cet exemple, nous allons simplement créer une file d'entiers. Ici. Nous allons dire Q, puis le type de données R avec le symbole inférieur à et supérieur à. Donc, nous allons dire, puis ensuite, nous lui donnerons un nom. Pourquoi ne pas simplement appeler cela des résultats de quiz. OK, alors allons-y et ajoutons quelques entiers à r cube. Donc, en bas, pour ce faire, nous devons dire le nom de notre file d'attente pour qu'elle sache de quoi nous parlons en premier lieu. ne voulons pas dire point, pousser et entre parenthèses, nous mettons simplement ce que nous voulons ajouter dans un point-virgule sans fil à la fin et nous disons quelque chose comme un 100. Et allons-y et ajoutons-en quelques autres que nous pouvons mettre dans le nombre que vous souhaitez. Comme. Donc, avec une file d'attente, si nous voulons imprimer quelque chose, entrez q, nous ne pouvons pas le faire. Nous l'avons fait par le passé, donc nous ne pouvons pas dire le score du quiz. Et puis entre crochets, disons deux, par exemple, avec un point-virgule à la fin si cela ne fonctionne pas. Et vous pouvez le voir ici, et si j'essayais de dire C ici, cela ne nous permettrait pas de le faire, nous obtiendrons une erreur. Alors, comment s'y prendre ? Eh bien, si vous voulez prononcer toute votre file d'attente, vous allez faire ce qui suit. Donc, tout d'abord, nous allons créer une boucle de temps, puis nous allons mettre le symbole «  non » et notre état ici, suivis du nom de notre file d'attente, des résultats du quiz. Et puis nous allons dire die, vide, tout en minuscules avec des parenthèses ouvertes et fermées, comme ça. Donc, ce que nous voulons dire ici, c'est que même si les scores du quiz sont notre q, n'est pas vide, ce champ vide renverra vrai s'il est vide et faux s' il n'est pas vide. Mais si vous vous en souvenez, parce que nous avons ce nœud ici, aura l'effet inverse. Habillez-vous bien, les résultats du quiz ne sont pas vides. Nous voulions faire ce qui suit. Et ce que nous voulons faire, c'est imprimer ce qui se trouve en tête de notre file d'attente. Et si vous vous en souvenez, le conteneur Q utilise le principe du premier entré, premier sorti. Donc parce que si on regarde ici, 100, c'est le premier, ce sera le premier que nous imprimerons. Et pour ce faire, nous allons simplement dire CL. Et ensuite, nous allons dire les résultats du quiz. Et cela va imprimer ce qui se trouve en tête de file d'attente. C'était juste des parenthèses ouvertes et fermées, comme cela dans un point-virgule à la fin. Donc, cette méthode front renvoie ici la valeur au début de la file d'attente. Et il existe également une méthode de sauvegarde pour récupérer ce qui se trouve en fin de file d'attente. Mais si nous voulons pouvoir tout obtenir, donc pas seulement l' avant ou l'arrière, tout ce qui se trouve entre les deux, nous allons devoir commencer à les retirer. Donc, comme je l'ai dit, vous pouvez penser qu' une file d'attente fait la queue quelque part. La première personne jouera à la deuxième, la troisième, à la quatrième. Et tout va se passer dans l'ordre. Et c'est comme ça que ça va se passer ici. OK ? Donc, juste en dessous, vous allez indiquer les résultats du quiz, les parenthèses ouvertes et fermées et un point-virgule à la fin. Donc moi, le diagramme à points des scores de quiz le fait, c' est qu'il supprime réellement l'élément et que le début de notre file d'attente s'en débarrasse. Ça va disparaître. Maintenant, ce qui va se passer, c'est que nous avons d'abord créé une file d'attente indiquant le type de données Q, R entre le symbole inférieur et le symbole supérieur à et lui avons donné un nom. Ensuite, nous avons ajouté des éléments en disant simplement son nom point push, et quel que soit l'ordre dans lequel nous les avons ajoutés dans l'ordre, ils figureront dans un QR, et c'est aussi l' ordre dans lequel ils sortiront. Le premier passe en premier, en deuxième, deuxième, en troisième, en troisième et ainsi de suite. Ensuite, descendez ici pour les imprimer. Parce que, comme je l'ai dit, nous ne pouvons accéder à cette première que dans cette dernière avec la méthode avant ou la méthode. Mais ici, nous utilisons simplement celui appelé front. Et nous avons dit : « Waouh, les résultats du quiz ne sont pas vides, ce qui signifie qu'il y a encore quelque chose dans notre file Nous allons imprimer ce qui se trouve au recto puis nous débarrasser de ce qui se trouve au recto en utilisant la méthode pop. Et vous pouvez reconnaître le mot pop et le mot push lorsque nous avons travaillé avec des vecteurs dans la dernière vidéo, sauf que nous avons dû enregistrer pushback in, pop back. Maintenant, avant d'exécuter notre code ici, allons-y et ajoutons une nouvelle ligne ici. Donc, quand un code, et vous pouvez le voir, nous avons imprimé 18034 du fichier. Et puis, avant de terminer cette vidéo, je vais juste vous montrer une dernière méthode. Donc, juste avant un moment en direct, si nous disons les résultats du quiz, la taille des points, l'ouverture, les parenthèses fermantes et un point-virgule à la fin. Et allons-y et imprimons-le. Donc, dites CL juste avant, il en créera un nouveau par la suite et exécutera notre code. Vous pouvez voir qu'il imprime la taille, comme nous pourrions le faire avec nos proches. Donc c'est toujours agréable. Nous avons donc 1803455 pour différents éléments ici avec l'impression ou nous obtenons cette valeur avec la méthode de taille où, mais vérifiez si elle est vide avec la méthode vide. Nous avons également appris à vérifier l'avant du cube à l'aide de la méthode du front. Et nous savons également que nous pouvons récupérer la fin de la file d'attente grâce à la méthode back, qui est écrite comme vous le pensez, où vous dites « back » en minuscules et en commençant par le début. Et si vous considérez cela comme une file d'attente dans un magasin ou quelque chose comme ça, alors ce sera la première ligne et ce sera la fin de la ligne. C'est donc un moyen facile de se souvenir la valeur que vous obtenez lorsque vous dites recto ou verso. Vous savez donc maintenant comment créer et utiliser le signal, comment ajouter des valeurs et en supprimer. Nous remarquons qu'il s'agit d'un type de contenant selon le principe du premier entré, premier sorti et nous connaissons quelques-unes des méthodes qui y sont associées. Et comme pour les autres conteneurs, il existe d'autres fonctions que vous pouvez utiliser avec cette zone qui y sont associées. Et si vous êtes intéressé, n'hésitez pas à aller les consulter de toute façon. Mais c'est tout pour cette vidéo. Mais avant de passer à la suivante, mais je veux que vous le fassiez, c'est enregistrer tout ce que vous avez, car nous allons l'utiliser dans la vidéo suivante lorsque nous parlerons d'un conteneur très similaire appelée pile. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 50. 49: Dans cette vidéo, nous allons parler d' un autre type de conteneur appelé stack. Comme vous pouvez le voir, j'ai ce code extrait de notre dernière vidéo car au cas où vous l'auriez manqué, je voulais que vous sauvegardiez ce que nous avions d' eux, car nous allons l'utiliser à nouveau dans cette vidéo. Et si vous avez oublié, ne vous inquiétez pas, allez-y et copiez ce que j'ai ici à l'écran. Maintenant, avant d'entrer dans les stocks, nous devons ajouter un autre fichier d'en-tête. Donc, en haut, nous allons dire « nourriture avec hashtag ». Et puis, entre le inférieur et le symbole supérieur à, nous allons simplement le dire comme cela. Et encore une fois, nous allons laisser cela pour le reste du cours. Assurez-vous donc que vous dites qu'ils sont maintenant là avec le code réel. Allons-y et examinons les différences entre une pile et une file d'attente. abord, la seule différence de syntaxe entre une pile et une file d'attente, car au lieu de dire q, nous allons dire stack. Est-ce facile ? Nous allons donc dire empiler. Juste comme ça. Nous pouvons laisser notre nom ici si nous le voulons. Nous pouvons même laisser ces méthodes ici si nous le voulons, car elles ont fonctionné exactement de la même manière. Et il dispose également d'une méthode push qui les place l'un devant l'autre. Cependant, une pile fonctionne et un type d'arrangement dernier entré, premier sorti. Donc, si vous voulez penser à empiler des blocs, placez une carte sur une autre et dessinez toujours par le haut. En gros, comment cela fonctionne. Donc, cette carte sera en fait comme notre dernière carte, par exemple, et ensuite nous aurons notre carte au-dessus de cela, celle du dessus et celle du dessus. Et ensuite, lorsque nous puisons dans ces éléments, nous allons repartir dans la direction opposée comme ceci. Le dernier arrivé sera le premier. Voici donc le haut de notre liste. Voici le bas. N'oubliez donc pas que maintenant notre méthode de taille fonctionne également. Nous n'avons donc rien à y changer. Maintenant, quand nous en viendrons à notre boucle while, vous remarquerez que cette méthode effrayée contient une erreur, et c'est parce que nous n' avons plus la méthode appelée front. Au lieu de cela, nous disons simplement top. Donc, le haut de notre pile est ce que nous obtiendrons lorsque nous vous disons « pop here » pour vous, sautez du haut de notre pile » , d'accord, pour que tout le reste reste exactement le même. Laissez-nous être fantastiques. Si vous voulez travailler avec une pile ou une file d'attente, peu près rien ne changera, sauf avec les méthodes que nous avons vues ici, où la fonction, vous voulez seulement la modifier au lieu de la méthode front. qui nous a donné la première valeur mise dans notre file d'attente, nous avons cette meilleure méthode parce que c'est la dernière valeur mise dans notre file d'attente, parce que nous travaillons avec un type de dernier entré, premier sorti de arrangement en matière de piles. Donc, si nous exécutons notre code ici, vous pouvez voir que tout fonctionne. Cependant, nous avons imprimé nos numéros la direction opposée à celle que nous avons faite avec notre file d'attente, car il s'agit d'une pile qui fonctionne comme un dernier entré, premier sorti plutôt que comme un premier entré, premier sorti. Donc parce que 55 était au sommet de notre liste et que c'était le premier à sortir de nos snack-suites avec 553 480 100$. Et si nous en avons quatre ici c'est parce que nous avons également imprimé la taille et que nous avons quatre éléments dedans. Maintenant, je tiens également à le mentionner parce que la méthode avant n'existe pas, pas plus que la méthode arrière. Vous ne pouvez pas obtenir cette valeur inférieure, et c'est à peu près tout pour cette vidéo. Maintenant, comme pour les autres conteneurs ou les autres fonctions et nos méthodes disponibles. Et je vous encourage vivement à les consulter si vous souhaitez utiliser une pile dans votre programme. Alors, quand voudriez-vous utiliser une file d'attente et quand voudriez-vous utiliser une pile ? Ainsi, si vous voulez un conteneur qui fonctionne selon le premier entré, premier sorti , utilisez la file d'attente. Et lorsque vous voulez le contenir, il fonctionne style dernier entré, premier sorti. Vous pouvez utiliser la pile, mais n'oubliez pas vous n'avez réellement accès qu'à la dernière valeur que vous placez dans une pile et une file d'attente, vous avez accès aux deux. Cependant, avec une file d'attente, vous ne pouvez retirer la première valeur qui a été placée avec une pile comme dernière valeur. Vous devez donc être le dernier entré, premier sorti et le premier entré, premier sorti. Mais si vous devez travailler avec ces valeurs intermédiaires, n'oubliez pas qu'ils voudront probablement simplement utiliser un autre conteneur. Nous avons déjà parlé de quelques-unes d'entre elles, mais il en existe d'autres. Donc, si cela vous intéresse, allez y jeter un œil. Sinon, nous en avons au moins une autre à venir dans une prochaine vidéo de ce cours intitulée « carte ». Alors restez à l'affût. Bref, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 51. Chapitre 10 (Boucles d'avant) : Intro aux boucles d'avant-plan: Dans cette vidéo, nous allons parler d'un nouveau type de boucle. Pour chaque boucle, ce que fait une boucle pour chaque boucle, c'est qu'elle exécute une section de code pour chaque élément d'un conteneur d' un type spécifié qui créera l'une d'entre elles. Et dans la vidéo suivante, nous verrons exactement de quoi je parle, mais je voulais juste vous donner une brève vidéo d'introduction ce qu'ils sont et ce qu'ils font. Donc, l'autre chose à noter à propos d'une boucle foreach est qu'elle copie les valeurs dans un conteneur qu'elle utilise pour son fonctionnement. Et je vais vous en montrer un exemple lorsque nous travaillerons sur ces derniers également. De plus, pour chaque boucle, parcourez uniquement un conteneur dans l'ordre. C'est quelque chose à noter, qu'il passera de l'index 0 jusqu'à la fin. Maintenant, laissez-moi vous donner quelques exemples de situations dans lesquelles vous pourriez vouloir utiliser un pour chaque boucle. Maintenant, par exemple, vous souhaitez tout imprimer dans un conteneur. Vous pouvez donc imprimer la valeur de chaque élément et peut-être voulez-vous obtenir la taille d'un tableau. Par exemple, vous pourriez avoir une variable, puis dans votre a pour chaque boucle, vous pourriez dire que pour chaque élément de notre tableau, nous allons augmenter cette variable d'une unité. Vous pouvez donc également utiliser un pour chaque boucle pour obtenir la taille d'un conteneur, titre d'exemple, de toute façon, c'est tout pour cette vidéo. la vidéo suivante, nous allons créer une boucle pour chaque boucle et travailler avec elle, ainsi que la comparer à Dans la vidéo suivante, nous allons créer une boucle pour chaque boucle et travailler avec elle, ainsi que la comparer à une boucle pour laquelle nous avons découvert par le passé. Juste pour que vous puissiez voir les différences et savoir quand vous voudriez utiliser l'un plutôt que l'autre. Alors merci de m'avoir regardé et à bientôt. 52. Chapitre 10 (Boucles d'avant) : Boucles d'avant-plan: Dans cette vidéo, nous allons créer une interface de travail pour chaque boucle et les comparer à la boucle FOR afin que vous puissiez voir la différence et savoir quand utiliser l'une par rapport à l'autre. Maintenant, si j'ai décidé de diviser une simple boucle en deux vidéos différentes, c'est parce que personnellement, j'ai trouvé chaque bouche était assez confuse, du moins comme on m'a expliqué la première fois les ont appris. Je voulais donc juste m' assurer que cela pouvait décomposer étape par étape et vraiment m'assurer que vous compreniez comment et quand les utiliser sans aucun problème. Donc, tout d'abord, nous allons commencer par créer un tableau de dix entiers. Nous allons donc dire mon tableau entre crochets ici. On va en mettre dix, comme ça. Et nous n'allons pas donner de valeur à cela ici. Puis il a dit que nous allions le faire en boucle. Donc, ici, nous allons dire que pour int, je suis égal à 0, I inférieur à dix, I plus, plus. Ensuite, à l'intérieur de notre boucle for, nous allons donner à chaque élément notre tableau et sa valeur initiale. Nous allons donc dire mon tableau à l'index. I. Tu te souviens que tu as juste mis ça entre crochets, comme si ça équivalait, non ? Maintenant, nous allons le mettre à cinq. Puis au-dessus ou pour la boucle. Allons-y et disons Sram. Et si vous vous souvenez comment l' utiliser ici, nous allons dire heure, et entre parenthèses, nous dirons non. Et si vous remarquez que nous passons la souris sur S ici et que nous prenons réellement un entier non signé. Donc, certaines personnes aiment s' assurer qu'elles recevront un int non signé et disent simplement non signé comme ceci entre parenthèses. Et ils veilleront à ce que vous obteniez une valeur positive de cette méthode temporelle. Ensuite, ici, au lieu de tout mettre sur cinq, nous allons dire rand entre parenthèses comme ça, suivi de l'opérateur modulus. Et on va le mettre 100 plus un. Et allons-y et mettons-le entre parenthèses juste pour nous assurer que l'ordre des opérations correct ou pour le définir explicitement. Et puis en bas, allons-y et créons une, une autre boucle pour imprimer notre variable. Oui, je sais que nous pourrions l' imprimer ici, mais vous verrez pourquoi nous le faisons dans un instant. Donc, ici, nous allons dire que le temps est égal à 0, moi, moins de dix. Moi en plus, en plus. Et puis entre crochets, il y aura mon index de tableau I. Et nous allons en fait dire C dans mon index de tableau, je vais créer une nouvelle ligne après chacun d'eux, comme ça. Maintenant, en dessous, nous allons faire exactement la même chose que nous avons fait dans ces deux-là pour les boucles. Ce que nous allons faire en R pour chaque boucle. Mais d'abord, lançons notre programme et veillons à ce que tout fonctionne. Comme vous pouvez le voir, nous avons dix nombres apparemment aléatoires ici, entre 1100. Et maintenant. Allons-y et commentons tout cela très rapidement. Et nous allons en fait le laisser ici, donc ne le supprimez pas. Et ensuite, en dessous, nous allons faire la même chose pour chaque boucle. Donc, ici, nous allons créer notre première boucle foreach. Et la syntaxe pour cela sera la suivante. Donc, la syntaxe pour a, pour chaque boucle ressemble à ceci. Nous allons dire quatre. Ensuite, entre parenthèses, nous allons indiquer le type de données de nos éléments, suivi d'un nom de variable, puis de deux points. Et enfin, le nom du conteneur avec lequel nous allons travailler. Donc, ici, nous aurons notre conteneur comme ça. Et au cas où vous ne seriez pas sûr de ce que je voulais dire par tout cela. Vous verrez dans une seconde quand nous le créerons, puis je reviendrai dessus. Je chargerai à la fin pour m' assurer que vous avez bien compris. Alors maintenant, allons-en et créons-en un qui fonctionne avec notre tableau. Disons que dans notre tableau, le type de données est un int. Ce sera donc le type de données de nos éléments. Donc, ici, disons pour int, alors notre nom de variable peut être ce que nous voulons. Alors allons-y et mettons quelque chose comme des œufs. Et puis après cela, mettez un deux-points suivi du nom du conteneur, qui dans ce cas est mon tableau, comme ceci. Et après cela, j'ai un ensemble de crochets frisés. Et voilà. Nous avons maintenant créé un pour chaque boucle. Alors, comment lisez-vous cela exactement ? Eh bien, je sais ce qui lie ces quatre éléments ici, mais imaginez un instant. C'est pour chaque élément de notre tableau que vous voulez créer une variable appelée x et la définir comme égale à l'élément. Donc, en parcourant notre tableau ici, x sera égal à chaque élément lors de sa boucle. J'espère donc que cela a du sens. Si ce n'est pas le cas, nous allons procéder à l'impression du résultat de ce dont je parle ici. Donc, d'abord, nous devons commencer et initialiser toutes les variables de notre tableau. Nous pouvons réellement le faire avec notre période de boucle foreach. Mais d'abord, il va falloir dire quelque chose comme ça. Nous dirons que i est égal à 0. Et puis chaque fois que nous parcourons notre boucle foreach, ce qui prendra le même temps que les éléments de notre tableau, car notre boucle foreach s'exécute une fois par élément de notre tableau. Donc, ici, nous allons dire I plus plus. Et nous dirons aussi mon tableau entre crochets ici. Nous dirons que i est égal, et allons-y et mettons-le à I. Ensuite, en dessous, nous en créerons une autre pour chaque boucle de notre tableau. Disons pour un tableau. Et dans ce bloc de code , il suffit de l'imprimer. Alors dites x line et quel est notre code. Donc, pour vous donner une meilleure idée de ce qui se passe ici, passons à mon tableau ici, en bas, et exécutons à nouveau notre code. D'accord, comme vous pouvez le voir, nous avons créé un tableau, comme nous l'avons fait par le passé avec dix entiers. Ensuite, nous avons créé un itérateur ici en créant simplement une variable appelée I et en la mettant à 0. Ensuite, nous avons dit que pour chaque entier de notre tableau, nous voulons créer une variable appelée x. Ensuite, nous avons dit que pour chaque entier de notre tableau, nous voulons exécuter ce bloc de code. Et lorsque nous faisons cela, nous voulons définir x égal à chaque élément au fur et à mesure. Donc, la première fois que x sera égal à l'élément 0, puis à un, puis à 23, etc. Maintenant, nous n'avons pas à nous inquiéter du fait que cela n'a pas été initialisé parce que nous n'avons rien fait avec x. Au lieu de cela, nous Je viens de dire mon tableau à i, j'étais 0. L'indice 0 est donc égal à I, qui est 0 pour la première fois. Ensuite, nous l'avons augmenté d'un et nous l'avons parcouru dix fois, donnant à nos éléments les valeurs de 0 à 9. Ensuite, nous en avons créé une autre pour chaque boucle. Nous avons dit que pour chaque entier et notre tableau, nous allons parcourir ce bloc de code. Je ne veux pas que x soit égal à chacun des éléments au fur et à mesure. Donc, parce que l'élément 0 était 0, x est 0, puis imprimez-le à 0. Puis la fois suivante, parce que l'élément 1 était un, X0 , X1, puis imprimez-le un et ainsi de suite. Et c'est exactement la même chose que si nous nous y intéressions et que nous l'avions déplacé vers le haut. J'ai commenté notre code ici. Et je vais aller de l'avant, couper ce qu'ils peuvent faire au hasard ici et juste le mettre sur moi et sur le code. Et comme vous pouvez le constater, nous avons imprimé de 0 à 9 à partir de nos deux boucles pour, et nous les imprimons à nouveau de 0 à 9 avec nos quatre boucles de chaque boucle. Nous avons donc fait la même chose ici qu'ici. Alors, quand voudriez-vous utiliser un pour chaque boucle au lieu d'un pour une boucle ? Eh bien, personnellement, je pense que lorsque nous initialisons les valeurs de notre tableau, cela semble beaucoup plus propre qu'une. Notre itérateur est complètement distinct. Ensuite, notre mise à jour variable étant I plus plus, se trouve également sur une ligne séparée. Il n'est pas clair non plus combien d'éléments se trouvent dans notre tableau dans ce bloc de code ici. Personnellement, je pense que cela semble beaucoup plus propre pour notre initialisation. Maintenant, qu'en est-il du moment où nous voulions simplement imprimer tout ce qui se trouvait dans notre tableau ? Eh bien, ici, nous avons dû, tout d' abord, savoir combien d'éléments s'y trouvent. Ensuite, nous avons dû créer une variable à parcourir. Ensuite, nous avons dû l' incrémenter d'une unité à chaque fois. Et nous avons également dû taper le nom de notre tableau maintenu par un index coloré par notre variable itérateur. Alors que nous venons de le dire ici pour chaque entier de notre tableau, nous allons définir cette valeur égale à chaque élément et à bam imprimé. Personnellement, si c'était moi, je ferais quelque chose. Comme je pense que cela semble beaucoup plus propre. Maintenant, dans ce cas, vous pouvez faire ce avec quoi vous vous sentez le plus à l'aise. Mais personnellement, je pense que cela semble beaucoup plus clair et qu' il est également très clair que nous voulons simplement exécuter cette boucle pour grand nombre d'éléments qui se trouvent dans notre tableau par rapport à celui-ci, où Assad se trouvait juste en lisant ceci ici. Ça dit juste que j'ai moins de dix ans. Ensuite, nous pouvons supposer que c'est le nombre de variables que nous avons dans notre tableau. Il est très clair que cela allait être exécuté pour autant d'éléments que ce qu' il y a dans notre tableau. Et il serait toujours clair s'il s'agit d' une file d'attente, d' une pile ou d'un vecteur, etc. Maintenant, allons-y et faisons encore une chose avec ça ici. Reprenons donc notre déclaration aléatoire ici. Nous allons donc dire qu'il est égal au module rand de 100 plus un. Ensuite, ici, créons une variable dont nous dirons la valeur la plus élevée. On peut donc dire le nombre le plus élevé. Cela équivaut donc à 0. Ensuite, à l'intérieur de notre boucle foreach, nous pouvons simplement dire quelque chose comme ceci. X est inférieur au nombre le plus élevé. Ensuite, nous voulons que le nombre le plus élevé soit égal. Juste comme ça. Je me souviens qu'il n'est pas nécessaire que ce soit x. On peut l'appeler comme on veut. Donc, par exemple, si je voulais que ce soit clair, ils pourraient dire renommer l'élément, non ? Donc, si l'élément actuel de notre tableau est inférieur au nombre le plus élevé, alors le nombre le plus élevé est égal à l'élément actuel. Et maintenant, ici, juste après notre boucle foreach, nous pouvons simplement dire quelque chose comme le nombre le plus élevé. Et puis avant cela, allons-y et mettons du texte. Disons l'espace numérique. Nous allons ajouter un autre opérateur d'insertion juste là. Et quand je code et que, et la raison pour laquelle j'ai imprimé 0, parce que cela doit en fait dire si l'élément actuel est supérieur au nombre le plus élevé que nous voulons définir, nombre le plus élevé égal à l'élément actuel. Et nous y voilà. Notre chiffre le plus élevé était peut-être six. Nous avons donc dit le chiffre le plus élevé de 96. Il y a donc juste un autre cas d'utilisation pour a, pour chaque boucle. Nous allons maintenant utiliser à nouveau pour chaque boucle dans ce cours. Donc, si vous ne le comprenez pas complètement , ne vous inquiétez pas. Comme je l'ai dit, nous les utiliserons à nouveau à l'avenir. Et allons-y et récapitulons rapidement celle qui convient. Et en gros, comment interpréter cette ligne ici. Donc, vous allez dire que pour toutes les parenthèses minuscules puis m, j'ai le type de données des éléments du tableau. Nous avons donc un tableau int, donc nous avons dit int, puis vous allez créer un nom de variable, et cela peut être ce que vous voulez. Donc, nous avons juste dit élément actuel, puis vous allez avoir deux points. Et enfin, le nom de votre conteneur, suivi de parenthèses et de crochets. Je suis désolée. En gros, pour chaque élément de notre tableau, nous allons créer cette variable. Et cette variable sera définie comme égale à chacune des valeurs de notre tableau au fur et à mesure de son évolution. Et cela va commencer à l'index 0 et se poursuivre jusqu'à la fin. Maintenant, dans la dernière vidéo, si vous vous en souvenez, j'ai dit que la boucle for each copie réellement le tableau pour son fonctionnement. Maintenant, qu'est-ce que je voulais dire par là ? Eh bien, laisse-moi te montrer. Donc, si je supprime ce code ici pendant un moment, si nous devions dire quelque chose comme élément actuel est égal à dix, puis créer un itérateur là-haut. Donc, si tu as dit que je suis égal à 0, et qu'ici, nous dirons « je plus », « plus ». Ensuite, imprimez votre tableau à l'index i à chaque fois. Créons donc une nouvelle ligne par la suite. Ensuite, nous allons effacer cette ligne et exécuter notre code. Vous pouvez voir que tout n'a pas changé dans notre tableau. Et c'est parce que cet élément actuel n'est ici que la copie des valeurs de notre tableau. Et si nous devions imprimer l'élément actuel ici, vous pouvez voir que nous sommes capables de le définir sur dix et de l'imprimer. Mais quand nous l'avons eu, comment il s'en est sorti il y a à peine une minute. Si nous exécutons notre code ici, vous pouvez voir qu'il n'en imprime pas dix pour chacun d'entre eux. Et c'est parce que l'élément actuel ici est juste une variable à laquelle nous voulons qu'il soit égal. Chaque élément de notre tableau. Au fur et à mesure, la première fois, il était égal à mon index de tableau 0, puis à mon index de tableau un. Mais la modification de l'élément actuel ne modifie pas réellement la valeur de notre tableau. Donc, cette variable ici est juste une copie de chacun des éléments entiers de notre tableau et n' aucun effet sur les éléments de notre tableau. Alors voilà. J'espère que cela a du sens. Si ce n'est pas le cas, nous travaillerons davantage sur chaque boucle tout au long du cours. Bref, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 53. 52: Dans cette vidéo, nous allons parler du mot clé automatique. Donc, en gros, c'est que le mot clé auto est essentiellement un espace réservé pour un type, mais qu'il ne s'agit pas d'un type en lui-même, ce qui signifie que vous ne pouvez pas y convertir un type de données différent. Maintenant, si vous utilisez le mot clé auto, la variable doit être initialisée. Et je vais vous montrer ce que je veux dire par là, ici. Donc, si je créais une variable ici et qu'au lieu de mettre le type de données directement, je me suis assis dessus. Et puis, comme ça, j'aurais une erreur parce que variables automatiques doivent être initialisées. Maintenant, permettez-moi de passer rapidement en revue certaines des informations utiles concernant l'utilisation du mot clé auto. Ensuite, nous allons entrer dans quelques exemples et voir où et quand cela peut être utile. Personnellement, je ne suis pas un gros utilisateur. Le mot clé automatique. Et si vous venez d'un autre langage de programmation, dites quelque chose comme C-Sharp par exemple et c'est essentiellement quelque chose comme avoir le mot clé var ou quelque chose comme ça. Maintenant, l'une des raisons pour lesquelles vous voudrez peut-être utiliser le mot clé auto est sa robustesse. Si l'expression est que le type a changé, compris lorsqu'un type de retour de fonction a changé, elle fonctionnera toujours. Et je sais que nous n'avons pas vraiment beaucoup parlé de fonctions, même si nous en avions une poignée par l'habitude . Mais vous verrez ce que nous entendons par là dans une prochaine vidéo. Ensuite, il y a la performance. Et ce que je veux dire par là, c'est que vous avez garantie qu'il n'y aura pas de conversion et que vous obtiendrez la garantie qu'il n'y aura pas de conversion et que vous obtiendrez le type dont vous avez besoin. Et je vais vous le montrer ici dans une minute. Ensuite, nous avons la convivialité. Et la façon dont cela entre en jeu, c'est que vous n'avez pas à vous soucier du nom de type, problèmes d' orthographe et des fautes de frappe. Donc, si vous utilisez des noms de caractères plus longs, et nous aborderons l'un d'entre eux dans la vidéo suivante lorsque nous parlerons de cartes, l'avantage du mot clé auto est qu'il est beaucoup plus court et que vous êtes moins sujet aux erreurs. Ensuite, il y a l' efficacité ou le simple taper ce mot parce que c' est un mot si court vous coupez peut être plus efficace en ce sens. Maintenant, allons-y et voyons comment utiliser le mot clé automatique. Et comme je l'ai dit, il s'agit essentiellement d'un espace réservé pour un type, bien que ce ne soit pas un type en soi. Et comment cela fonctionne, c'est que lorsque vous écrivez automatiquement, notre programme ici déterminera automatiquement le type dont nous avons besoin. Alors allons-y et examinons cela en créant différentes variables. Donc, si je voulais créer un entier, je pourrais simplement dire que le nombre automatique est égal à cinq. Et si je passe la souris dessus, vous pouvez voir que j'ai créé une variable entière. Et si nous en avons fait un flotteur comme celui-ci, vous pouvez voir que c'est maintenant un char. Et si nous en faisons quelque chose comme ça, vous pouvez voir qu'il se transforme automatiquement en double. Donc, comme je l'ai dit, vous pouvez simplement utiliser ce mot clé pour qu'il détermine automatiquement le type dont vous avez besoin. Permettez-moi de le remplacer rapidement par une encre. Et en fait, nous allons simplement l'appeler directement. Et ici, nous allons dire quelque chose comme numéro automatique, café est égal à un nombre, juste comme ça. Et maintenant, cette valeur sera automatiquement copiée ici, comme nous l'avons vu par le passé. Et vous pouvez voir qu'il s' agit automatiquement d'une variable entière. Et c'est un petit exemple très simple de cas où cela peut s'avérer utile. Parce que maintenant, si nous allions de l'avant et changeons le type de données pour dire un nombre flottant et que nous faisions quelque chose comme ça. Vous pouvez voir que cela devient automatiquement un flotteur. Nous n'avons même pas eu à modifier notre code ici. Et puis, supposons que nous voulions avoir du code pour imprimer un tableau, ce que nous avons fait par le passé. Alors laissez-moi commencer et supprimer cela rapidement. Ici, nous allons dire dans mon tableau. Et puis les crochets indiqueront quelque chose comme cinq. Juste comme ça pour créer un tableau d'entiers de cinq variables. Alors allons-y et passons à chacune de ces valeurs K. Disons donc quelque chose comme ça. Bien, maintenant, ils ont tous les cinq une valeur initiale. Et rappelez-vous que si vous le souhaitez, vous pouvez simplement supprimer de ce numéro ici, non, déterminer automatiquement que nous voulons cinq valeurs dans la liste. Ensuite, ici, nous pouvons imprimer tout ce qui se trouve dans notre tableau en utilisant une boucle pour chaque, qui fonctionnera automatiquement quel que soit le nombre d' éléments contenus dans notre tableau. Nous pourrions dire quelque chose comme quatre x deux-points dans mon tableau. Ensuite, nous pourrions simplement dire C sur X sur la ligne. Et après avoir exécuté le code, comme nous le savons par le passé, cela va se poursuivre et tout imprimer sous forme d'art, n'est-ce pas ? Maintenant, même si ici dans un si petit morceau de code, il est très évident que nous travaillons avec un tableau d'entiers. Une chose que nous pourrions faire, c'est simplement dire auto, et maintenant nous n' avons même plus à nous inquiéter à ce sujet. Cela va automatiquement savoir quel type de données se trouve dans notre tableau. Nous n'avons pas à y penser. Si nous avions un plus gros morceau de code ici, nous n'avons pas à revenir en arrière et vérifier le type de données que nous utilisons. Nous le savons déjà ici même. Nous voulons mettre le type de données de notre conteneur. Quoi qu'il en soit, le simple fait de dire automatique sera souvent plus facile, surtout si nous travaillons avec un type de données plus complexe, vous le verrez dans la vidéo suivante. Lorsque vous faites quelque chose comme ça, c'est probablement l'un de mes cas d'utilisation préférés pour ce mot clé. Je peux juste dire auto, je n' ai pas à y penser. Je sais que je veux le type de données de toute façon. Et si vous vous souvenez d'ici, nous savons qu'il n'y aura aucun type de conversion. Il va juste obtenir le type de données exact dont nous avons besoin. Et c'est ce que nous voulions mettre ici de toute façon. Et aussi, disons qu'en fin de compte, selon la raison d'être de notre tableau, nous nous sommes dit : « Vous savez quoi, je ne vais plus être capable d'utiliser des nombres entiers pour ce que je fais. J'ai besoin de flotteurs. Eh bien, nous pourrions simplement les modifier pour en faire une valeur flottante, comme ça. Et vous pouvez inscrire les chiffres que vous n'étiez pas là, sans vraiment faire de différence. Et bon, regarde ça. Je n'ai même pas besoin de modifier mon code ici. C'est donc fantastique. Cela étant dit, utilisation de l'automobile présente certaines lacunes, et je tiens simplement à vous en informer également. De plus, comme je l'ai dit, je n'utilise pas beaucoup l'automobile personnellement, mais je sais qu'il y a beaucoup de monde qui le fait. Et la plupart du temps, si vous lisez le code de quelqu'un d'autre, il y a de fortes chances que vous voyiez utiliser le mot clé auto. Et j'ai même vu certaines personnes utiliser fonction automatique et elles ne tapent même pas là, tapent du tout. Il suffit de dire auto et l'utiliser pour à peu près tout. Maintenant, personnellement, supposons que nous créons une variable comme celle-ci et que x est égal à cinq. Maintenant, je sais que c'est un entier. Je peux le dire. Je jette un coup d'œil très rapide. Je n'ai même pas besoin d'y penser, mais si je tape ici, eh bien, oui, je peux probablement déduire que c'est un entier en vérifiant ce numéro de sondage ici. Ou si j'avais quelque chose comme ça où nous disons auto. L'égal à x, eh bien, je ne sais même pas ce qu'est b à moins que je ne passe ici et que je passe la souris dessus juste pour découvrir que c'est un entier car ici, il y a aussi un entier. Et je sais qu'au début, j'ai dit, eh bien, si nous devions changer cela d'un int à un float, alors nous n'avons pas à changer cette racine ici. Mais que se passerait-il si nous avions une méthode qui nécessitait le type d'origine ? Maintenant, nous allons devoir passer en revue et découvrir quelles méthodes ont toutes été gâchées par cela. Et gardez à l'esprit quel est le nouveau type de données, etc. Et ça peut devenir assez compliqué. Personnellement, je préfère voir le type dans la plupart des cas, mais n'hésitez pas à l' expérimenter vous-même et à voir ce que vous préférez faire. Cependant, comme je l'ai dit, pour de tels cas, en particulier lorsque je travaille avec des types de données plus complexes où je sais que je veux juste que le type de données exact de mon conteneur se trouve ici. Je pourrais aussi bien dire auto, c'est beaucoup plus facile. Je n'ai pas vraiment besoin d'y penser. Et si, pour une raison quelconque, mon type de tableau changeait ici, et que je suis en train d' imprimer ces valeurs de toute façon parce que je n'ai pas de méthodes spécifiques ici. Eh bien, je peux juste dire auto. Je n'ai pas besoin d'y penser. Je n'ai pas à m'inquiéter de changer cela plus tard. Ça va marcher de toute façon. C'est tout pour cette vidéo. Je voulais juste vous faire prendre conscience de ce qu' est le mot clé auto et de ce que sont ces fork ? Parce que je sais pertinemment que si vous vous lancez dans la programmation, vous verrez le mot clé auto. Si vous venez d'un autre langage de programmation, il y a de fortes chances que vous ayez vu le mot clé var et nous nous demandons si C Plus Plus avait quelque chose de similaire. Alors, tu y vas. J'espère que vous avez bien compris comment utiliser le mot clé auto et à quoi il sert en gros Il vous suffit de l'ajouter à notre programme ici pour déterminer le type de données dont nous avons besoin par lui-même. Et vous ne voulez pas avoir à le dire explicitement. Mais si vous voulez que votre type de données soit écrit explicitement, eh bien, il vous suffira de le mettre vous-même. Quoi qu'il en soit Merci de m'avoir écouté , et à bientôt. 54. 53: Dans cette vidéo, nous allons parler d' un autre conteneur appelé les cartes. Désormais, les cartes et C plus plus sont un type de conteneur qui stocke des éléments et de manière non cartographiée où vous avez une clé et une valeur mappée. Désormais, la valeur de la clé est généralement utilisée pour trier et identifier de manière unique les éléments de votre conteneur, tandis que la valeur mappée stocke le contenu associé à cette clé. Maintenant, plutôt que de vous confondre avec un tas de cartes, créons-en une nous-mêmes. Et avant de le faire, vous devez ajouter ce fichier d' en-tête qui n'est qu'une carte. Alors allons-y et commençons. La syntaxe d'une carte est maintenant la suivante. Vous allez d'abord dire carte, entièrement en minuscules, le symbole inférieur à, suivi d'un type de données qui sera associé à votre clé. Donc, comme ça, vous allez avoir une virgule suivie du type de données de votre carte. Donc, quand le symbole est supérieur à, et après cela, vous aurez le nom de la carte suivi d'un point-virgule. Donc, comme vous pouvez le voir, cela ressemble beaucoup à la création d'un vecteur, d'une file d'attente ou d'une pile. Cependant, au lieu d' avoir un seul type de données, nous devons maintenant nous rappeler que votre type de données clé consiste généralement à trier et à identifier de manière unique le type de données mappé dans ces types de données. différent d'ailleurs. Vous n'avez donc pas à le stocker, juste des extrémités. Vous pouvez le stocker dans une chaîne ou essentiellement ce que vous voulez. Alors allons-y et créons une carte. Et nous allons continuer et baser cela sur l' annuaire téléphonique dans notre cas, juste parce que tout le monde sait ce qu'est un annuaire téléphonique. Donc, j'espère que ce sera plus facile à comprendre de cette façon. Donc, ici, nous allons dire carte, puis le symbole «  moins que ». Ensuite, nous allons identifier de manière unique chaque personne figurant dans l'annuaire téléphonique par son nom. Alors allons-y et disons simplement chaîne, comme cette virgule. Ensuite, le numéro de chacun sera stocké sous forme de nombre entier. Nous allons donc dire int. Nous allons appeler cet annuaire téléphonique. Juste comme ça. Donc, ici, nous avons notre carte vide. Ensuite, ici, nous allons ajouter quelques éléments à notre carte. Très bien, alors allons-y et ajoutons quelques éléments à notre carte. Et pour ce faire, nous allons simplement prononcer le nom de notre annuaire cartographique. Ensuite, nous allons utiliser le modificateur d'accès des membres. Nous allons donc dire point là, insérer toutes les minuscules d'ailleurs. Ensuite, entre parenthèses, nous allons mettre le type maintenant parce que notre carte contient deux types de données différents comme ceux qui sont connectés. C'est ce qu'on appelle un payeur. Ainsi, un parent et C plus plus ne sont essentiellement qu'un conteneur qui stocke deux valeurs. Et ces valeurs peuvent ou non être du même type de données, ici, nous allons dire insertion de points du répertoire téléphonique. Et ensuite, nous allons dire cheveux, tout en minuscules ici. Et puis un symbole inférieur à suivi des mêmes types de données que ceux de notre carte. Donc, si vous le souhaitez, vous pouvez simplement les copier et les coller. Mais nous allons le supprimer, juste essayer de nous entraîner ici, juste comme ça. Et puis, entre parenthèses, nous devons mettre les valeurs que nous voulons insérer dans la chaîne et la chaîne. Mettons simplement un nom ici, quelque chose comme une virgule Jack, puis la valeur entière. Et nous pouvons simplement ajouter n' importe quel numéro à dix chiffres que nous voulons représenter leur numéro de téléphone. Ensuite, nous allons simplement mettre un point-virgule à la fin, et nous allons ajouter quelques chiffres supplémentaires. Et au lieu de taper tout cela à nouveau, je vais simplement copier et coller cela plusieurs fois. Ensuite, nous passerons en revue chacun de ces huit noms de clé différents. Et vous voudrez que cette première valeur soit unique pour tout le monde. Vous ne voudriez donc pas mettre le nom de Jack et plusieurs allèles. Et si vous créez un annuaire téléphonique, vous devriez avoir un nom de famille, par exemple, mais comme nous ne travaillons qu' avec quelque chose de petit comme ici, vous avez tous compris. Nous allons donc dire Jack, John, Pam, et quelque chose comme ça. Et je vais donner à chacun de ces huit numéros différents. Et n'hésitez pas à ajouter les chiffres que vous voulez plutôt que d'avoir à copier exactement ce que j'ai ici, car cela ne fera aucune différence pour notre exemple. Maintenant, et si nous voulons imprimer la carte ? Eh bien, nous pourrions le faire en utilisant un pour chaque boucle. Donc, si nous voulons dire et puis nous pouvons dire paire, suivie du symbole inférieur à, puis de la déformation. Et le symbole « plus grand que ». Et ensuite, nous allons dire personne, espace, espace deux-points, nom de notre carte, il y avait un annuaire téléphonique et puis un crochet bouclé ouvert et fermé, comme ça. Ensuite, nous pouvons imprimer chacune d'elles, et je vais vous montrer comment procéder. Nous allons donc dire CO, suivi de personne, car c'est la variable que nous utilisons pour accéder à chacune d'entre elles. Nous allons dire régime. Et puis remarquez qu'il en résulte un premier et un second. La première est cette première valeur étant notre chaîne, ce sera donc leur nom. Et puis la seconde serait la valeur entière, ou dans ce cas, le nombre de chacun. Donc, nous allons d'abord dire personne point, puis ensuite, nous allons mettre un espace comme celui-ci. Ensuite, nous dirons personne à cette seconde, suivi de la ligne N, juste comme ça. Et si nous exécutons notre code ici, vous pouvez voir que tous nos numéros sont en fait foirés. Maintenant, pourquoi ? Eh bien, comme je l'ai déjà mentionné, un entier ne peut contenir qu' une certaine plage, puis éventuellement un enveloppement et aller de l'avant. Nous en avons parlé dans une vidéo précédente. Alors, comment pouvons-nous résoudre ce problème ? Eh bien, c'est un excellent exemple de cas dans lesquels vous souhaitez rechercher un type de données différent pour répondre à vos besoins et des erreurs qui peuvent survenir si votre type de données est trop court pour cela, la valeur que vous êtes en essayant de détenir, auquel cas ici, ma valeur la plus élevée que j'essaie détenir ses plus de 8 milliards de dollars. Et si je passe la souris dessus, vous pouvez voir qu'il suppose que cette valeur est un poumon. Poumon. Et comme nous n'allons donner personne une valeur de numéro de téléphone négative, nous pouvons tout aussi bien rendre cette variable non signée. Donc, pour régler ce problème, nous allons dire « non signé », long », juste comme ça. Et nous allons le copier et le coller pour chacun d'eux. Ainsi, assurez-vous de le copier pour chaque élément que nous avons ajouté, ainsi qu'un R pour chaque boucle. Nous avons donc créé une carte contenant toute la chaîne du jour et une chaîne longue, longue non signée , qui peut contenir un très grand nombre entier positif. Et nous appelons cette carte un annuaire téléphonique. Nous avons ensuite inséré plusieurs éléments en prononçant le nom de notre carte suivi de cette méthode d'insertion. Et puis notre type de données était une paire qui, comme je l'ai dit, correspond à deux types de valeurs différents, ou peut contenir deux types de valeurs différents. Je devrais dire, comme nous aurions pu créer les deux, une chaîne ou un int ou tout ce que nous voulons. Mais dans ce cas, nous définissons une chaîne et un long, long non signé pour représenter un annuaire téléphonique. Ensuite, ici, nous avons simplement créé une boucle foreach simple dans laquelle nous avons indiqué pour chaque paire de chaîne et un long, long non signé dans notre annuaire téléphonique ou dans un conteneur, ici une carte. Dans ce cas, nous voulons créer une variable appelée person et les définir comme égales à chaque élément au fur et à mesure que nous la parcourons. Nous pouvons donc imprimer le point de personne en premier, qui sera notre première valeur ici et notre paire, puis nous ajoutons un espace et ensuite nous imprimons la personne en second, ce qui est notre deuxième valeur ici, suivi de la création d'une nouvelle ligne. Et si nous exécutons à nouveau notre code, vous pouvez voir que cela fonctionne désormais très bien. Et nos chiffres sont ceux que nous avons saisis ici parce qu' un long, long non signé peut contenir une valeur aussi importante. Maintenant, remarquez à quel point ce type de données prend beaucoup de place et, franchement, il a l'air un peu moche. Eh bien, il existe un moyen simple de résoudre ce problème en utilisant le mot clé auto dont nous venons parler dans la dernière vidéo. Nous pouvons simplement dire auto, et maintenant nous n'avons plus besoin de mettre toutes ces choses supplémentaires. Et si nous exécutons notre code, vous pouvez voir qu'il fonctionne parfaitement sans aucun problème. En tant que mot-clé automatique, nous avons automatiquement déterminé le type de données exact dont nous avions besoin. Alors, à quel point est-ce génial ? Et ça a l'air bien plus propre que ça, à mon avis. Cependant, vous pouvez le faire d'une manière ou d'une autre. Cependant, juste pour vous montrer quelque chose, nous ne pouvons pas mettre automatique ici car cela ne fonctionnera pas. Voici donc un exemple de cas où vous ne pouvez pas utiliser le mot clé auto. Et au lieu de cela, nous devons mettre la valeur directement. Alors, vous l'avez. Il existe un moyen simple de créer une carte, d'ajouter des éléments et d'utiliser un pour chaque boucle avec une carte afin d'imprimer les valeurs qu'elle contient. Maintenant, avant de terminer cette vidéo, je vais juste vous montrer quelques méthodes supplémentaires, que vous pouvez utiliser avec votre conteneur de cartes. Mais comme toujours, il y en a encore beaucoup d'autres. N'hésitez donc pas à les consulter si vous décidez d'utiliser une carte dans l'un de vos programmes. La première chose que nous allons examiner est de savoir comment supprimer un élément de notre carte. Mais avant cela, je vais simplement ajouter un commentaire supplémentaire ici. Créez une carte. Et puis, ici même, nous allons supprimer la colonne des montants. Très vite, si vous vous souvenez qu'au début de la vidéo, j'ai dit qu'une carte est présentée un peu comme une vraie carte. Nous allons avoir des valeurs clés, puis des valeurs mappées dans cette clé, non seulement pour trier les éléments de votre conteneur, mais également pour localiser les éléments dans votre conteneur. Donc, ici même, si nous voulons supprimer un élément de notre conteneur, nous avons simplement besoin de connaître la clé de cet élément. Et laissez-moi vous montrer comment procéder. Donc, ici, nous allons dire annuaire téléphonique étant le nom de notre carte, effacement par points. Ensuite, entre parenthèses, nous allons simplement mettre la valeur clé de l'élément que nous voulons supprimer. Supposons que John, pour une raison ou une autre, ait quitté la ville et que nous n'ayons plus besoin de son numéro dans notre annuaire téléphonique. Eh bien, nous pouvons simplement mettre John entre guillemets parce que nous travaillons avec une chaîne et que nous mettons un point-virgule à la fin. Maintenant, lorsque nous exécuterons notre code, John ne figurera plus dans notre annuaire téléphonique. Donc, juste là, c'est ainsi que vous supprimez des éléments d'un. Et laissez-moi vous montrer autre chose sur cette méthode également. Donc, si nous allons de l'avant et que nous copions cette ligne ici où nous avons inséré John et/ou l' annuaire téléphonique et que nous l'avons collée comme ceci et que nous donnons celui-ci une couleur différente. Comme ça. Et exécutez notre code. Vous pouvez remarquer qu'aucun des deux John n'existe, et c'est parce que cela supprimera en fait tous les éléments avec cette clé. Il existe un autre exemple de la raison pour laquelle vous souhaitez vous assurer que chaque élément de votre conteneur de carte possède une valeur de clé différente. Maintenant, allons-y et examinons une dernière méthode que nous pouvons utiliser avec les cartes ici. Maintenant, c'est juste le dernier que je vais vous montrer, souvenez-vous qu'il y en a beaucoup d'autres si cela vous intéresse. Donc, avec celui-ci, nous allons nous permettre d'imprimer le numéro de téléphone de la personne que nous recherchons. Un autre excellent exemple de la raison pour laquelle vous souhaitez donner à chacun une clé spécifique. Et je vais en fait supprimer ce John supplémentaire que nous avons ajouté à notre annuaire téléphonique ici. Donc, ici, nous allons dire élément basé sur. Ensuite, en bas, tout ce que nous avons à faire en tant qu'annuaire téléphonique de PDG. Et puis, entre parenthèses, mettez sa valeur clé entre guillemets ici, parce que nous travaillons avec des chaînes pour notre valeur clé, je peux dire, Hé, obtenons le numéro de Tams, juste comme ça. Et nous imprimerons le numéro de Pam. Et je vais en fait commenter notre boucle foreach juste pour qu'elle ne prenne pas de place lorsque nous exécutons notre programme. Et si je lance notre code , on y va. Il y a le numéro des proxénètes juste là. Alors, tu y vas. J'espère que vous avez maintenant une compréhension de base du fonctionnement des conteneurs de cartes dans C plus plus et une compréhension de base de leurs fonctionnalités. Devriez-vous l'utiliser dans un futur de vos programmes ? tout cas, j'espère que vous avez apprécié la vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 55. Chapitre 10 (Boucles d'avant) : itérateurs: Dans cette vidéo, je vais vous donner une introduction très basique ou très brève aux itérateurs. Et honnêtement, je n'allais même pas lancer ça dans le cours C plus plus pour les débutants, mais je le vois tellement souvent que j'ai décidé de le mettre là-dedans. Donc au moins, vous savez ce que c' est quand vous le rencontrez. Cependant, l'exemple que je vais donner n'est pas vraiment le meilleur cas d' utilisation. Mais comme je l'ai dit, je le vois tout le temps. Donc, je veux juste m'assurer que vous ne soyez pas complètement surpris lorsque vous le voyez très tôt, lorsque vous commencez à créer vos propres programmes et à regarder code d'autres personnes pour référence. Alors allons-y. Tout d'abord, qu' est-ce qu'un itérateur ? Un itérateur est un objet utilisé pour effectuer itération sur les éléments d'un conteneur. Quoi qu'il en soit, il y a l' idée de base de ce qu'est un itérateur. Comme je l'ai dit, c'est juste un adjectif utilisé pour itérer sur des éléments d'un conteneur, ce que nous avons fait par le passé. Mais maintenant, je vais vous montrer comment procéder en utilisant un véritable objet itérateur. Et je vais également vous montrer comment faire la même chose en utilisant un pour chaque boucle, comme nous l'avons fait par le passé, juste pour que vous puissiez voir les comparaisons entre elles. Et comme je l'ai dit, ce n'est vraiment pas le meilleur cas d'utilisation pour cela. Et normalement, j' utiliserais juste une boucle pour chaque boucle. Et tu verras ce que je veux dire ici dans un instant. Donc, tout d'abord, nous allons créer un vecteur. Je vais taper comme ça. Ensuite, nous appellerons simplement ces numéros et leur donnerons la valeur suivante. Donc, entre crochets, allez-y et insérez n'importe quelle vue à cinq chiffres. Je vais juste dire 12345 pour des raisons de simplicité. Et nous avons examiné comment procéder par itération à l'aide de deux méthodes différentes. Donc, si vous vous en souvenez, nous l'avons fait avec une boucle pour, et nous l'avons fait avec une pour chaque boucle. Maintenant, pour le faire avec un pour chaque boucle, si vous vous en souvenez, il suffit de dire quelque chose comme un numéro de port, des deux-points, comme ceci. Et puis un bloc de code d'entrée a été imprimé comme ça. Et cela fonctionnera très bien. Cela imprimera tout dans notre vecteur numérique. Mais comment faire cela avec un itérateur ? Eh bien, d'abord, nous allons commencer et déclarer un itérateur. Et pour ce faire, nous allons retaper le type de conteneur, qui est un vecteur de type int suivi de deux deux-points. Et puis nous allons dire itérateur en minuscules, comme suit. Ensuite, nous avons besoin d'un nom et d'une convention de dénomination commune. Le nom très courant si vous effacez ou un itérateur va simplement être IT. Et cela seul est une déclaration pour notre itérateur. Donc je vais trouver ça et appeler cette déclaration d'itérateur pour nos chiffres comme ça. Et je le fais juste pour référence. Vous n'avez donc pas à copier cette partie si vous ne le souhaitez pas. Et laissez-moi zoomer ici pour vous les gars. Mais en dessous, émigrez et initialisez pour cela. Donc, initialisation itérée, comme ça. Nous pouvons le déclarer et l'initialiser sur la même ligne. C'est ce que dit l' initialisation de l'itérateur dans la déclaration pour notre vecteur numérique. Et ce que nous ferions pour y parvenir, c'est dire type de conteneur, suivi des deux itérateurs de Colin, du nom, encore une fois. Ensuite, nous ferions un suivi avec l'endroit où nous voulons que notre itérateur commence. Essentiellement, la façon dont nous le ferions dans ce cas serait de prononcer le nom. Nous sommes des conteneurs, nous sommes morts. Encore une fois. Maintenant, c'est la syntaxe de base pour déclarer et initialiser un itérateur. Syntaxe des itérateurs. N'oubliez pas que la syntaxe est essentiellement la règle pour quelque chose, essentiellement le conteneur. Et ensuite tu vas devoir le faire, Colin est comme ça. Je vais dire itérateur, suivi du nom de l'itérateur. Je vais juste choisir ici. Ensuite, si vous voulez l'initialiser, vous allez dire égal, suivi du point du nom du conteneur. Et ensuite, si vous voulez le régler à la première valeur, vous pouvez au moins dire que cela a commencé. Cependant, il existe d'autres méthodes, vous n'avez donc pas à le démarrer dès le premier élément du conteneur. Quoi qu'il en soit, je vais aussi commenter celui-ci. Et nous allons simplement commencer par la déclaration. Donc, en bas, nous allons juste dire vecteur dans l'itérateur de Colin, IT et nous devrons mettre un point-virgule à la fin. Très bien, alors on y va. Nous avons déclaré notre itérateur. Maintenant, allons-y et créons une boucle pour. Thrill, notre vecteur là-haut. Et en fait, je vais juste copier ce code et le déplacer ici pour que nous puissions rester à l'écran pour vous. Et je vais enlever celui-ci d'ici. Et je pourrais le commenter juste pour que cela n' apparaisse pas réellement sur console. Et nous allons créer une boucle for pour fonctionner avec notre vecteur. Nous allons donc dire quatre. Ensuite, à l'intérieur, nous allons simplement initialiser notre itérateur que nous avons déjà créé. Je vais dire que c'est un régime à chiffres égaux. Encore une fois. Comme je l'ai dit, cela va régler notre itérateur à la toute première valeur du vecteur R étant un. Ensuite, pour une affection, nous allons dire essentiellement pendant l'informatique, alors commencez par vous attaquer à l'informatique ici. Être notre itérateur n' est pas égal à. Les chiffres et les vrais rapides et itérateurs indiquent simplement l'emplacement en mémoire des éléments de notre conteneur, ce qui peut être un peu déroutant. Et nous y reviendrons un peu plus en détail lorsque nous parlerons des pointeurs à l'avenir. Mais pour l'instant, sachez simplement que cela indique essentiellement que l'emplacement en mémoire n'est pas la même chose que notre élément réel. OK ? Donc, en gros, nous voulons créer un itérateur qui commence à la toute première valeur ici. Et puis alors que notre itérateur n'est pas égal au dernier élément ou ne pointe pas vers le dernier élément. Je pourrais dire que nous voulons exécuter notre code. Maintenant, après cela, nous pouvons simplement dire IT plus, plus le nom d'un générateur plus, plus. Et cela fonctionnera très bien. Maintenant, cette fin de méthode n'est pas réellement la dernière valeur de notre conteneur. En fait, il s'agit essentiellement de la valeur après cela, si elle existait telle que nous pouvions l'envisager. Donc, en gros, nous ne pointons vers une valeur qui n'existe pas. Donc ça va commencer par celui-ci. Nous y voilà, 2345. Et puis, une fois qu'il pointe vers le sixième élément imaginaire, il serait égal à cette fin. Eh bien, ce n'est pas égal à cela. Nous voulons continuer à exécuter notre code. J'espère donc que cela a du sens. En gros, s'il n'y avait pas de sixième élément imaginaire ici, c'est à cela que fait référence ici. Donc, ce que nous soulignons, tout ce qui se trouve dans notre conteneur et nous voulons faire ce qui suit et le parcourir. Ensuite, nous allons avoir des crochets bouclés ouverts et fermés. Et puis à l'intérieur, nous allons simplement imprimer maintenant j'en crée un nouveau. Maintenant, remarquez que nous avons reçu cette erreur et c'est parce que nous devons mettre un astérisque avant de le dire ici. Maintenant, pourquoi avons-nous cet astérisque ? Et nous y reviendrons un peu plus en détail lorsque nous parlerons de pointeurs. Mais essentiellement, rappelez-vous comment j'ai dit qu'un itérateur pointait vers l'emplacement en mémoire où se trouve cet élément. Eh bien, cet astérisque nous permet de déréférencer ce pointeur. Donc, au lieu de nous rendre l'emplacement et la mémoire, nous récupérerons la valeur réelle. J'espère donc que cela a du sens. Si ce n'est pas le cas, nous en reparlerons plus tard dans le cours. Mais sachez que pour l'instant, nous l'avons mis ici pour obtenir la valeur réelle et non l'adresse de localisation de la mémoire. Donc, si nous exécutons notre code ici, et comme vous pouvez le voir, nous l'imprimons 12345 sur des lignes séparées. Et si vous vous demandez comment j'ai zoomé sur la console ou plus loin dans Visual Studio ici, vous pouvez maintenir la touche Ctrl enfoncée et utiliser la molette de défilement pour zoomer en avant et en arrière. Cependant, sur la fenêtre de la console, cela ne fait qu' augmenter et diminuer la taille de la fenêtre dans son ensemble, ce qui, je suppose, suppose que vous êtes dans un sens détourné. Quoi qu'il en soit, nous avons imprimé 12345 sur des lignes séparées. Comme je l'ai dit, dans ce cas précis, je ne le ferais jamais personnellement. Et la plupart du temps, vous le verrez même écrit où la déclaration et l'initialisation se situent sur la même ligne. Donc, si on copie et colle ça ici, et qu'on ne veut pas mettre le nom deux fois. Donc, juste comme ça et supprimez-les ici. Cela fonctionnera très bien. Et la plupart du temps, c'est ainsi que vous verrez les choses se faire, comme pour la déclaration de l'itérateur et son initialisation sur la même ligne exacte. C'est ainsi que je vais procéder et maintenant, comme je l'ai dit, dans ce cas, vous ne voudriez probablement jamais faire cela parce que cela fonctionne beaucoup mieux pour chaque boucle que nous avons ici . Ça a l'air tellement plus propre. Mais comme je l'ai mentionné au début de la vidéo, je vois ça tout le temps. Donc je voulais juste m'assurer que vous sachiez ce qui se passe ici. Donc, en gros, dans notre boucle for, nous créons un itérateur en saisissant le type de conteneur ici, suivi de deux deux-points, puis du mot clé itérateur, puis du nom de leur itérateur, que vous verrez souvent comme informatique. Mais vous pouvez mettre ce que vous voulez, suivi de l'opérateur d'affectation pour l'initialiser. Ensuite, nous inscrivons le nom réel du conteneur et lui donnons un point de départ. Parce que, comme je l'ai dit, un itérateur pointe vers l'emplacement en mémoire où se trouve un élément dans un conteneur. Donc, en gros, nous disons : « Hé, commencez par le tout premier élément. Ensuite, nous avons dit, alors que notre itérateur ne pointe essentiellement pas vers l'élément après le dernier. C'est donc notre dernier élément. S'il pointait vers un six éléments imaginaires, c'est à cela que ce nombre est acheté et serait égal à cela. Eh bien, ce n'est pas ce que nous voulons dire. Nous voulons aller de l'avant et augmenter le nombre d'itérations par un, ce qui nous permettra de progresser sur la base de nos éléments ici. Ensuite, nous voulons imprimer la valeur réelle laquelle pointe notre itérateur et sur une nouvelle ligne à chaque fois. Et nous avons travaillé avec pour les boucles, et ainsi de suite. Vous devez donc comprendre les bases. En gros, nous sommes capables de déclarer et d'initialiser une variable ici. Nous avons une condition ici, puis notre variable update, qui est l'endroit où nous avons mis à jour notre itérateur dans ce cas. Maintenant, bien que cet exemple ne soit pas génial et qu'il s'agisse d'une utilisation très basique d'un itérateur, il existe de nombreuses autres méthodes que vous pouvez utiliser avec lui pour faire différentes choses. Il existe des cas d'utilisation réels dans lesquels vous souhaiteriez utiliser un itérateur. En effet, chaque conteneur n' enregistre pas ses données de manière continue, où tout est en ordre et vous pouvez simplement utiliser une boucle de base à quatre. Et parfois, un itérateur peut être nécessaire. Si vous travaillez avec un autre type de conteneur qui ne le stocke pas sous forme de valeurs dans un ordre séquentiel, comme le fait un vecteur ou un tableau. Un itérateur peut être quelque chose que vous devrez utiliser et étudier un peu plus. Mais il s'agit d'un aperçu de base de l'un d'entre eux, ainsi que d'un exemple de base de la façon en créer et d'utiliser un exemple, vous verrez peut-être assez fréquemment si vous commencez à regarder le code d'autres personnes, surtout de toute façon, c'est essentiellement tout pour cette vidéo. Je veux juste m' assurer que vous saviez ce qu'est un itérateur et que vous avez une compréhension de base de ce à quoi pourrait ressembler son utilisation, afin de ne pas être complètement pris au dépourvu lorsque cela se présente à vous ne pas être complètement pris au dépourvu . Quoi qu'il en soit, merci d'avoir regardé. J'espère que vous avez apprécié la vidéo et, comme toujours, je vous verrai dans la prochaine. 56. Chapitre 11 (Enums) : Intro aux Enums: Dans cette vidéo, nous allons parler d'énumérations. Et je vais juste vous donner une brève introduction dans cette vidéo. Et puis, dans les trois prochaines vidéos, nous allons en fait les créer et les utiliser. Maintenant, normalement, lorsque vous apprenez un langage de programmation, vous allez apprendre assez tôt. Cependant, j'ai décidé de les attendre jusqu'à présent parce que, d'une part, je n'ai pas trouvé vraiment nécessaire vous virer trop tôt dans le cours. Et je les ai trouvés un peu confus lorsque j'ai appris la programmation pour la première fois. J'ai donc pensé que je vous laisserais acquérir une compréhension de base de la langue avant que nous ne les y ajoutions. Mais vous les verrez très souvent. Ils sont utiles. Alors allons-y et voyons ce qu'est exactement une énumération. Une énumération, abréviation d'un type énuméré sera en fait notre premier type de données défini par l'utilisateur. Et vous verrez ce que je veux dire par là dans la vidéo suivante, lorsque nous en créerons un. Et ce qu'est une énumération, c'est essentiellement un ensemble de valeurs constantes auxquelles est associé un nom que vous pouvez utiliser dans votre code. OK, il en va de même pour le type de données défini par l'utilisateur. Et c'est un groupe de constantes avec une valeur intégrale. OK ? Cela signifie donc qu'il va extraire les nombres entiers, ou un nombre entier, devrais-je dire, auquel est associé un nom. Et comme ces constantes sont associées à un nom, cela rend votre code beaucoup plus lisible, ce qui en est à peu près le principal cas d'utilisation. Et vous pourrez en voir un exemple dans l' une des prochaines vidéos ici. Maintenant, je sais que nous n'avons pas vraiment parlé de constantes depuis longtemps. Je vais juste vous donner un bref rappel ici également. Alors, qu'est-ce qu'une constante ? Eh bien, c'est juste une variable qui ne peut pas être modifiée. Donc, si vous pensez à en créer une, vous allez dire constante, puis vous allez simplement créer une variable comme d'habitude. Nous pourrions donc dire nombre constant et le fixer à cinq. Une chose dont je n'ai pas parlé lorsque nous avons parlé de constantes pour la dernière fois, c'est que lorsque vous nommez une constante, vous verrez souvent des personnes et vous lui donnez un nom en majuscules, comme ceci pour préfixe spécial. pour indiquer que c'est une constante. Donc, si plus tard dans mon code, j'ai essayé de dire des chiffres par exemple, et je vois, oh hé, c'est tout en majuscules ou je vois un préfixe spécifique. Je sais que c'est une variable constante. Je ne voulais pas que cela change un jour, non ? Parce que la constante ne peut pas être modifiée. Et s'il a essayé de le changer, vous obtiendrez une erreur. C'est donc juste quelque chose dont il faut être conscient. plupart du temps, vous verrez des effets spécifiques ou majuscules dans le nom comme une simple convention de dénomination de base. Donc, vous savez, c' est une variable constante, pas juste ma variable moyenne normale que je peux modifier. Bref, c' est tout pour cette vidéo. Donc, la principale chose que je veux que vous en retiriez est qu'un ENM un type de données défini par l'utilisateur et qu'il s'agit d'un groupe de constantes avec une valeur intégrale avec un nom associé à celle-ci. Maintenant, quand je dis avec un nom qui lui est associé, je veux dire avec chaque valeur intégrale constante, pas seulement l'énumération elle-même. Et vous pourrez voir un exemple de cela et l'une des prochaines vidéos. Comme toujours, merci de m'avoir écouté, et à bientôt. 57. Chapitre 11 (Enums) : créer un énum: Bonjour à tous. Dans cette vidéo, nous allons en fait créer notre première. Maintenant, il existe deux types d'énumérations que vous pouvez créer. Mais dans cette vidéo, nous allons simplement travailler avec le type le plus élémentaire. Ensuite, dans une prochaine vidéo, je vous montrerai l'autre type que vous pouvez créer. Et ce n'est pas vraiment plus compliqué. Et nous passerons en revue les différences, puis aussi. Alors, comment créer une énumération ? La syntaxe d'une énumération et/ou d' un type énuméré est la suivante. Vous allez d'abord dire Ina, puis vous allez suivre avec le nom de vos revenus. Et puis, entre crochets, vous aurez chaque valeur que vous souhaitez associer à votre ENM. Et ici, vous allez réellement mettre un nom de chaîne et ensuite une constante lui sera associée. Maintenant, cela équivaut à 0, ce n'est pas nécessaire lors de la création d'un anime. Je l'ai juste mis ici pour vous montrer la constante associée à cette première valeur. Et ensuite, celui-ci en aura un qui lui sera associé et celui-ci en aura deux. Et je vais continuer à monter pour obtenir autant de valeurs que nous avons. Et je vais vous montrer ce que je veux dire par là dans une seconde. Si vous êtes un peu confus. Donc, ici, je les écoute, taxez à nouveau pour eux, mais j'ai également inclus la valeur constante associée à chacun d'eux. Et nous pouvons même créer des variables de notre énumération, puisqu'il s'agit d'un type défini par prononçant simplement notre nom EM suivi du nom de notre variable et en le définissant comme égal à l' une des valeurs que nous avons associé à notre énumération. Souvenez-vous également de la façon dont j'ai dit qu'une énumération est un groupe de valeurs intégrales constantes. Ils ont chacun un nom qui leur est associé. Eh bien, si vous vous en souvenez, les constantes doivent également recevoir une valeur initiale dès le début. Nous pouvons donc créer une énumération puis initialiser les valeurs plus tard. Nous devons le faire tout de suite. Alors allons-y et voyons comment en créer un nous-mêmes. Donc, ici, nous allons dire, puis nous allons simplement appeler celui-ci, par exemple. Et la plupart du temps, vous pouvez voir les types définis par l'utilisateur commencer par une majuscule. Nous allons donc procéder de la sorte et le faire également pour notre dénomination ici. Et puis entre crochets. Et n'oubliez pas que lorsque je vous ferai connaître les différentes conventions de dénomination, vous voudrez simplement utiliser ce que l'entreprise ou la majorité des personnes avec qui vous travaillez utilisent. Si vous travaillez simplement en solo, n' hésitez pas à donner votre propre touche aux choses. Quoi qu'il en soit, nous créditons chacun d'entre eux en disant Ina, merci de lui avoir donné un nom. Ensuite, entre crochets, nous allons saisir ici certaines valeurs associées à notre énumération. Au lieu de saisir des chiffres réels, nous allons simplement mettre des noms de fruits dans notre cas. On pourrait donc dire quelque chose comme pomme, banane, virgule orange, juste comme ça. Et vous y voilà. Nous avons maintenant créé une énumération appelée through contenant trois valeurs différentes. Et si vous vous souvenez, j'ai dit que chacune est associée à une valeur constante, qui par défaut est un entier. Donc, si je passe la souris dessus ici, vous pouvez voir qu'Apple est associée au chiffre 0, banane associée à un, l' orange à et cetera. Et cela va continuer. Et ensuite Allons-y. Je n'en ai pas été un autre et appelez cela raisins et L1 se verra automatiquement attribuer trois. Vous pouvez également leur donner votre propre valeur. Je pourrais donc dire qu'Apple sera égal à cinq, par exemple, puis il comptera à partir de là si je ne change aucun des autres. Ainsi, tout ce qui n'a pas sa propre valeur définie augmentera simplement d'une unité par rapport à la dernière valeur définie par l'utilisateur. Apple aura donc cinq ans maintenant, banane, orange, sept, raisins, huit. Et je pourrais même dire que la banane sera désormais égale à dix. Et puis il montera simplement à partir de là avec Orange à 11. Et quelqu'un. Maintenant, il faut savoir que si je dis banane égale à quatre, par exemple, parce que l' orange sera toujours égale à cinq et qu'il n'y aura aucun problème. Ils peuvent avoir les mêmes numéros qui leur sont associés, mais c'est exactement ce que je veux que tu sois. OK, donc vous pouvez y accéder chaque année en fonction la valeur et de chaque valeur qui n'en a pas, nous allons simplement commencer à compter à partir de la dernière valeur définie par l'utilisateur. N'oubliez pas que les tableaux et autres conteneurs commenceront tous à 0. Très bien, c'est donc la méthode de base pour créer une énumération. Et encore une chose que je veux vous montrer, c'est que si vous vous souvenez, je vous ai dit que ce seront naturellement des valeurs entières, mais que nous pouvons réellement changer cela si nous ne le voulions pas, chacune de celles-ci pour être une constante et oubliez pas qu'elles doivent être une valeur intégrale. Nous ne serons donc pas en mesure de changer cela en un flottant ou un double, mais nous ne pouvons pas changer la valeur intégrale à laquelle ils sont associés. Alors faisons-le. Après notre nom d'énumération, nous allons mettre deux points suivis du type de données qui ne nous a pas été attribué. Il doit faire partie intégrante de votre type de données. Nous pourrions donc dire explicitement int si nous le voulions, ou nous pourrions dire quelque chose comme non signé si nous le voulions également, ou nous pourrions changer complètement le type. On peut donc dire char par exemple. Et cela fonctionnera très bien. C'est maintenant qu' une valeur graphique leur est associée, mais vous n'avez pas à le faire. Vous pouvez simplement le laisser tel quel, et ils utiliseront naturellement par défaut un entier. Quoi qu'il en soit, c'est tout pour cette vidéo et la vidéo suivante, nous allons créer un programme de base avec et sans num afin que vous puissiez voir le véritable cas d'utilisation de l'un d'entre eux et comment en utiliser un en code. Alors restez à l'affût , comme toujours, merci de m'avoir écouté et je vous verrai dans la prochaine. 58. Chapitre 11 (Enums) : utiliser les enums: Dans cette vidéo, nous allons créer un programme de base à la fois large et sans énumérations, afin que vous puissiez voir leur véritable cas d'utilisation. Dans le cas d'utilisation de base d'E&M, il s'agit essentiellement de rendre votre code plus lisible et plus organisé. Alors allons-y. Ainsi, le programme que nous allons créer dans cette vidéo va demander à l'utilisateur choisir un fruit parmi une liste d' options . Une fois que l' utilisateur a fait un choix, nous allons simplement signifier une confirmation de leur décision à leur intention. Alors allons-y et commençons. abord, nous allons commencer par créer une liste de nombres entiers nommés d'après différents fruits et attribuer à chacun d'eux une valeur constante. Donc je vais dire que Const Apple est égal à 0. Nina en était une. Orange est égal à deux. Et nous n'en ferons qu'une de plus. Disons qu'une paire constante est égale à trois. Ensuite, en bas, nous allons imprimer la liste des options à l'utilisateur. Donc, je vais dire « C ». Choisissez les options dans la liste. Ensuite, nous allons créer un entier avec les entrées, donc si c' possible, puis ci-dessous, cela indiquera cn. Comme ça. Nous allons maintenant créer un commutateur qui reliera leur choix à eux. Et si vous vous souvenez comment créer un switch, nous allons dire switch puis terminer entre parenthèses. Nous allons mettre la variable que nous vérifions. Donc on va dire « switch input », et ensuite on va dire « a un goût de 0 deux-points ». Ensuite, on dira « C ». Et puis fermez avec un u, cela montre une pomme. Juste comme ça. Et nous dirons la ligne M après. Et puis nous recevons une nouvelle chemise que nous mettons également sur notre déclaration de pause. Maintenant, allons-y et copiez-collez ces quatre fois. D'accord, et puis ici, quand je mets celui-ci à un, c'est l'un des deux et que ce 123 correspond aux valeurs associées à nos entiers, alors nous devons juste changer le texte à l'intérieur de chaque étui, ici. Donc, au cas où l'on dirait que vous avez choisi une banane. Alors, en bas, K a deux ans. Nous dirons que vous avez choisi une orange. Et enfin, il indiquera que vous avez choisi une paire. Et puis, là-haut, nous devons encore donner à l' utilisateur une liste d'options. Nous allons donc dire C et les guillemets en diront un. Pomme Ensuite, nous allons créer une ligne comme celle-ci. Copiez et collez ceci plusieurs fois ici. Nina, orange et poire. Et nous l'avons effectivement inventé, ce premier 120123. Et avant d'exécuter notre code, nous voulons créer une nouvelle ligne, qui apparaisse à droite. Maintenant, si nous exécutons notre code, nous pouvons voir que nous avons dit Veuillez faire un fruit en fonction de la liste des options ci-dessous, nous avons une pomme, une banane, une orange par paire. Et si nous saisissons deux, par exemple, disons que vous avez choisi une orange, et voilà, notre code fonctionne. Maintenant, quand il s'agit de ça ici, surtout si vous travaillez avec un programme beaucoup plus vaste, ce n'est pas la chose la plus raisonnable au monde, n'est-ce pas ? Nous parlons de cas 0, puis nous devons nous rappeler que c'est associé à Apple, cas 1. va falloir se rappeler que c'est associé à la banane. Et bien que notre code soit assez petit, ce n'est pas si difficile à vérifier ici et à lire ici. Nous pourrions le rendre beaucoup plus lisible avec une énumération. Donc, au lieu de créer une nouvelle constante pour chaque option, puis d'essayer mémoriser l' association avec cette option, nous allons simplement créer une énumération. Donc, là-haut, nous allons simplement supprimer toutes ces options. Et puis, là-haut, nous allons dire enum, fruit. Et puis entre crochets ici, disons pomme, banane, orange. Ensuite, ici, nous allons commencer et changer notre entier en quelque chose comme x tout de suite. Et puis ici, nous allons dire que le fruit notre type de données défini par l'utilisateur dans cette énumération que nous venons de créer, a appelé cette enclave et lui a donné la valeur de x. Maintenant, nous allons obtenir un car nous ne pouvons pas initialiser notre variable à un entier comme celui-ci, mais nous pouvons réellement le convertir en type fruit. Et cela fonctionnera très bien. Donc, si je lance notre code ici, vous pouvez voir qu'il fonctionne comme avant. Si je choisis une option comme trois ici, disons que vous avez choisi une paire, et c'est parce que l' entrée ici est juste égale à la valeur entière de celle-ci. Mais comme il s' agit d'un type fruit, nous pouvons simplement utiliser ces valeurs constantes nommées ici. Donc, ici, je pourrais juste dire Case, Apple. Et en dessous, je peux dire banane. Ensuite, on peut dire orange et poire. Et la raison pour laquelle cela me donne une erreur, c' est parce que j' épelle mal banane. Et si je lance mon code, et maintenant vous pouvez voir que cela fonctionne très bien. Et si je choisis une option. 0 ici, ça dira que vous avez choisi une pomme, et maintenant nous n'avons plus à nous souvenir de tout lien avec elle. Et comme vous pouvez le constater, c'est beaucoup plus facile à lire. Maintenant, je peux juste dire étui, étui Apple, étui banane, paire d'étuis orange. Un autre avantage de notre énumération ici, fait d'avoir un groupe de constantes, c'est que nous n'avions même pas à nous souvenir ce que c'était. Et je vais te montrer ce que je veux dire. Donc, en bas, j' aurais pu simplement dire le cas par le biais du nom de notre énumération ici et mettre deux deux-points comme ça. Et en fait, au moins un peu de Visual Studio m'aurait donné une liste de nos différentes options ici. Et cela me montre également la constante qui y est associée. Maintenant, je peux juste dire que Case Fruit était une pomme. Je peux voir la constante que j'ai associée à cela et la sélectionner ici. Et je peux même l' écrire comme tel. Et cela fonctionnera très bien. C'est donc fantastique. Maintenant, d'accord, nous n' avons que quatre options si nous travaillions avec un programme plus vaste et si nous avions une liste de fruits plus Par exemple, cela aurait été beaucoup plus facile à utiliser. J'aurais pu simplement le dire à travers toutes les options que j'ai insérées ici et en créer une pour chacune d'entre elles. Donc, comme je l'ai dit, le cas d'utilisation de base d'un ENM de rendre votre code plus lisible. Et bien que nous n'ayons utilisé que les fruits comme exemple de base, si vous créez un jeu ou quelque chose comme ça, un ENM d'armes , vous avez donné à chacune une clé et un identifiant de valeur uniques et avez fait des choses qui comme un autre exemple. Un autre avantage, c' est que si nous devions modifier la valeur stockée derrière Apple ici pour quelque raison que ce soit, disons que je la remplace par environ modifier la valeur stockée derrière Apple ici pour quelque raison que ce soit, cinq. Et celui-ci est trop pauvre. Ou ce que vous avez fait, c'est que je n'ai pas du tout à changer ça ici et que cela fonctionnera très bien. Et si j'ai un quelconque chevauchement, par exemple, orange est cinq et Apple est cinq. Cela m'avertira également ici que j' ai deux cas pour lesquels le même numéro a été demandé. Donc pas de problème. Je peux juste l'écrire ici. Maintenant, en bas, comment créons-nous réellement une liste d'options ? Et nous ne voulions pas avoir à changer cela à chaque fois que nous modifiions nos constantes ici, nous aurions pu faire ce qui suit. Je vais donc simplement supprimer les chiffres de ces derniers. Alors allons-y et mettons tout cela dans un ordre séquentiel. Nous allons donc simplement supprimer tout cela à partir d'ici. Et si nous voulions, juste pour plus de clarté, nous pourrions simplement dire, hé, celui-ci commence à 0, même si cela se produit par défaut. Mais vous verrez certaines personnes le faire. Je vais donc simplement vous montrer cela à titre d'exemple. Et puis ici, parce qu'il n'y a qu'une impression de pomme. Et si nous exécutons notre code, nous allons dire 0, puis Apple. Nous pourrions donc le faire pour le reste, comme ça. Et puis ici, nous pourrions simplement dire cette paire d'espaces, comme nous l'avons vu de manière orange et qu'ils investissent, nous échantillonnons. Maintenant, si nous exécutons notre code, cela ne fera qu'imprimer les options qui s'offrent à nous. Et même si nous avions modifié les valeurs ici, notre code fonctionnerait toujours très bien, ce qui est vraiment bien. Et nous pouvons également voir de manière explicite sur quoi nous travaillons ici lorsque nous imprimons les différentes options. Donc, là-haut, si je devais le changer à dix, toutes mes valeurs seraient différentes et exécuterait mon code. Mes options ont été modifiées dynamiquement avec lui, et il est toujours très lisible dans notre code également. Quoi qu'il en soit, ce sera essentiellement tout pour cette vidéo. J'espère que vous avez maintenant une compréhension de base de la création d'une énumération et son cas d'utilisation est de rendre votre code plus lisible et plus dynamique. Dans certains cas, comme vous l'avez vu ici, en vous fournissant un groupe de constantes nommées que vous pouvez utiliser dans votre code et en vous fournissant également un type de données défini par l'utilisateur avec lequel travailler. Maintenant, la dernière chose que je veux vous montrer rapidement, c'est que, comme nos noms de constantes enum ont chacun une valeur réelle qui leur est associée, vous pouvez faire quelque chose comme ce qui suit. Donc, ici, je pourrais dire vrai. Et je vais juste mettre ça dans notre valise. Je dirais qu'Apple est égal par l'intermédiaire d'Apple. Au fait, j'aurais pu juste dire pomme, et ça aurait marché aussi. Ensuite, ici, je dirais que fruits, bananes, c'est exactement comme ça. Ensuite, je peux créer une instruction if qui fonctionne avec les mathématiques sous-jacentes. Je peux donc dire que si Apple est supérieur à une banane, puis exécuter du code ici, parce qu'Apple a un chiffre inférieur associé à un dix contre un 11, alors ce code ne fonctionnerait pas. Mais si je vais de l'avant et que je change la donne, disons que j'ai acheté que c' est une meilleure banane. Cela fonctionnera très bien. Et en fait, je vais aller de l'avant et le déplacer rapidement vers le haut de notre code, comme s'il s'imprime sans aucun problème, mais en dessous de notre énumération ici. Et si je le lance, vous pouvez voir qu'il dit Apple est meilleur que la banane. Mais si nous allions de l'avant et inversons la tendance, ce ne serait pas le cas. Donc, je veux juste vous montrer que vous pouvez utiliser des énumérations en mathématiques comme vous le feriez s'il s'agissait d'une constante intégrale normale. Quoi qu'il en soit, je vais me débarrasser de ce code supplémentaire ici. Et puis ce que je veux que vous fassiez, c'est enregistrer tout ce que nous avons ici parce que nous allons l'utiliser dans la prochaine vidéo quand je vous montrerai l'autre type d'enum et les différences entre celui-ci et celui-ci. Assurez-vous donc de sauvegarder ce que vous avez, car nous allons l'utiliser dans la prochaine vidéo. Quoi qu'il en soit, comme toujours, merci de m'avoir écouté, et je te verrai dans la prochaine. 59. Chapitre 11 (Enums) : les cours Eums vs Enum: Dans cette vidéo, nous allons parler l'autre type de cours E&M, qui présente quelques différences par rapport à un ENM normal, comme nous l'avons créé dans la dernière vidéo. Maintenant, si vous vous en souvenez dans la dernière vidéo, je voulais que vous sauvegardiez tout le code que nous avons créé pour l'utiliser dans cette vidéo. Mais si pour une raison ou une autre, vous avez oublié, ce n'est pas grave, que la seule pièce principale à laquelle je veux que vous vous accrochiez en ce moment est juste que c' est la création même de notre énumération. Et je vais simplement me contenter de commenter le reste pour l'instant. Permettez-moi donc de vous montrer quelques autres choses sur les énumérations régulières avant de voir comment créer une classe d'énumération et les différences. abord, si nous essayons de créer une variable avec le même nom que n'importe laquelle de nos constantes ici, au lieu de nous contenter, nous allons obtenir une erreur. Donc, si je dis int orange, par exemple, équivaut à 0 en essayant d'exécuter mon code, ça va me donner une erreur. Et c'est parce que, d'une part, une énumération régulière est envisagée sur la portée. Donc, tous ces noms sont essentiellement utilisés pour notre programme. Et vous pouvez voir ici que le fruit est sur scoped et qu'il préférerait que nous utilisions une classe enum plutôt que suffisamment dans ce cas. Maintenant, l'autre point avec les énumérations régulières, c'est qu' une variable d' énumération, nous sommes implicitement converties en entier. Et laisse-moi te le montrer tout de suite. Donc, ici, si je vais de l'avant et que je supprime ça, d'accord. Je ne vais pas passer en revue tout mon équipage et le mettre sur un pied d'égalité pour prouver. OK ? Et puis ici, je peux dire que x est égal à cinq plus moins. Ensuite, si j'imprime x, comme ça, j'obtiendrai t plus. J'aurais pu mettre un montant égal à mes fruits. Et cela aurait également fonctionné. Et cela convertira implicitement cette valeur en ceci. Et si c'est ce que tu veux, tant mieux. Mais si nous en faisions une classe enum, elle ne se convertirait pas implicitement comme ça. Et je vais te le montrer tout de suite. Alors, comment créer une classe enum ? Eh bien, c'est assez simple. Et donc la même énumération suivie du nom de son énumération, classe d' enum, suivie du nom de notre génome. Maintenant, comme vous pouvez le voir, nous avons immédiatement reçu une erreur et elle ne sera pas implicitement convertie de notre classe enum qui est ici un fruit en une valeur entière. Cependant, nous pouvons toujours le faire explicitement en disant : «  Hé, allez-y et faites-en un entier ». C'est très bien. Si nous exécutons notre code, nous en aurons toujours dix. Ainsi, en en faisant une classe, vous ne ferez pas simplement implicitement des conversions à partir de votre type enum, de deux autres types. Au lieu de cela, vous devrez le faire explicitement. De plus, il ne reprend pas ces noms. J'aurais donc pu appeler cette pomme, par exemple. Cela fonctionnerait très bien. C'est parce que notre énumération est désormais essentiellement limitée. Et ces noms sont propres à cette classe ici, et nous reviendrons sur les cours plus tard dans le cours. Mais pour l'instant, sachez simplement que maintenant nous pouvons en avoir deux du même nom sans aucun problème ici. Et cela peut être utile si nous avions une autre classe E&M, par exemple, si nous voulions avoir des noms similaires. Alors peut-être que j'avais un cours d'énumération appelé nourriture. Ensuite, à l'intérieur, j'ai mangé différents aliments avec lesquels je voulais travailler. Je pourrais dire du poulet, chips de pommes comme ça. Et cela fonctionnera très bien sans aucun problème, alors que ce ne serait pas le cas avec des énumérations régulières. Il y a donc certaines différences. En gros, si vous utilisez un nom et une classe enum, vous pouvez toujours l'utiliser ailleurs. Alors que si vous l'utilisez uniquement avec un ENM normal, vous ne pouvez pas le faire également, énumérations régulières peuvent implicitement se convertir en d'autres types, ce qui est impossible en tant que classe d'enum et vous devez le faire explicitement, ce qui aidez à garantir que c'est ce que vous voulez qu'il fasse. Alors, vous l'avez. Il est possible de créer une classe enum par rapport à une classe E&M et vous connaissez maintenant les différences. Alors, comme toujours, merci de m'avoir écouté et je vous verrai dans la prochaine. 60. Chapitre 12 (Fonctions) : Intro aux fonctions: Dans cette vidéo, nous allons parler de fonctions. Maintenant, une fonction ou une méthode est essentiellement un bloc de code qui ne s'exécute que lorsqu'il fait froid. Donc, comme je l'ai dit, une fonction est essentiellement un bloc de code, comme nous avons un bloc de code ici. ne court que lorsqu'il fait froid. Et nous avons en fait utilisé une poignée de fonctions différentes pour différentes choses. Par exemple, nous avons simplement utilisé un tas de fonctions différentes lorsque nous avons parlé de conteneurs dans les vidéos précédentes. De plus, presque tout notre code a été écrit dans cette fonction principale qui, comme je l'ai déjà dit, chaque programme C plus plus besoin d'une fonction principale car elle est appelée dès le début du programme lorsque votre programme commence et se termine. Et voici le bloc de code qui s'exécute lorsqu'il fait froid. Alors pourquoi voudrions-nous utiliser et/ou créer une fonction ? Eh bien, tout d'abord, cela va nettoyer votre code. L'une des raisons pour lesquelles a nettoie notre code est que chaque fois que vous avez, disons, un bloc de code que vous utilisez, je ne sais pas, trois fois ou plus ou quelque chose comme ça. Au lieu de copier et coller l'intégralité de ce bloc de code plusieurs fois, vous pouvez simplement créer une fonction qui nous permet d'utiliser facilement du code encore et encore sans avoir à le copier et à le coller. Et une autre raison pour laquelle vous pourriez vouloir utiliser une fonction, car par exemple, disons que nous avons un bloc de code que nous avons utilisé encore et encore. Et nous sommes allés de l'avant et nous l'avons simplement copiée et collée, copiée et collée partout où nous en avions besoin. Et si au bout du compte, tu te rends compte, tu sais quoi, j'ai besoin de ça pour faire ça. Quelque chose de légèrement différent maintenant. Eh bien, maintenant, vous allez devoir rechercher tout votre code que vous avez utilisé à maintes reprises et ajuster partout individuellement. Alors que si vous aviez une fonction, vous pouvez simplement ajuster la fonction. Il fonctionne donc essentiellement de manière dynamique. Partout où il est utilisé. Le code a changé parce que nous pouvons simplement changer la fonction au lieu d' avoir à modifier chaque partie du code que nous avons utilisée encore et encore. Très bien, donc, pour résumer une fonction et notre méthode sous la forme d'un bloc de code qui ne s'exécute que lorsqu'elle est appelée quelques-unes des principales raisons pour lesquelles vous voudriez utiliser une fonction, en premier lieu, c'est nettoyer augmentez votre code pour le rendre plus dynamique. Et pour que vous puissiez facilement utiliser du code encore et encore sans avoir à le réécrire. Quoi qu'il en soit, j'espère que cela vous donnera une compréhension de base de ce qu'est une fonction et quand vous voudriez l'utiliser. Mais si vous ne le comprenez pas parfaitement, ne vous inquiétez pas, car nous allons créer et travailler avec différents exemples dans les prochaines vidéos. Bref, merci de m'avoir écouté, et à bientôt. 61. Chapitre 12 (Fonctions) : créer une fonction: Dans cette vidéo, nous allons créer et utiliser une fonction très basique. Et puis, dans les prochaines vidéos, nous allons travailler lentement avec des fonctions de plus en plus complexes afin que vous puissiez bien comprendre comment utiliser et créer vos propres fonctions . Et c'est parce que les fonctions sont constamment utilisées dans la programmation. Et personnellement, je trouve des fonctions et des méthodes, quel que soit le nom que vous voulez. Tellement utile que je ne toucherai pas ou ne travaillerai même avec un langage de programmation qui ne l'a pas. Et c'est parce que cela nettoie tellement votre code. Cela le rend beaucoup plus dynamique, beaucoup plus facile à utiliser et moins sujet aux erreurs que de copier-coller du code encore et encore et encore. Et en programmation, vous devez toujours faire tout ce qui est en votre pouvoir pour éviter les erreurs humaines car tout le monde fait des erreurs. Et parfois, il faut beaucoup de temps pour déterminer la cause du problème. Quoi qu'il en soit, assez de cette diatribe, allons-y et créons notre propre fonction de base. Donc, ici, en dehors de notre fonction principale, nous allons créer notre propre fonction. Pour commencer, nous allons indiquer notre type de retour, et c'est ce que vous souhaitez obtenir de la méthode. Par exemple, notre méthode principale ici en tant que type de retour d'un entier. C'est pourquoi, à la fin de tous nos programmes, nous renvoyons 0, qui est une valeur entière. Ainsi, lorsque la méthode principale est appelée, elle a un entier de type de retour et nous renvoyons l'entier. Et cela doit être fait maintenant en C plus plus, si vous vous souvenez, vous pouvez supprimer cette ligne de code. Et C plus plus le fera réellement pour vous, au moins avec votre méthode principale, sans que vous ayez besoin de cette ligne de code spécifique. Mais je voulais juste le laisser là pour que vous compreniez que, hé, nous avons un type de retour int, nous devons retourner un entier. Et aussi, lorsque notre fonction principale renvoie 0 et C plus plus, nous savons que tout notre code a été exécuté avec succès et nous avons pu atteindre la fin ici. Et nous aurions pu simplement mettre un 0 ici aussi. Mais nous pouvons également connaître cet excellent succès ici si vous souhaitez qu'il soit précisé de manière plus explicite. Alors allons-y et créons réellement ce truc. Tout d'abord, nous allons commencer par un type de retour. Dans ce cas, nous allons dire nul. Et ce que signifie void, c'est que, hé, nous ne voulons rien renvoyer depuis cette fonction. Nous voulons simplement exécuter le code qu'il contient. Et c'est parfaitement bien. Et nous commencerons à travailler avec différents types de retours et une prochaine vidéo. Mais pour l'instant, nous n'allons tout simplement rien retourner de notre fonction. Nous allons donc simplement exécuter le code qu'il contient. Ensuite, allons-y et appelons cette impression. Juste comme ça. Nous aurons des parenthèses ouvertes et fermées par la suite. Ensuite, nous aurons notre bloc de code, qui, une fois de plus, est juste défini avec des crochets ouverts et fermés. Tout le code qu'il contient est notre bloc de code. Maintenant, cette partie supérieure est notre déclaration de méthode ou de fonction. Donc, un peu comme pour les variables, comment déclarer et initialiser une variable. Ici, nous pouvons déclarer une fonction. Et puis c'est dans notre bloc de code que nous définissons réellement notre fonction. Donc, en bas, ou un bloc de code ici se trouverait la définition de notre fonction. D'accord, c'est donc notre déclaration et ce qu'est le bloc de code d'entrée est notre définition. Maintenant, allons-y et mettons du code ici pour que nous puissions voir comment cela fonctionne et nous puissions y mettre ce que nous voulons. Mais on va y aller et imprimer Hello. Puisque notre fonction s'appelle print hello, puis revenons à notre méthode principale, nous n'avons pas vraiment appelé cette fonction ou elle ne fera rien. Donc, comme vous pouvez le constater, si nous exécutons notre code maintenant, il n' imprimera rien. Et c'est parce que, comme nous en avons parlé dans la dernière vidéo, une fonction est un bloc de code qui ne s'exécute que lorsqu'elle est appelée. Alors, comment appelle-t-on notre fonction ? Eh bien, nous allons prononcer le nom de notre fonction, suivi de parenthèses ouvertes, puis de parenthèses fermées et d'un point-virgule. Maintenant, ce n'est pas toujours comme ça qu'on appelle une fonction. Et nous aborderons certaines des différentes manières lorsque nous commencerons à parler d'arguments et de paramètres. Mais pour appeler notre fonction ici, c'est exactement comme cela que cela se fait. Premièrement, nous ne collectons rien à partir d'hypothèses, donc je n'ai rien à enregistrer nulle part et nous n'avons rien entre parenthèses. Nous n'avons donc besoin de rien entre parenthèses ici. Laissez-moi simplement mettre un point-virgule à la fin. Et si nous essayons d'exécuter notre code, vous pouvez voir que nous obtenons une erreur. C'est parce que, comme tout le reste dans C plus plus, vous ne pouvez pas l'utiliser avant qu'il ne soit défini. Et une façon de résoudre ce problème est en fait de copier un code partout ici, et je le place au-dessus de notre fonction principale. Et maintenant, si nous exécutons notre code, vous pouvez voir qu'il ne fonctionnera pas et imprimer bonjour. Et allons-y et cassons la ligne M ici. Et juste pour vous montrer cela, nous pouvons les copier et les coller autant que nous le voulons. Et nous pouvons le mettre n' importe où dans notre code et il fonctionnera très bien. Et comme vous pouvez le voir, nous avons imprimé « Bonjour » à chaque fois que nous faisons appel à notre fonction. Il s'agit d'une fonction assez basique qui ne fait pas grand-chose , mais vous avez l'idée d'une qui indique clairement ce que nous essayons de faire. Nous allons juste imprimer Hello car nous avons donné notre méthode. Voici notre fonction un nom très définitif de ce que fait cette fonction. De plus, si nous avions beaucoup plus de code ici, par exemple, si nous imprimons comme un paragraphe ou quelque chose comme ça, cela commencerait à paraître très compliqué si nous écrivions cela ici à chaque chronométrez ou copiez-le et collez-le car ce serait beaucoup de textes pour vraiment aucun gain par rapport à deux seulement. Quelque chose comme ça où nous pouvons simplement avoir nom de notre fonction, comme sub t s'en est souvenu, voici notre fonction. Quoi qu'il en soit, c'est à peu près tout pour cette vidéo. Comme je l'ai dit dans les prochaines vidéos, nous allons simplement travailler lentement avec fonctions de plus en plus complexes jusqu'à ce que nous ayons décomposé tous les éléments de base dont vous aurez besoin pour créer des fonctions de votre propre chef. Donc, pour terminer cette vidéo, récapitulons rapidement les principaux éléments que vous voudrez retenir de cette première étape, pour créer une fonction très simple et/ou basique, vous pouvez avoir votre type de retour suivi du nom, parenthèses ouvertes et fermées, puis de votre bloc de code et de crochets. Et comme pour tout le reste, notre code est lu de haut en bas. Il doit donc connaître notre fonction avant de pouvoir l'utiliser. De plus, si nous ne renvoyons rien d'une fonction, nous pouvons simplement dire void. Ensuite, pour appeler une fonction ou l'utiliser réellement, nous devons prononcer le nom de notre fonction suivi de parenthèses ouvertes et fermées, moins dans ce cas, car il n'y a rien entre parenthèses ici. Enfin, un point-virgule. Maintenant, si vous ne savez toujours comment utiliser les fonctions, ne vous inquiétez pas. Vous allez voir d' autres exemples dans les prochaines vidéos. Maintenant, avant de passer à la vidéo suivante, veuillez enregistrer tout ce que vous avez, car nous allons l'utiliser dans la vidéo suivante lorsque nous parlerons des prototypes de fonctions. Quoi qu'il en soit, c'est tout pour cette vidéo. Comme toujours, merci de m'avoir écouté, et à bientôt. 62. Chapitre 12 (Fonctions) : Prototypes de fonctions: Dans cette vidéo, nous allons créer ce on appelle un prototype de fonction ou de méthode. Maintenant, allez-y et vous montrer ce que c'est. Si vous vous souvenez que dans la dernière vidéo, lorsque notre méthode, déclaration et notre définition se trouvaient ci-dessous, nous n'avons pas pu appeler notre méthode. Et c'est parce que notre programme n'avait aucune idée de quoi nous parlions. Parce que si vous vous en souvenez, le code se lit de haut en bas. Alors allons-y très vite. pouvons le ramener au niveau le plus bas, notre fonction principale. Comme ça. Si nous allons de l'avant et que nous essayons de l'exécuter, vous pouvez voir que nous obtenons une erreur. Et il indique que print hello n'a pas été trouvé. Il n'a aucune idée de quoi nous parlons. Maintenant. Nous pouvions simplement faire ce que nous faisions auparavant, évidemment , en reprenant toute notre fonction et en la plaçant au-dessus de notre fonction principale. Cependant, la plupart du temps, lorsque vous ouvrez votre code, vous souhaitez simplement vérifier le contenu de la fonction principale. J'espère que vous devriez être en mesure de comprendre comment fonctionne le code et comment faire défiler une tonne d'autres méthodes. Selon la complexité de votre code, peut être vraiment ennuyeux et désordonné. Donc, pour résoudre ce problème, nous pouvons utiliser ce que l'on appelle le prototype de fonction, et c'est assez facile à faire. Nous allons donc copier ceux qui étaient très en première ligne de notre méthode. Ensuite, collez-le au-dessus notre méthode principale et mettez un point-virgule à la fin. Et voici un prototype de fonction. C'est à peu près tout ce que nous avons à faire. Et maintenant, quand notre code est lu de haut en bas, il va dire : « Oh, d' accord, il y a une fonction appelée print hello, et la définition se trouve juste en bas. Maintenant, quand on l'appelle, il sait de quoi on parle. Et si nous exécutons notre code, vous pouvez voir qu'il fonctionne très bien. Maintenant. C'est un prototype de fonction. Et si vous voulez une explication plus détaillée de ce qu'est un prototype de fonction, il s'agit essentiellement une autre déclaration et il doit avoir le type de retour, cas échéant, le nom et les périmètres. dans l'ordre. Et nous aborderons les bitters dans une vidéo ultérieure. Mais comme nous n'en avions pas ici, nous avons simplement mis nos parenthèses ouvertes et fermées. Enfin, il suffit de le suivre avec le point-virgule. Et cela permet au compilateur, ou à celui qui traduit tout ce code en binaire pour que l'ordinateur puisse le comprendre, savoir à quoi s'attendre dans le futur. Ainsi, lorsque nous avons un appel de fonction plus tard, il sait déjà à quoi cet appel de fonction fait référence, étant donné que cette fonction est là, la racine a été déclarée et mise en évidence à l'avance. Et tout cela fait essentiellement tant que notre définition figure plus loin dans notre code. Parce que, comme je l'ai dit, la plupart du temps, lorsque vous ouvrez votre code, vous voulez simplement pouvoir regarder la fonction principale et comprendre ce qui se passe. Vous ne voulez pas avoir à traiter une tonne d'autres textes à l'avance. Tu veux juste entrer dans le vif du sujet. Quoi qu'il en soit, j'espère que c'était assez facile à comprendre. Si ce n'est pas le cas, nous travaillerons également avec eux dans les prochaines vidéos. Parce que je recommande toujours d'utiliser un prototype de fonction plutôt que de placer votre fonction au-dessus de votre fonction principale, même si cela fonctionnera de la même manière, c'est juste beaucoup plus propre. Donc, en gros, rappelez-vous simplement que si vous voulez avoir la définition de votre fonction plus tard, ce que je recommande toujours vous suffit copier cette ligne supérieure ici, coller ci-dessus, et insérez un point-virgule et vous allez quand même, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 63. 62: Dans cette vidéo, nous allons parler des types de retours. Maintenant, si vous pensez à créer une fonction très basique, vous allez commencer par le type de retour, suivi du nom, des parenthèses ouvertes et fermées, puis de votre bloc de code. Dans les vidéos précédentes, nous avons simplement dit que nous ne voulions pas qu'elle rende quoi que ce soit, nous ne voulions pas qu'elle rende quoi que ce soit, inséré le mot clé void. Mais dans cette vidéo, nous allons voir comment récupérer de valeur de notre fonction et créer une fonction qui le fait également. Alors allons-y et commençons. Maintenant, pour commencer, nous allons simplement créer notre prototype de fonction. Donc, pour ce faire, nous allons mettre un type de retour, qui sera int, suivi du nom, qui sera renvoyé dix. Et n'oubliez pas que cela peut être ce que vous voulez. D'ailleurs, la convention de dénomination typique pour une fonction consiste à utiliser CamelCase, comme nous le faisons pour les variables, mais pour commencer par une majuscule , nous allons avoir des parenthèses ouvertes et fermées et un point-virgule à la fin, car il s'agit de notre prototype de fonction. Maintenant, si je passe la souris dessus, vous pouvez voir qu'il nous avertit que nous n' avons pas de définition de notre fonction. Mais comme vous pouvez le voir, la ligne ondulée est en vert, ce qui signifie essentiellement que votre code fonctionnera toujours. Mais bon, c'est juste un avertissement. En gros, si nous exécutons notre code, nous n'obtenons aucune erreur. Le code fonctionne très bien. Cela ressemble donc plus à un avertissement qu' à véritable avertissement indiquant qu'un code ne s'exécutera pas correctement. C'est pourquoi il est en vert au lieu de rouge, moins dans Visual Studio. Donc, pour créer réellement notre fonction, nous allons copier tout cela à l'exception du point-virgule et le coller ci-dessous. Ensuite, nous aurons des crochets bouclés ouverts et fermés comme ça. Et nous allons mettre notre code ici. Et nous pouvons à nouveau avoir tout ce que nous voulions dans notre bloc de code. Mais dans ce cas, nous allons simplement renvoyer une valeur de dix. Donc aujourd'hui, tout ce que nous allons faire, c'est dire le temps d'attente, suivi de dix et d'un point-virgule à la fin. Et vous y voilà. Et si nous passons la souris dessus, vous pouvez voir qu'il s'agit bien d'une valeur entière, alors nous avons juste notre point-virgule à la fin. Et si nous voulons que ce soit encore plus explicite à ce sujet, nous pouvons affirmer quelque chose comme int dix est égal à dix, puis renvoyer cette variable directement. Mais ce que nous avions ici est parfait. Donc, tout comme avec notre méthode principale, où elle renvoie un entier en utilisant ce mot clé de retour. Je me souviens que cela revient essentiellement dire retour à zéro. Donc, tout ce que vous devez faire pour renvoyer une valeur à partir d'une fonction. Nous saisissons simplement le type de données que vous souhaitez renvoyer avant le nom de la fonction, puis utilisons ce mot clé de retour en minuscules, suivi de la valeur que vous souhaitez renvoyer. Et vous devez vous assurer que ce type de données est identique à votre type de retour. Ensuite, là-haut, nous pouvons collecter cette valeur. Maintenant, juste pour vous montrer quelque chose ici, si nous allions de l'avant et que nous appelions leur fonction en prononçant à nouveau le nom de notre fonction, suivi de parenthèses ouvertes et fermées. Comme nous n'avons rien ici, nous n'avons besoin de rien ici. Ensuite, en mettant un point-virgule à la fin et en exécutant notre code, vous pouvez voir qu' il fonctionne très bien. Cependant, chaque fois que vous avez une fonction qui renvoie un type de données, vous souhaitez stocker cette valeur quelque part. Parce que si vous n' allez pas stocker cette valeur, vous auriez tout aussi bien pu ne rien avoir retourné au départ. Donc, là-haut, nous allons dire quelque chose comme int x est égal à return ten. Et puis en bas, nous allons simplement imprimer x, comme si nous exécutons notre code, vous pouvez voir qu'il est maintenant égal à dix. C'est parce que nous avons défini x égal au résultat de cette fonction. Et comme il renvoie un entier, nous récupérons un entier. Donc, tout ce que nous avons fait était de créer une variable appelée x et de la définir comme égale à ce que notre fonction renvoie ici. Et si je passe la souris sur cette fonction, vous pouvez voir qu'elle renvoie une valeur entière. Donc x sera égal à l'entier renvoyé par notre fonction ici, qui est dans ce cas. Donc cette ligne est exactement la même que si nous disions que x est égal à dix. Au moins dans ce cas, nous pouvons simplement travailler avec notre variable normalement. Alors, tu y vas. Vous savez maintenant comment utiliser un type de retour lors de la création d'une fonction. En gros, au lieu de dire « nul » ici, vous indiquez le type de données que vous souhaitez renvoyer. Ensuite, dans votre fonction, vous dites return suivi la valeur du type de données que vous souhaitez qu'elle renvoie. Maintenant, chaque fois que vous appelez cette fonction, elle vous renvoie à cette valeur de ce type. C'est pourquoi nous avons pu faire ce qui suit sans problème. Pour ceux d'entre vous qui s'en souviennent, x est une variable locale car elle a été déclarée dans un bloc de code n' est disponible que dans ce bloc de code après sa déclaration. Cela signifie que nous aurions pu dire quelque chose comme ça ici. X est égal à dix, puis dit renvoyé X. Et cela fonctionnerait très bien car en ce qui concerne ce bloc de code, x n'existe pas ici. Et en ce qui concerne ce bloc de code, ce x ici n'existe pas, et donc ils peuvent avoir le même nom exact sans aucun problème. Juste quelque chose à noter. Vous voulez toujours rendre les choses disponibles uniquement dans la mesure où vous le devez absolument. Si nous n'avions pas à créer un x ici, une variable globale, par exemple, vous ne voudriez pas le faire. Vous voulez simplement le rendre aussi disponible que vous le souhaitez. Donc, d'une part, vous n'avez aucun problème lorsque les noms de variables se chevauchent. Et deuxièmement, vous minimisez également les erreurs humaines. Je crée une variable ou quoi que ce soit d'autre, uniquement aussi disponible que nécessaire, ce qui est toujours une bonne chose. Maintenant, pour vous montrer une dernière chose, car il peut s'agir essentiellement n'importe quel type de données que nous voulons. Nous pourrions renvoyer quelque chose comme un cool, d'ailleurs, en remarquant que si notre prototype de fonction avait une déclaration différente de celle de notre fonction réelle, nous obtenons une erreur. Vous devez donc être sûr de leur donner le même type de retour, comme ça. Et puis à l'intérieur d'ici, nous pourrions dire que quelque chose comme « pool » est vrai, égal à vrai, puis revient à vrai. Maintenant, c' est essentiellement la même chose que si nous n'avions pas cela et que nous disions simplement retourner, c'est vrai. Je vais juste procéder de cette façon, juste pour vous montrer que nous pouvons simplement ajouter la région variable ici. Et puis, là-haut, nous aurions pu avoir une déclaration si nous en avions renvoyé dix. Et nous aurions probablement voulu le renommer en quelque chose comme return true. Juste pour que ce soit clair. Cette fonction fonctionne lorsque vous lisez simplement notre méthode principale. Parce que vous ne voulez pas toujours vous préoccuper du code contenu dans le degré de la fonction. Vous voulez simplement être capable, comme je l'ai dit dans le passé, lire votre fonction principale et d'avoir une compréhension générale de ce qui se passe. Donc, ici, nous avons dit si retournez vrai. Remarquez qu'en appelant cette fonction, comme il s'agissait d'une condition d' instruction if, nous n'avons pas eu besoin de mettre un point-virgule ici. Et puis en bas, nous pouvons mettre des crochets si cela renvoie vrai, exécuter ce code et nous allons simplement dire C out if instruction ou quelque chose comme ça. Et si nous exécutons notre code, vous pouvez voir que cela fonctionne très bien. Et si nous avions changé cela en faux par exemple et exécuté notre code, il n'aurait pas fonctionné. Ainsi, lorsque vous renvoyez une valeur booléenne, vous pouvez également l' utiliser directement dans votre instruction if comme condition ici. Donc c'est plutôt chouette. N'oubliez donc pas qu'une fonction est là pour vous faciliter la vie. Et donc, c'est essentiellement la même chose que d'avoir la valeur booléenne ici, puisqu'elle renvoie un Booléen et quand nous avons renvoyé un int, c'était la même chose que d' avoir la valeur int ici, puisqu'elle renvoie un entier. Alors, vous l'avez. J'espère que vous avez maintenant une compréhension de base de la façon de travailler avec les types de retour. Sinon, vous pouvez toujours revoir la vidéo. Sinon, vous en verrez d'autres exemples dans les prochaines vidéos. Alors merci de m'avoir écouté, et à bientôt. 64. Chapitre 12 (Fonctions) : Paramètres et arguments: Dans cette vidéo, nous allons examiner les paramètres et les arguments. Dans le passé, nous avons créé des fonctions de base qui ressemblaient à ceci. Ils avaient un type de retour suivi du nom, parenthèses ouvertes et fermées, puis de notre bloc de code et de crochets. Mais à l'intérieur de ces parenthèses, nous pouvons en fait avoir la liste de ce que l'on appelle des paramètres. Nous pourrions donc dire si le paramètre un, le paramètre deux, etc. Et nous pouvons en avoir autant que nous le voulons. Et quelles sont ces valeurs que nous prévoyons de transmettre à la fonction. Nous pouvons donc envoyer des données à la fonction et récupérer des données depuis la fonction. Alors allons-y et voyons comment procéder. Donc, en bas de notre fonction principale, allons-y et créons une fonction qui additionne deux nombres et nous donne le résultat de cela. Donc, pour ce faire, nous allons le citer dans ce cas. Ensuite, nous dirons «  ajouter » pour notre nom. Et puis entre parenthèses, nous allons dire int x virgule y, juste comme ça. Ensuite, nous aurons notre bloc de code et je vais expliquer pourquoi nous l'avons fait ici dans un instant. Ensuite, à l'intérieur de notre bloc de code, on dira return x plus y. Maintenant, nous aurions pu créer une variable entière appelée result et ensuite renvoyer le résultat. Mais je veux juste vous montrer que nous pourrions avoir une expression dans notre instruction de retour ici, parce que ce sont deux nombres entiers, elle renverra un entier. Et maintenant, lorsque nous appelons réellement notre fonction, nous pouvons effectuer les opérations suivantes. Alors d'abord, allons-y et imprimons le résultat de cette fonction. Donc, pour ce faire, nous allons simplement dire C par le nom de notre fonction ici. Et puis entre parenthèses, vous pouvez voir qu'il faut mettre deux valeurs entières. Et les valeurs que nous mettons dans notre appel de fonction ici sont appelées arguments, alors que celles-ci, en bas, nous appellerons les périmètres. Donc, ici, nous pouvons dire quelque chose comme 510. Ensuite, ces nombres seront envoyés à notre fonction ici, puis additionnés et renvoyés sous forme d'entier. Et puis, avant d'exécuter un code, parce que notre méthode se trouve en dessous de notre fonction principale, nous avons juste besoin de créer un prototype. Nous allons donc copier cette ligne supérieure, coller ci-dessus et la mettre par un point-virgule. Nous avons donc maintenant un prototype de fonction. Nous avons un appel de fonction ici, et nous avons également une déclaration et une définition de fonction ici. Donc, si nous exécutons notre code ici très rapidement, vous pouvez voir qu' il imprime 15. C'est parce que nous avons dit : « Hé, nous voulons imprimer cette valeur entière que nous obtenons à partir d'ici. C'était notre type de retour ici. Ensuite, nous transmettons deux valeurs entières comme arguments pour ces paramètres. Et tout ce que nous avons fait, c'est de dire : « Hé, retourne le premier plus le second. Et d'ailleurs, les arguments que nous transmettons ici sont les valeurs que nous avons transmises ici doivent être dans le même ordre que celles que nous avons transmises ici. Donc, ces dix ne remplaceront jamais x, et ces cinq ne remplaceront jamais y. Ils seront dans l'ordre, et dans le même ordre qu'ici, ils devaient être dans cet ordre là-haut C'est pourquoi il est souvent plus facile de copier cette première ligne puis ajouter un point-virgule à la fin lors de la création de votre prototype de fonction. De plus, juste pour vous faire savoir que ces noms de paramètres sont locaux à cette fonction. Vous pouvez donc toujours créer un entier x ici et un entier y, et cela fonctionnera très bien. OK ? Ils sont donc locaux à la fonction pour laquelle ils ont été créés. Donc, en gros, pour créer un paramètre, il suffit d'avoir le type de données suivi du nom. Et tout ce nom est le nom avec lequel vous souhaitez travailler pour la valeur transmise à votre fonction. Vous allez donc créer un périmètre chaque fois que vous souhaitez transmettre quelque chose à votre fonction. Et ce que vous transmettez s'appelle l'argument, et il est associé au même paramètre dans l'ordre. Nous avons donc 510 ici, qui seront associés à X et Y respectivement. Donc ce cinq vaut pour x et le moment était venu de savoir pourquoi ? Comme je l'ai dit, nous avons pu les nommer comme nous le voulions, même si nous avions créé deux variables ici. Donc, si nous l'avions voulu, nous aurions pu dire int x ou num one. Num deux est égal à dix, puis passé en num un, num deux. Et ça va très bien fonctionner. Comme je l'ai dit, ce nom de paramètre ici contient exactement ce que vous voulez appeler la valeur ou l'argument transmis dans votre fonction. Et ils auraient pu porter le même nom si nous avions voulu que cela soit ainsi et cela aurait également fonctionné. Mais comme je l'ai dit, tu peux l'appeler comme tu veux. Nous avons donc simplement indiqué x et y noms que nous voulions utiliser pour les valeurs transmises afin de pouvoir utiliser dans notre livre de codes. De plus, une autre chose à noter est que ce paramètre est une copie de cette variable et non la variable elle-même. Donc, si et là j'ai dit x plus plus, et puis ici nous avons imprimé numéro un. Aucun ne serait changé. Nous en avons donc imprimé 16 parce que nous avons adopté 510. Ensuite, nous avons augmenté x de un, ce qui était égal à cinq à l'origine. Donc cinq à 66 plus 1016. Et puis nous avons imprimé le numéro un, qui était toujours bien. Et c'est parce que, comme je l'ai dit, ce périmètre étant ici x, juste une copie de l' argument transmis, qui était nul un. Et perte de majuscules, ce qui signifie que changer x ne modifie pas réellement la variable, c'est aussi pourquoi s'il s' agissait d'une constante, par exemple, cela fonctionnera très bien parce que nous n'avons pas essayé de modifier constant, nous changeons simplement la copie de cet être. J'espère donc que tout cela avait du sens. La principale chose que je veux que vous en retiriez est que vous pouvez transmettre des valeurs à une fonction en créant un paramètre , en indiquant simplement le type de données suivi d'un nom que vous souhaitez travailler. avec au sein de la fonction. Ensuite, la valeur que vous avez transmise s'appelle l'argument et sera copiée pour être utilisée dans votre fonction. Ensuite, vous devez simplement vous assurer que tous les paramètres que vous avez ici sont également placés dans votre prototype, et ils sont également requis lorsque vous appelez la fonction. Nous n'aurions donc pas pu dire add num one car nous aurions une erreur disant, hé, cela nécessite en fait plus d'arguments, est-ce pas ? Alors, vous l'avez. Vous savez maintenant comment travailler avec les paramètres et les arguments en C plus. Maintenant, je vais supprimer le PDG numéro un, et le supprimer pour cette constante ici, comme ça. Et ce que je veux que vous fassiez, c'est sauvegarder tout ce que nous avons ici, parce que nous allons l'utiliser dans la prochaine vidéo. Bref, merci de m'avoir regardée , et à bientôt dans la prochaine. 65. Chapitre 12 (Fonctions) : arguments optionnels: Dans cette vidéo, nous allons parler d' arguments facultatifs. Maintenant, si vous vous en souvenez, dans la dernière vidéo, je vous ai demandé de dire tout ce que vous aviez pour que nous puissions l' utiliser dans cette vidéo ici. Maintenant, si pour une raison quelconque vous n'avez pas regardé la dernière vidéo ou si vous avez oublié de l'enregistrer, hésitez pas à mettre la vidéo en pause et à copier le tout. Quoi qu'il en soit, allons-y et examinons arguments facultatifs et leurs cas d'utilisation. Donc, pour rendre un argument facultatif, tout ce que nous avons à faire est de définir le paramètre comme étant égal à quelque chose en bas notre déclaration de fonction de notre déclaration de fonction. Mais lorsque nous faisons cela, nous devons commencer par la plus à droite et nous diriger vers la gauche. Alors laissez-moi vous montrer ce que je veux dire par là. Je peux donc donner une valeur par défaut de 0. Nous allons donc avoir une erreur ici. Même argument par défaut, pas à la fin de la liste des paramètres. C'est pourquoi vous devez toujours commencer par la plus à droite. Donc, comme vous pouvez le voir, si je mets y égal à 0, tout ira bien. Ensuite, nous pouvons parcourir à gauche tous les paramètres pour lesquels nous voulons avoir une valeur par défaut. Et cela les rendra également facultatifs. Alors maintenant, là où j'ai dit ajouter num un, num deux, je peux simplement les supprimer complètement. Ensuite, nous devons faire une dernière chose avant exécuter notre code afin de ne pas avoir d'erreurs. Et c'est-à-dire que nous devons soit prendre notre méthode complète ici et la mettre en haut, comme ça. Et ça va très bien fonctionner. Donc, si nous exécutons notre code ici, vous pouvez voir que nous en avons imprimé un. Et c'est parce que nous avons ce x plus plus ici. Mais si nous le supprimons rapidement, vous pouvez voir si nous affichons 0 et si nous n'avons pas eu à transmettre d'arguments car les arguments étaient facultatifs car nos paramètres ont une valeur par défaut. Maintenant, l'autre option serait de laisser notre fonction là où nous l'avions. Juste comme ça. Supprimez cette valeur par défaut pour nos paramètres dans notre déclaration de fonction ci-dessous, et placez-la plutôt dans le prototype de la fonction. Et non, vous ne pouvez pas l' avoir dans les deux. Donc, si vous avez un prototype de fonction, c'est là que doivent figurer vos valeurs par défaut. Et il y a différentes raisons à cela, que je ne vais pas vraiment aborder. Mais sachez simplement que si vous voulez avoir un argument par défaut, vous devez donner à vos périmètres une valeur par défaut, commençant par celle qui se trouve le plus à droite et en revenant pour autant de valeurs par défaut arguments comme vous le souhaitez. Et si vous avez un prototype de fonction, ces valeurs par défaut doivent y figurer et non figurer dans notre définition de fonction. Et maintenant, si nous nous en débarrassons à nouveau ici et exécutons notre code, nous pouvons voir que nous allons imprimer 0. Nous pouvons changer ces valeurs comme nous le voulons, comme y est égal à cinq, et maintenant il affichera Hi. Très bien, alors voyons un meilleur exemple de cas où vous pourriez vouloir les utiliser. Débarrassons-nous donc de notre fonction ici. Ensuite, nous allons également nous débarrasser de tout ce qui se trouve ici et supprimer notre prototype de fonction pour commencer avec un canevas vide, par exemple. Ensuite, ici, créons un prototype pour cette fonction. Et ce que nous allons faire, disons annuler, envoyer du texte, ouvrir et fermer parenthèses et un point-virgule à la fin. Et puis, à l'intérieur, nous allons prendre une chaîne comme argument. Nous avons donc besoin d'un paramètre de chaîne et appelons simplement ce texte comme ceci. Ensuite, allons-y et créons la déclaration et la définition de la fonction réelles ci-dessous. Nous allons donc simplement le coller ici sans le point-virgule et créer notre bloc de code. Ensuite, nous allons simplement dire CL. Ensuite, allons-y et donnons à notre texte ici une valeur par défaut. Et parce que nous avons un prototype de fonction qui va devoir être placé ici. Donc, juste après que les textes disent « égal », vous n'avez pas envoyé de chaîne. La fonction. Cela nous permettra donc d'appeler notre fonction, mais nous avertira que nous n'avons pas réellement saisi de texte. Maintenant, dans ce cas, nous aurions pu simplement ne pas avoir de valeur par défaut et cela ne nous permettrait pas du tout d' appeler la fonction sans insérer de texte. Mais nous allons le faire de cette façon juste pour vous donner un exemple de la façon dont vous pourriez les utiliser. Et ensuite, ici, nous allons simplement appeler notre méthode. Nous allons donc dire imprimer du texte. Ensuite, allons-y et envoyons du texte ici. Nous allons donc dire imprimer le texte, bonjour, monde, point-virgule à la fin et exécuter notre code. Et comme vous pouvez le constater, nous avons imprimé Hello World. Et si nous n'avons rien mis ici et autour de notre code, cela indiquera maintenant que vous n'avez pas envoyé de chaîne à la fonction. Alors, tu y vas. Vous savez maintenant comment créer des arguments facultatifs. Et pour résumer, vous pouvez le faire en donnant un ou plusieurs paramètres, une valeur par défaut commençant par la droite et remontant vers la gauche, soit dans la déclaration de fonction ici, soit si vous avez votre prototype de fonction, il doit y être placé. Et d'ailleurs, juste un aperçu de la raison pour laquelle nous devons commencer par la droite et travailler vers la gauche en dehors du fait que nous recevrons une erreur et qu'elle ne nous laissera pas exécuter notre code est la suivante. Disons qu'après cela, je suis allé de l'avant et que j'ai pris un entier et que nous l' appellerons simplement x et que nous le mettrons égal à 0. Ensuite, nous allons supprimer la valeur par défaut pour le texte ici. Et ici, on va dire x, comme ça. Ensuite, en bas, nous allons dire C pour les textes, et nous imprimerons également x comme ça. Et allons-y et renommons-les jusqu'à la fin. Et si nous voulions être plus explicites ici, d'accord ? Et maintenant, si nous commençons à saisir des arguments ici, cela passe automatiquement de gauche à droite, car n' oubliez pas qu' ils doivent être en ordre. Donc, quand je mets un texte comme « low ». Et maintenant, cet argument de chaîne Hello ira automatiquement à notre premier paramètre. Mais comment nous a-t-on permis de le faire de cette façon ? Eh bien, alors nous n' aurions aucun moyen de donner une valeur à x sans donner une valeur au texte. De toute façon, le coucher du soleil est fait dans l'ordre. Quoi qu'il en soit, j'espère que tout cela avait du sens pour vous. Sinon, vous pouvez toujours me parler dans la section de discussion ci-dessous, et je vous répondrai dès que possible de toute façon. Merci de m'avoir regardée, et je te verrai dans la prochaine. 66. Chapitre 12 (Fonctions) : fonctions surchargées: Dans cette vidéo, nous allons parler ce que l'on appelle la surcharge de fonctions, c' est-à-dire que vous avez plusieurs fonctions sous le même nom mais avec des arguments différents. Et je vais vous montrer pourquoi vous voudriez le faire avec un exemple ici. Alors allons-y et créons une fonction pour additionner des nombres. Donc, en bas, nous allons dire int. Et puis la parenthèse NR, nous dirons int x virgule y, comme ça. Ensuite, dans notre bloc de code, nous dirons return x plus y. Allons-y et plaçons notre prototype de fonction en haut. Nous allons donc simplement le copier, coller ci-dessus et mettre un point-virgule ici. Et n'oubliez pas que si nous voulions des valeurs par défaut ici, elles devraient apparaître ici. Donc, il suffit de copier et coller, cela ne fonctionnerait pas. Il faudrait ajouter quelque chose comme x est égal à 0 et y est égal à 0. Maintenant, allons-y et surchargeons cette fonction pour prendre un ensemble d'arguments différent. Donc, pour ce faire, nous allons simplement copier cette méthode et la coller ci-dessous, comme ça. Ensuite, nous allons dire une virgule et un z. N'oubliez pas que nous pouvons l'appeler comme nous voulons. Ensuite, nous dirons que renvoie x plus y plus z. Ensuite, nous allons copier cette ligne supérieure ici, la coller au-dessus et mettre un point-virgule à la fin. Et voilà. Nous avons maintenant deux fonctions distinctes et leurs prototypes de fonctions respectifs qui portent le même nom mais des arguments différents. Et c'est ce qu'on appelle la surcharge des fonctions. Maintenant, dans notre fonction principale, je peux dire quelque chose comme CL, ajouter le nom de notre fonction. Et dans Visual Studio , vous pouvez au moins voir que j'ai deux options. Et si je passe la souris dessus, cela indique plus deux surcharges. Mais cela m'avertit qu'aucune instance de la fonction surchargée nommée add ne correspond à la liste des arguments. Et c'est parce que je n'ai rien mis ici. Mais maintenant, vous pouvez voir que j'ai une fonction d' ajout qui prend deux en valeurs, et j'ai une deuxième fonction d'ajout qui prend, signifiant. Je pourrais dire quelque chose comme cinq virgules cinq. Assurez-vous de mettre un point-virgule à la fin et exécutez mon code. Et vous pouvez voir que nous en avons imprimé dix, et cela fonctionne très bien, pas de problème. Mais je pourrais aussi ajouter une autre valeur entière maintenant et regarder ça. Nous en avons imprimé 15. Cette fonction d'ajout est donc un parfait exemple de cas où vous pourriez vouloir faire quelque chose comme ça. Et je peux en faire autant que je le souhaite. Donc, je pourrais simplement utiliser cette fonction d'ajout pour ajouter autant de variables entières que je le souhaite. Une autre chose que nous aurions pu faire est d'utiliser un type de données complètement différent. Nous allons donc copier à nouveau notre méthode d'ajout ici et les coller ci-dessous entre les deux autres, comme suit. Et au lieu de dire «  entrez tout cela », nous allons commencer et dire « flotter ». Ensuite, nous allons copier notre première ligne. Collez-le ici pour créer un prototype. N'oubliez pas le point-virgule à la fin. Et maintenant, je peux mettre des variables flottantes, cela fonctionnerait très bien. Comme si c'était un 3.3 à 5,5 virgules ou quelque chose comme ça. Et exécutez notre code. Maintenant, nous allons obtenir 8,8, juste comme ça. Donc c'est plutôt chouette. Et c'est encore une fois un parfait exemple de cas où vous voudriez utiliser la surcharge de fonctions, car maintenant je peux avoir une fonction appelée add. Je n'ai pas besoin de me souvenir d'un tas de noms de fonctions différents. Et je peux lancer des chars, je pourrais lancer un pouce. Et je peux aussi avoir différentes quantités de nombres ou de variables que j'y ajouterais. Et je n'aurai aucun problème tant que j'aurai créé une déclaration et une définition pour chaque ensemble d'arguments que je voudrais utiliser. Et si nous le voulions, nous aurions même pu donner à l'une de ces valeurs, comme la première ici, des valeurs par défaut. Donc, là-haut, j'aurais pu dire que x est égal à 0 et y est égal à 0. Et cela fonctionnera bien aussi. Donc maintenant, je ne pouvais rien avoir ici, ou j'aurais pu créer une autre fonction d'ajout qui ne prenait tout simplement pas d' arguments dans ce cas. Mais vous devez être prudent lorsque vous le faites, car si j'avais fait de même avec celui-ci, il se pourrait qu'il ne sache pas de quoi je parlais au départ. Alors avais-je fait quelque chose comme ça depuis le début ? Eh bien, maintenant, je ne sais plus quoi je parle, car cet appel de fonction d'ajout fonctionnerait pour plus d'une instance de la fonction surchargée. C'est donc un problème accordé dans ce cas, ils sont tous définis sur 0. Alors qui s'en soucie si on a imprimé 0 ? Mais vous obtiendrez évidemment une erreur. Notre code ne fonctionnera donc plus tant que nous n' aurons pas résolu ce problème. Je voulais juste vous informer à ce sujet. Bref, c'est tout pour cette vidéo. J'espère que vous comprenez maintenant comment fonctionnent les fonctions surchargées et quand vous souhaiterez les utiliser. Merci de m'avoir écouté , et à bientôt. 67. Chapitre 12 (Fonctions) : la Recursion: Dans cette vidéo, nous allons parler de ce qu' on appelle la récursivité, où quelque chose fait essentiellement appel à lui-même. Et nous allons le faire avec une fonction qui nous donnera la factorielle d'un nombre. Si tu ne sais pas ce que c'est, laisse-moi te le montrer rapidement. Donc, la factorielle d'un nombre est quelque chose comme ça. Disons que nous lui avons donné le chiffre cinq, la factorielle E 45. Voici ce qui suit. Ce serait cinq fois le chiffre inférieur. Donc quatre fois le chiffre en dessous, soit trois fois deux fois un. Et cela nous donnerait la factorielle de cinq. Donc, en gros, vous allez multiplier le nombre que vous avez inscrit par ce nombre, par un en dessous, jusqu'à ce que vous obteniez un, multipliez-le complètement et cela vous donnera votre factoriel. Et nous allons en fait utiliser cinq dans la méthode allez créer juste pour que vous sachiez qu'elle fonctionne correctement. Donc, si nous utilisons une calculatrice ici et disons cinq fois, quatre fois trois fois deux fois une, vous pouvez voir que nous obtenons 120. Très bien, alors allons-y et créons une fonction qui les fasse. Maintenant, il existe plusieurs façons répliquer cela dans le code, mais nous allons le faire avec récursivité où nous avons quelque chose appelé lui-même. Alors allons-y et créons un exemple de cela. Donc, ci-dessous, nous allons créer une méthode qui nous donnera la factorielle de tout nombre que nous y insérons. Donc, ici, nous allons dire enter et nous appellerons cela factoriel. Et puis entre parenthèses, nous allons dire nombre. Ensuite, dans notre bloc de code, nous dirons que si le nombre est supérieur à un, nous voulons procéder comme suit, à savoir renvoyer le nombre de fois. Ensuite, nous allons à nouveau faire appel à la méthode factorielle, comme celle-ci. Ici, nous allons dire le nombre moins un. Et puis ici, nous allons créer une instruction else comme celle-ci et dire « sinon » en renvoyer une. Cela peut sembler un peu confus, mais nous allons créer une autre méthode qui fait la même chose sans récursivité. Ensuite, j' essaierai de les séparer du mieux que je peux. J'espère que tout cela a du sens quant à la façon dont cela fonctionne en arrière-plan. Mais d'abord, allons-y et créons notre prototype de fonction avant de l'oublier. Je vais donc le coller ci-dessus et lancer un point-virgule. Maintenant, ci-dessous, cela créera une autre méthode, par exemple, n factorielle. Nous allons simplement appeler cette factorielle deux, par exemple, disons nombre entier. Et c'est un parfait exemple de cas où vous pourriez simplement vouloir lui donner à une variable le même nom qu'une autre, car elle est très lisible. Ils ne sont pas du tout connectés. La portée finale est incluse dans la fonction, donc mineure. Et puis, à l'intérieur de notre bloc de code, nous allons dire la factorielle suivante. Un. Ensuite, nous allons créer une boucle for et dire que int I est égal à un, alors que j'entends que c'est inférieur ou égal au nombre I plus, plus. Et puis entre crochets, on dira que temps factoriel est égal à I, genre. Donc. Ensuite, en dehors de cela, nous irons de l'avant et reviendrons. Cela devrait faire exactement la même chose. Ensuite, avant que j'oublie, allons-y et créons-en un prototype de cette manière. Alors maintenant, ici, allons-y et faisons appel à ces deux méthodes. Dites donc la ligne factorielle CL. Et puis en dessous de cette factorielle ACL moyenne par rapport à la ligne N. N'oubliez pas les parenthèses ici, comme ça. Ensuite, nous en ajouterons cinq pour les deux. OK, donc je vais faire un zoom arrière sur les cliniques, vous pouvez vous assurer que votre code correspond au mien ici. Et allons-y et exécutons-le. Comme vous pouvez le constater, nous avons la 120e position pour les deux bosses, ce qui était la factorielle pour le VIH. En réalité, aucune de ces fonctions ne semble trop mauvaise, mais ce n'est qu'un exemple d'utilisation de la récursivité des fonctions pour effectuer une tâche. Donc, que se passe-t-il réellement ici sous le capot, car cela peut sembler un peu confus pour quelqu'un, eh bien, tout d'abord, nous avons dit si le nombre est supérieur à un, donc si nous avions l' exemple de cinq ici, Eh bien, est-ce que cinq est plus qu'un ? Et la réponse est oui. Donc, ce que nous allons faire, c'est renvoyer un nombre cinq fois supérieur à la factorielle du nombre situé en dessous. Ce que cela va renvoyer un entier. Mais quand celui-ci sera adopté, il dira que c'est pour plus d'un. Oui, ça l'est. Maintenant, nous voulons quatre fois plus que ce chiffre, et cela va continuer jusqu'à ce que nous arrivions à un point où le nombre est égal à un. Et ensuite, il va juste rendre quoi ? Vous devez vous assurer que j'ai finalement cette récursion ici, nous arrêterons et que cela n' arrivera pas à l'infini. Sinon, sans trop entrer dans les détails, on va trop dans les mauvaises herbes. Vous allez manquer de mémoire et vous allez avoir des problèmes parce que vous créez une autre fonction dans une fonction, dans une fonction. Et cela ne fait que s' accumuler et s'accumuler, et puis vous finissez par rencontrer des problèmes. Alors allons-y et voyons ce qui se passe. Donc, pour ce faire, allons-y et commençons par le tout dernier cas. Donc, à la fin de tout cela, nous allons avoir une fonction qui dit, d'accord, nous voulons retourner deux fois une, parce que ce sera ce qui reviendra de la fonction ici. Une fois que c'est égal à un, parce que le nombre n'est pas supérieur à un, parce que ce serait un, il en retournera un. Donc, à la fin, je reviendrai deux fois une. Ensuite, la fonction qui essayait d'obtenir le résultat de cette équation ici, eh bien, j'ai trois fois, trois fois deux, qui sont ensuite descendues à deux, une. Ensuite, la fonction ci-dessus. On en aura quatre fois trois, comme ça. Et finalement, nous aurons cinq fois le résultat de tout cela. Donc, essentiellement, nous avons maintenant la fonction qui vient d'en renvoyer une. Ensuite, nous avons une deuxième fonction qui a fait ce calcul ici, une troisième fonction plutôt qu'une quatrième fonction cinquième. avez donc créé cinq fonctions uniquement en insérant ces cinq fonctions ici. Donc, ce qui va se passer, c'est cette première fonction, nous allons simplement en renvoyer une. Le second renverra une valeur de deux, le suivant une valeur de six, puis 24. Enfin, cinq fois 24, cela nous donne 120. Alors, tu y vas. C'est ainsi que nous avons obtenu notre réponse finale. Maintenant, j'espère que cela a du sens. Si ce n'est pas le cas, n'hésitez pas à vous connecter en ligne et à examiner davantage la récursivité et d'autres exemples, à travailler avec et à vraiment décomposer ce qui se passe. Maintenant, comme je l'ai dit, vous devez faire attention à ne pas créer trop de fonctions lorsque vous faites cela. Et vous devez également vous assurer que cela ne se produira pas à l'infini pour la même raison que vous manquerez de mémoire à un moment donné. Donc, dans ce cas, c'était notre point d'arrêt où, une fois que le nombre n'était plus supérieur à un, nous revenions simplement à un. Et ce point d'arrêt s'appelle votre cas de base en matière de récursivité. Alors, tu y vas. J'espère que vous avez maintenant une compréhension de base de ce qu'est la récursivité des fonctions et que vous savez comment l'utiliser et les choses à faire attention lorsque vous l'utilisez de toute façon. C'est donc tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 68. Chapitre 12 (Fonctions) : tableaux en tant que paramètres: Dans cette vidéo, nous allons parler de transmission de tableaux comme argument. Mais avant de le faire, je tiens à mentionner une chose. Nous avons déjà parlé des types et des fonctions de retour, mais je tiens à vous faire savoir qu'une fois que vous aurez cette instruction de retour et que vous aurez renvoyé quelque chose à la couleur, quel que soit le nom de votre fonction, aucun code de mot de passe ne sera exécuté. Donc c'est un peu comme sortir de son innocence. Donc, ici, je vais dire CL, bonjour, comme ça, et exécuter notre code. Il ne va même pas lire ça. Il ne l' imprimera pas car nous avons déjà reçu un relevé de retour. Ainsi, lorsque vous créez une fonction qui a un type de retour, notez qu' une fois que vous aurez une instruction return, elle arrêtera de lire le code et votre fonction et reviendra simplement à l'appelant ou à l'endroit où vous appelez votre fonction en premier lieu. Donc, si vous avez plusieurs instructions if ou quelque chose comme ça, vous pourriez avoir plusieurs déclarations de retour et cela fonctionnera très bien. Je voulais juste vous informer qu' une instruction de retour peut également être considérée comme une instruction de rupture renvoyant une valeur. Alors allons-y et voyons comment les tableaux sont transmis en tant qu'arguments. Tout d'abord, allons-y et créons un tableau. Nous allons donc mettre mon tableau entre crochets ici. Cela lui donnera juste une taille de cinq. Et allons-y et donnons-lui cinq valeurs dès le départ. Nous allons donc dire 1234. Ensuite, allons-y et créons une fonction qui imprimera un tableau. Donc, nous allons dire void, imprimer un tableau, comme ça, puis entrer des parenthèses ici, nous allons créer un paramètre qui prend un tableau comme argument. Nous devrons donc toujours avoir le type de données comme d'habitude. Ensuite, nous aurons ici un nom avec lequel nous voulons travailler dans le cadre de notre fonction, comme d'habitude. Ensuite, nous aurons des crochets ouverts et fermés pour signifier qu'il s'agit d'un tableau et pas simplement d'un entier. Ensuite, ci-dessous, nous allons créer notre bloc de code ici pour notre fonction. Ensuite, ici, nous allons imprimer tous les éléments de notre tableau. Nous allons donc dire que pour I est égal à 0, I inférieur à cinq, I plus, plus. Et puis, entre parenthèses, il y avait un PDG. Et puis le nom de notre paramètre étant ARR, alors que n crochets indiqueront que je vais créer une nouvelle ligne. Et maintenant, si vous êtes ici dans notre fonction principale, vous pouvez également regarder comme notre couleur, puisque c'est ce qui va appeler notre fonction PrintArray. Nous pouvons dire imprimer un tableau puis , entre parenthèses, passer dans mon tableau. Je peux donc mettre un point-virgule. Notez que nous ne mettons aucun crochet ici dans notre argument ni aucun chiffre. Maintenant, avant d'exécuter un code, nous devons simplement créer un prototype de fonction ici en haut et l'exécuter. Vous pouvez voir que nous l' imprimons 12345. Maintenant, remarquez que nous sommes allés de l'avant et que nous avons mis la taille ici de manière explicite. Et ce n'est pas génial parce que ce n'est pas très dynamique. Mais le problème, c'est que nous ne pouvions pas mettre une taille comme argument ici. Donc, pour résoudre ce problème , vous devriez dire une virgule ou quelque chose comme ça. N'oubliez pas que vous pouvez le nommer comme vous le souhaitez , puis mettre une taille inférieure à la taille ici. Et ici, nous voudrions changer notre prototype. Ensuite, nous avons mis la taille ici. Et cela fonctionnerait très bien. Comme vous pouvez le voir, nous avons imprimé 12345. Et c'est la meilleure façon de passer un tableau en argument, car en ayant le tableau et la taille d'une variable séparée cela fonctionnera et dynamiquement maintenant. Donc maintenant, si nous définissons notre tableau, il aura une taille de sept, par exemple. Et puis je suis là. Nous avons deux autres éléments ce type et nous les avons modifiés ici. Notre fonction continuera de fonctionner comme nous le souhaitons. Maintenant, quelque chose que vous pouvez faire est de mettre une taille ici, comme ça. Et cela fonctionnera très bien aussi. Le problème, c' est que si la taille de notre tableau change ici, vous ne pourrez pas accéder à ces autres valeurs car il ne saura pas de quoi vous parlez. Donc, si ici, j'ai dit que CL est le nom de notre paramètre ici, puis j'en mets sept, par exemple, et exécutez notre code. Vous pouvez voir que nous obtenons une réponse vraiment étrange. Et c'est parce qu'en ce qui le concerne, notre réseau a une taille de cinq. Pouvons-nous simplement demander le septième élément et nous n'allons pas vraiment comprendre pourquoi cela s'est produit. Mais sachez que même si cela était possible, ce que nous faisions auparavant n'avait qu'une taille vide. Ensuite, une variable de taille distincte est le meilleur moyen de le faire. Maintenant, l'autre point intéressant à propos l'utilisation d'un tableau en tant que paramètre , c'est qu'il est effectivement passé par référence et nous reviendrons sur les références plus tard. Mais en gros, lorsque nous travaillions avec des variables comme paramètres, elles étaient transmises par valeur et nous en créions une copie. Je l'ai démontré dans une vidéo précédente, mais avec les tableaux, ils sont transmis par référence. Et c'est parce que N C plus plus vous ne pouvez pas transmettre un tableau par valeur et en créer une copie. Et nous n' allons pas expliquer pourquoi, mais essentiellement parce que cela est transmis par référence, nous ne créons pas de copie de ce tableau, et nous travaillons essentiellement avec le tableau directement. Donc maintenant, si je dis que ARR indexé 0 est égal à dix, comme ça à la fin de notre fonction ici, puis imprimez-le. Mon tableau indexe 0, comme ça, et exécute notre code, vous pouvez voir que nous en imprimons dix. Et c'est parce que même si nous travaillions avec le nom de notre paramètre ici, les tableaux sont transmis par référence. Comme je l'ai dit, nous aborderons les références dans une prochaine vidéo. Nous sommes essentiellement en mesure de travailler avec l'original plutôt qu'avec une copie de celui-ci. Donc, si nous changeons quelque chose ici avec notre périmètre, nous modifierons également l' original. Donc, en gros, la principale chose que je veux que vous retiriez de cette vidéo, c'est que si vous voulez utiliser un tableau comme paramètre, vous allez le faire comme suit. Vous allez avoir le type de données des tableaux suivi d'un nom avec lequel vous souhaitez travailler. Ensuite, utilisez simplement vos crochets pour indiquer qu'il s'agit d'un tableau. Vous aurez besoin d'une variable distincte pour la taille réelle de ce tableau. De plus, les tableaux sont transmis par référence, ce qui signifie que lorsque nous changeons quelque chose en utilisant le nom de notre paramètre ici, nous modifierons également l'original. Donc, en faisant un peu de planification, cela modifie l'original car il ne s'agit pas ici d'une copie comme lorsque vous travaillez avec d'autres types de données. Donc, juste pour vous montrer cela encore une fois, si nous disons que x est égal à sept puis que nous transmettons x comme variable entière, puis que nous changeons la valeur de la taille ici en disant size plus, plus, puis print dehors x en bas. Allons-y et lançons cela sur une nouvelle ligne pour que ce soit un peu plus évident. Vous pouvez voir qu'il nous en reste sept. Et c'est parce que les autres types de données utilisés comme argument sont transmis par valeur. Par conséquent, la taille ici n'est qu'une copie de cette valeur et n'aura aucun effet sur l'original. Mais une course en particulier est passée par référence, ce qui signifie essentiellement que nous allons travailler avec l'original et ne pas créer de copie du tout. Donc, lorsque nous avons modifié notre périmètre ici, nous avons également modifié l'original. J'espère que cela a du sens. Si ce n'est pas le cas, ne vous inquiétez pas, nous parlerons références dans la prochaine vidéo. Donc, la seule chose que vous devez vraiment retenir de cette vidéo est de savoir comment prendre un tableau comme paramètre. abord, vous voulez dire que vous prenez un tableau en utilisant les crochets et le type de données de ce tableau, et vous donnerez le nom de ce paramètre comme d'habitude, puis vous devez avoir un variable pour sa taille car il ne peut pas être aston avec l'argument ici. Il suffit donc de le mettre séparément. Enfin, sachez simplement que les tableaux sont spécifiquement transmis par référence, ce qui signifie que si vous modifiez le paramètre ici, vous jouez essentiellement avec l'original. Bref, j'espère que vous avez apprécié. Merci de m'avoir écouté , et à bientôt. 69. Chapitre 13 (Références) : Intro aux références: Dans cette vidéo, je vais vous donner une brève introduction aux références. D'accord, donc j'ai référencé un alias ou un autre nom pour autre chose. Ainsi, par exemple, beaucoup de gens ont des surnoms. Disons que tu t' appelles Jonathan. Les gens peuvent t'appeler John, et ils font référence à la même chose. Donc, dans cet exemple, John ferait référence à Jonathan, nous parlerons de la même personne. Et c'est essentiellement ce à quoi fait référence un C plus plus. Ainsi, par exemple, nous pouvons avoir un entier appelé x, et disons simplement qu' il est égal à 0. Et puis nous pourrions avoir une référence appelée surnom ou quelque chose comme ça. titre d'exemple terrible, cela équivaut à x. Maintenant, nous pouvons simplement dire que x est surnommé ici, et nous allons parler de la même chose. Et si nous définissons x surnom égal à cinq plus tard. Donc, si ici je dis que x surnom est égal à cinq. Maintenant, x serait égal à cinq parce que je fais référence exactement à la même chose. Une référence n'est donc qu'un alias ou un autre nom pour autre chose. Et nous aborderons quelques exemples, ainsi que la manière d' en créer un pour elle-même dans les prochaines vidéos, et nous examinerons certains des différents cas d' utilisation à titre référence afin que vous sachiez comment pour les utiliser dans vos propres programmes. Quoi qu'il en soit, j'espère que tout cela a du sens et, comme toujours, merci de m'avoir regardé et à bientôt. 70. Chapitre 13 (Références) : Créer une référence: Dans cette vidéo, nous allons créer une référence de base. Voyons donc comment cela s'est passé. La syntaxe de notre référence est donc la suivante. Vous allez d'abord avoir le type de données. Autre chose à laquelle vous ferez référence. Ensuite, vous allez suivre avec le symbole d'esperluette tel que SO, suivi du nom de la référence. Ensuite, vous le définirez comme étant le nom de référence, qui est une chose à laquelle vous faites référence. OK, alors allons-y et créons-en un ici. Nous dirons que int x est égal à cinq. Et puis en dessous, nous dirons int esperluette. Et nous appellerons cela X égal à X. D'accord ? Nous avons donc le type de données de l'objet auquel nous faisons référence, conservé par le symbole de l'esperluette, puis le nom de notre référence. Et tu peux l'appeler comme tu veux, suivi du nom. Maintenant, si vous vous souvenez que dans la dernière vidéo, j'ai dit une référence, donc il y a juste un alias pour parler de la même chose. Maintenant, nous pouvons utiliser X-Ray ou notre nom de référence ici pour faire tout ce que nous pouvons avec x en disant simplement x. Et donc ici, je pourrais dire quelque chose comme x ref est égal à dix. Et si nous imprimons x maintenant, comme ça, il en imprimera dix. Et nous aurions même pu simplement les imprimer et les référencer directement. Et cela en imprimerait également dix. Donc, une référence sous la forme d'un alias ou d'un autre nom pour la chose à laquelle elle fait référence. Ceci et cela sont essentiellement la même chose. Maintenant, une chose que je tiens également à mentionner est que vous ne pouvez pas déclarer une référence , puis l'initialiser ultérieurement. Cela doit être fait sur la même ligne, même manière que les constantes, par exemple, fonctionnent, car vous ne pouvez pas non modifier votre référence ultérieurement. Donc, si je dis que y est égal à dix, je ne peux pas changer x ref pour qu'il soit égal à quoi ? Eh bien, je pourrais dire que extra est égal à y, mais cela changerait simplement x. Ce ne serait pas un surnom pour y maintenant, et vous pouvez le voir si j'imprime x ref et x ici sur la même ligne, puis nous allons créer une nouvelle ligne. Ensuite, nous changerons y pour qu'il soit égal à 15. Ensuite, ici, nous allons écrire C et nous en imprimerons un peu plus. Pourquoi ? Ainsi, si je lance mon code ici, vous pouvez voir que nous en avons imprimé dix parce que extra a été défini comme égal à x, qui était cinq. Ensuite, nous mettons x fondamentalement égal à y, maintenant x est égal à dix. Nous en avons donc imprimé dix parce que f et x supplémentaires sont la même chose. Et puis nous en avons imprimé dix à nouveau, parce que encore une fois, ces deux sont exactement les mêmes maintenant, puis nous changeons le y à 15, mais quand nous l'imprimons, X ref ou x, en gros, il était toujours dix et y était 15, donc nous avons imprimé 15 après. J'espère donc que cela a du sens. Une fois que vous avez dit que j'ai référencé égal à quelque chose, vous ne pouvez pas le changer. Après cette ligne, notre référence est gravée dans la pierre. Extra aura toujours l' équivalent de x et vice versa, c' est-à-dire y, x changera les dix lorsque nous changeons x ref l'heure. Ok, alors tu y vas. C'est ainsi que vous créez une référence de base. Tout ce que vous allez faire est de dire le type de données de l'objet auquel vous voulez faire référence, suivi du symbole d' esperluette, puis vous aurez le nom de votre référence et vous pourrez l'appeler comme vous le souhaitez tu aimerais. Ensuite, vous aurez ce à quoi il va faire référence. Et vous l'avez de toute façon. Merci de m'avoir écouté et je vous verrai dans la prochaine. 71. Chapitre 13 (Références) : Références et boucles de précurseur: Dans cette vidéo, nous allons parler de références une fois de plus, mais nous parlerons spécifiquement l'utilisation de références avec pour chaque boucle. Alors allons-y et jetons un coup d'œil à cela. Tout d'abord, nous allons créer un tableau d'entiers. Nous allons donc dire int mon tableau, puis nous aurons quelques crochets ici. Ensuite, nous allons ajouter quelques chiffres. Donc, dites un, virgule deux. D'accord, nous avons donc un tableau int de taille cinq avec cinq valeurs différentes. N'oubliez pas que si vous le vouliez, vous pouvez le mettre ici aussi. Il est donc plus facilement lisible. Combien de valeurs se trouvent dans votre tableau, mais vous n'en avez pas besoin. Ensuite, nous allons imprimer tout ce qui se trouve sur notre droite et sur notre boucle foreach comme nous l'avons fait par le passé. Et je m'excuse d'avoir utilisé les mêmes exemples encore et encore dans plusieurs vidéos. Mais le but, c'est de n'introduire qu' une seule nouvelle chose à fois afin que vous puissiez mieux comprendre tout. Très bien, donc ici, nous allons créer un pour chaque boucle et nous allons dire quatre. Ou nous pourrions dire auto, si vous vous souvenez, puisque nous voulons le même type de données que notre conteneur de toute façon, et ensuite nous dirons x deux-points dans mon tableau, comme ça. Ensuite, entre crochets, nous allons mettre notre code, disons CL x, et nous allons créer une nouvelle ligne juste comme ça. Maintenant, si je lance notre code ici, vous pouvez voir que cela fonctionne très bien. 12345. Maintenant, si nous voulions changer la valeur normale des éléments de notre tableau, cela ne fonctionnerait pas. Et c'est parce que X n'est qu' une copie de ces valeurs ici. Nous ne pouvons pas dire que x est égal à cinq et nous attendre à ce que cela modifie les valeurs réelles de ces indices. Donc, si nous exécutons notre code, vous pouvez voir que nous allons juste imprimer 55 fois. Et ensuite, si nous devions imprimer à nouveau notre tableau, donc si nous copions ceci ici et que nous l'imprimions à nouveau, et nous supprimerons simplement ce x égal à cinq lignes. Vous verrez que cela ne changera pas. Vous l'imprimez donc 55 fois, puis vous l'imprimez 12345 soit les valeurs stockées dans notre tableau. Cependant, si nous faisons référence à notre tableau ou à un autre nom pour notre tarif, si vous le souhaitez, cela fonctionnera. Donc, tout ce que nous avons à faire, c'est qu'après l'auto, nous allons ajouter le symbole de l'esperluette comme ça. Et maintenant x sera une véritable référence à ces valeurs, ce qui est plutôt intéressant. Donc, si nous exécutons notre code, encore une fois, vous pouvez voir que nous avons imprimé 510 fois, car au fur et à mesure de son exécution, X était en fait le même que chacune de ces variables ici. Et bien que j'aie mentionné dans la dernière vidéo qu'une référence ne peut pas être modifiée, ce qui se passe réellement ici c' est qu'à chaque fois qu'elle parcourt notre code, ou pour chaque boucle, elle crée une référence appelée x, en le mettant à l'index 0 la première fois. Et puis en exécutant ce code, je vais créer une autre référence appelée x et la définir comme étant l'index un. Et il passe dans l' ordre, juste comme ça, créant à chaque fois une nouvelle référence qui n'existe plus après notre bloc de code. Donc, ne vous inquiétez de rien. Et comme il s'agit d'une référence, nous sommes en mesure de modifier les valeurs d'origine. L'autre avantage des références est que, comme nous travaillons avec l'original, nous ne créons nous travaillons avec l'original, pas une copie qui peut coûter très cher. Donc, par exemple, si j' initialisais simplement chaque valeur mon taux à 0 et que j'avais alors un tableau de mille. Cela fonctionnera très bien. Et si je courais, cela serait imprimé un millier de valeurs. Mais comme cela a été transmis par référence, vous suffit de modifier la valeur et de l'imprimer. Mais comment ne pas être passé par référence, comme nous l'avons fait ici. En fait, nous avons dû créer une copie de toutes les 1 000 valeurs et l'imprimer. Et en ce moment, nous travaillons avec des entiers, et c'est la seule chose dans notre programme, donc ce n'était pas si mal. Mais lorsque vous travaillez avec des types de données plus volumineux et plus d'informations, cela peut coûter très cher. Donc, faire quelque chose comme ça ici est plus efficace. Voici donc un autre exemple montrant quand utiliser une référence et comment elle peut être utilisée pour chaque boucle. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 72. Chapitre 13 (Références) : Références en tant que paramètres: Dans cette vidéo, nous allons à nouveau parler de références, mais nous allons spécifiquement parler de références en tant que paramètres. Et si vous vous souvenez que dans une vidéo précédente, nous avions déjà travaillé avec tableaux transmis par référence, mais maintenant nous allons également transmettre d'autres types de données par référence. Alors allons-y et voyons comment cela se fait. abord, nous allons créer une variable entière ici. Donc disons int num un est égal à cinq. Et puis en dessous, allons-y et imprimons numéro un, juste comme ça. Ensuite, ici, nous allons créer une méthode et dire void, ce qui signifie que nous n'avons pas besoin d'un type de retour. Et nous dirons réglé sur dix, par exemple. Ensuite, entre parenthèses, nous prendrons un entier et nous l'appellerons simplement x. À l'intérieur, nous dirons que le texte est égal à dix. Ensuite, nous allons créer un prototype pour notre fonction ci-dessus. N'oubliez donc pas le point-virgule. Ensuite, il ne nous reste qu'à appeler notre bureau ici. Nous disons réglé à dix. Les parenthèses ouvertes et fermées mettront num un à l'intérieur et un point-virgule à la fin. Et si nous exécutons un code, il en imprimera cinq. Et c'est parce que les autres types de données en dehors des tableaux sont transmis par valeur. Cela signifie que lorsque nous avons mis num un ici comme argument, x était égal à la valeur de num un étant cinq. Ensuite, nous avons dit essentiellement que cinq égale dix. Eh bien, cela n'a pas du tout changé. C'est pourquoi, lorsque nous l'avons imprimé en un, il était toujours bien. Mais si on passe par référence en mettant l'esperluette devant le type de données ici. Et nous devons également le faire dans notre prototype. Eh bien, maintenant x est un surnom ou un alias, ou une préférence, ou quel que soit le nom que vous voulez donner à ce nom. Donc, quand notre code a été exécuté, nous nous sommes dit, d'accord, nous allions créer une référence appelée x et lui attribuer valeur de ce qui est transmis en tant que numéro un. Ensuite, nous avons essentiellement dit que num un est égal à dix. Donc, lorsque nous exécutons notre code et que maintenant, numéro un est dix, et c'est parce que x était une référence à ce que nous avons transmis. Alors, tu y vas. C'est ainsi que vous pouvez utiliser des références comme paramètres. Maintenant, cela présente le même avantage que pour chaque boucle où, à chaque fois que cela passe, cela créera une nouvelle référence et la définira égale à la valeur que nous transmettons. Donc la prochaine fois que nous l'appellerons, si nous disons que num deux est égal à trois par exemple. Ensuite, nous avons copié notre appel de méthode ici et en avons mis deux. Ensuite, nous allons imprimer un espace suivi de deux. Ils seront tous deux égaux à. Et c'est parce que chaque fois qu'il passe, il crée une nouvelle référence appelée x et égale à n'importe quel argument que nous avons transmis. Donc, x n'est pas réellement remplacé par une autre référence. Il s'agit d'une toute nouvelle référence appelée x, qui n'existe plus une fois ce bloc de code terminé. C'est pourquoi cela fonctionne. Maintenant, ce que je veux mentionner, c'est que vous pouvez transmettre quelque chose ici pour d'efficacité et vous assurer de ne pas modifier cette valeur. Supposons par exemple que nous transmettions un livre de texte entier et que cette méthode consistait à l'imprimer. Eh bien, nous ne voudrions pas créer une copie complète de ce livre de textes chaque fois que nous utilisons cette méthode. Au lieu de cela, nous voudrions probablement faire quelque chose comme ça en travaillant simplement avec le même livre de texte, puis en nous assurant de ne pas modifier ce texte à la suite d'une erreur utilisateur dans notre bloc de code ici, tout ce que nous J'ai à faire c'est de dire const. Et cela nous évitera de jouer avec cette variable maintenant en disant : «  Hé, ce n'est pas modifiable. Cela évitera donc toute erreur utilisateur de votre part ou de toute autre personne qui pourrait être en mesure de modifier votre code. Il sera très évident que je voulais juste une référence à ma variable, mais je ne voulais pas vraiment modifier cette variable. Donc, peu importe ce que j'ai mis dans ce bloc de code, ça ne me laissera pas jouer avec ça maintenant. Vous pouvez donc utiliser le mot clé const pour créer une constante même s' il s'agit d'une référence, juste pour vous assurer que vous ne pouvez pas la modifier. Je veux juste que cela soit lu uniquement en gros. Et cela vous permettra essentiellement de gagner en efficacité sans avoir la possibilité de changer l'original. Donc c'est génial. Quoi qu'il en soit, c'est tout pour cette vidéo. Je voulais juste vous montrer comment utiliser des références avec des paramètres. Quoi qu'il en soit, comme toujours, merci de m'avoir écouté, et à bientôt. 73. Chapitre 13 (Références) : Références en tant que types de retour: Dans cette vidéo, je suis vraiment désolée, mais nous parlons de références. Encore une fois. Cependant, cette fois, nous parlons références en tant que types de retour. Alors allons-y et voyons comment cela se fait, ainsi que le cas d' utilisation réel de cela. Donc, ce que nous allons faire est de créer un tableau int pour commencer. Nous allons l'appeler mon tableau, et nous allons le définir comme étant 12345, juste comme ça. Et nous allons aller de l'avant et dire explicitement : « Hé, nous avons des valeurs élevées ici. Très bien, maintenant, en dessous, allons-y et imprimons tout ce qui se trouve dans notre tableau. Il dira pour auto x, deux-points sur mon tableau, juste comme ça. Et des supports frisés à l'encre. Nous irons de l'avant et X sur une nouvelle ligne à chaque fois. Créons donc un espace vide entre les deux car nous allons mettre quelque chose ici dans un instant. Et puis ici, allons-y et créons notre fonction réelle ou une méthode, si vous le souhaitez. Donc on va faire, disons, suivi du symbole de l' esperluette. Ensuite, nous dirons de définir la valeur comme ça pour le nom de notre fonction. Et puis, entre parenthèses, nous allons simplement prendre un entier, donc un x sécant. Donc, nous aurons quelques accolades. Et puis ici, nous allons dire de transformer mon tableau en index X. Et allons-y et appelons cela juste trait pour index. Maintenant, vous remarquerez que nous obtenons une erreur car notre tableau n'est pas défini. Donc, ce que nous devons réellement faire, c'est prendre notre tableau ici et mettre en dehors de toute fonction de ce type. Ensuite, nous allons également copier notre méthode ici, ou la première ligne de celle-ci, devrais-je dire, pour notre prototype . Et maintenant, ce que nous allons faire c'est mettre le texte ci-dessous, l'imprimer ici, copier notre boucle foreach et la coller ci-dessous, comme ça. Et puis, entre les deux, nous allons réellement changer les valeurs de r, n'est-ce pas ? Ainsi, comme notre fonction a une référence comme type de retour, nous pouvons l'utiliser sur le côté gauche d' une expression ou d'une instruction d'affectation dans ce cas. Et vous verrez ce que je veux dire ici dans une seconde. Nous allons donc dire valeur fixe. Ensuite, entre parenthèses, nous allons mettre l'indice que nous voulons modifier. Alors allons-y et changeons ces deuxièmes ici. Nous allons donc dire un, car n'oubliez pas que les index des conteneurs commencent à 0. Nous allons donc modifier cette valeur ici même. Ensuite, nous pouvons simplement dire égaux. Allons-y et changeons-en un autre juste en dessous. Nous allons donc dire une valeur de l' indice quatre égale à cinq. Ou allons-y et changez-le en quelque chose comme 33. Alors allons-y et jetons un coup d'œil à l'ensemble de notre code ici. abord, nous avons créé un tableau en dehors de toute fonction afin qu'il soit disponible dans le monde entier dans ce cas, puis nous avons eu notre prototype de fonction. Et si nous passons à notre fonction ici, nous avons eu un type de retour de référence int et notre fonction s'appelait set value et prenait un entier. Ensuite, nous avons renvoyé une référence entière de l'index spécifié pour ce tableau spécifique. Donc, tout ce qui se trouve ici sur la gauche peut aussi bien avoir dit une référence int, appelez-la graph par exemple, égale à mon index de tableau un. Et cela aurait été exactement la même chose, et nous verrons cela dans une seconde. Donc, si nous exécutons notre code ici, nous allons en imprimer un à cinq, puis en imprimer un. Notre deuxième indice a été changé à 1034, puis notre dernier indice, ou notre élément à l'indice 4. cinquième élément, quelle que soit la façon dont vous voulez regarder, a été réglé sur 33. Alors vous l'avez. Et cela aurait fait exactement la même chose si nous avions pris cela ici et que nous l'avions effacé. Et puis en bas, cela équivaut à dix parce que nous devons en fait changer la valeur ici, puis exécuter notre code. Est-ce que vous regarderiez ça, exactement le même résultat ? Alors, tu y vas. Laisse-moi y aller et annuler ça très rapidement. Donc, comme vous pouvez le voir, dire que c'était essentiellement la même chose que de dire cela, plus de dire que le souffle est égal à dix. La seule différence ici est que nous pouvons créer une référence à l'index notre choix en renvoyant simplement une référence et en insérant l'index que nous voulons. Et puis, comme nous avions une référence comme type de retour, vous pouvez utiliser notre fonction ici sur le côté gauche de l'expression. Alors nous avons dit : « Hé, changez mon tableau essentiellement à l'index 12, ce que vous auriez également pu considérer comme disant que mon index de tableau un est égal à dix, ce qui dans ce cas au moins aurait été un beaucoup plus simple. Mais je voulais juste vous montrer comment fonctionne l'utilisation de références comme types de retour. En gros, cela vous permet simplement de renvoyer une référence égale à ce que vous avez indiqué dans le retour ici. Donc, notre référence entière était égale à mon tableau, peu importe. Alors, tu y vas. Il s'agit de références d'utilisation comme types de retour. Vous placerez l'esperluette après le type de données du type de retour, fois dans votre déclaration et dans votre prototype, puis vous renverrez ce que vous souhaitez qu'il soit une référence. Alors vous l'avez. Alors terminez cette vidéo. Laissez-moi vous montrer comment je viens de créer une référence à un entier dans notre méthode ici. Donc, si nous supprimons tout cela ici, nous appellerons notre méthode rent. Et nous ferons de même ici. Ensuite, nous irons de l'avant et supprimerons l'argument des deux. Nous avons donc quelque chose qui ressemble à ceci maintenant, puis nous allons renvoyer x. Et pour définir ensuite, nous allons créer une variable globale X. Nous avons donc maintenant une variable appelée x, qui n'a aucune valeur. Mais si nous le voulions, nous pourrions le mettre à 0. Et ici, et notre fonction principale, disons en encerclant le nom de notre fonction, puis en ouvrant et en fermant des parenthèses, puisque nous n' avons aucun argument à transmettre et en le mettant à dix. Et puis en bas, nous dirons x. Alors, qu'est-ce que cela va faire ? Nous avons d'abord créé une variable globale appelée x, puis à l'intérieur de notre fonction principale, nous avons appelé notre fonction créée par l'utilisateur appelée rente by wrath. Et ce que cela va faire, c'est renvoyer une référence entière à x. Maintenant, gardez à l'esprit que cela n'a pas de nom, donc nous ne pourrons pas vraiment l' utiliser plus tard, mais cela fonctionnera toujours pour ce cas d'utilisation . Nous avons donc dit de retourner par référence, ce qui nous donne une référence entière à X. Donc maintenant, cela pourrait tout aussi bien être x. Donc, cela revient à dire que x est égal à dix, gros parce que nous avons créé un global variable appelée x. Et puis, lorsque nous appelons notre méthode ici, elle a renvoyé une référence entière à x. Donc, cela peut aussi bien être x, et nous l'avons défini comme égal à dix. Maintenant, quand nous l'avons imprimé, x, x était dix. Et si nous exécutons notre code, vous pouvez voir que c'est le cas. Alors, tu y vas. J'espère que vous comprenez maintenant comment utiliser les références en tant que types renvoyés. Cela vous permet essentiellement de renvoyer directement une référence. Et le principal argument en est que vous pouvez utiliser votre méthode ici, sur le côté gauche d' un énoncé de devoir. Vous avez donc vu comment faire cela à la fois avec une variable et avec un conteneur tel qu'un tableau. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 74. Chapitre 13 (Références) : adresses de mémoire: Dans cette vidéo, je vais vous donner un aperçu de ce que font réellement les références en arrière-plan, comme une sorte d' introduction au prochain sujet de ce cours, à savoir les pointeurs. Et vous verrez pourquoi j'ai fait cette vidéo une fois que nous y serons parvenus. Mais pour l'instant, allons-y et concentrons-nous simplement sur la répartition de ce qui se passe réellement avec les références. Pour ce faire, nous allons créer une variable entière appelée x et lui attribuer la valeur cinq, par exemple. Ensuite, je vais ajouter quelques commentaires ici. Ce n'est donc qu'une variable int. Et ensuite, en dessous, nous allons imprimer l'adresse mémoire de notre variable entière. Et nous pouvons le faire avec ce symbole d'esperluette suivi du nom, notre variable, puis nous imprimerons une nouvelle ligne. Donc, ceci va afficher l'adresse mémoire de x. Et si nous exécutons notre code ici, vous pouvez voir que c'est ce qui se passe. Ou du moins, croyez-moi, c'est l'adresse mémoire de x. Je sais que ça a l'air fou. Ne vous inquiétez pas, vous n' avez pas à décomposer tout cela ou quoi que ce soit d'autre et à découvrir ce que c'est. Sachez juste que c'est ainsi que nous pouvons obtenir l'adresse mémoire d' une variable, d'accord, maintenant, si nous créons une référence à x, donc si je dis esperluette, et que nous appellerons simplement ceci href est égal à x. Donc et puis imprimez l' esperluette ref pour obtenir l'adresse mémoire de rep. Ainsi, nous allons également créer une nouvelle vie pour celui-ci , puis exécuter notre code. Vous pouvez voir que ce sont exactement les mêmes. OK ? Donc, ici, nous avons créé une référence x, puis nous avons imprimé l'adresse mémoire. Notre prochaine référence. Comme vous l'avez vu lorsque nous étions dans un code, ce sont exactement les mêmes. Et c'est parce que, comme je l'ai déjà dit, une référence est essentiellement un autre nom désignant exactement la même chose. Rien n'est différent. Ils partagent exactement le même emplacement de mémoire et partagent la même valeur. L'indice respiratoire imprimé normalement n'en imprimerait que cinq. Et pour vraiment faire comprendre qu' ils sont la même chose. Je vais vous montrer une dernière chose en l'utilisant comme argument. Et je sais que nous en avons parlé un peu par le passé, mais je vais juste vous montrer une dernière chose à ce sujet. Donc, si vous dites x est égal à cinq, et qu'en dessous de ce crédit une référence à des experts en esperluette, ref est égal à x. Et ensuite, nous allons créer une méthode ici, et nous dirons void, change int num. Et dans notre bloc de code, nous dirons que num est égal à 22 et nous devons en faire un prototype. Je vais juste le mettre ici, comme ça. Et maintenant, si nous allons de l'avant et les méthodes de couleur ne changeront pas la colère. Nous allons donc transmettre notre référence réelle à x, c out, breath. Alors, que pensez-vous qu' il va se passer ? Eh bien, allons-y et voyons s'il va en imprimer cinq. Et c'est parce que, comme je l'ai dit, une référence et la chose à laquelle elle fait référence ou à laquelle ils font référence sont la même chose. Nous pouvons donc la transmettre comme nous avons coupé la variable d'origine et elle ne sera toujours pas modifiée. Maintenant, comment prendre une référence comme paramètre ici, comme nous l'avons fait par le passé, alors oui, elle passerait à 22. Et nous aurions même pu simplement passer un x ici et il passera tout de même à 22 parce que, comme je l'ai dit, c'est pareil. Vous pouvez les utiliser de la même couleur blanche. Alors, tu y vas. Je voulais vraiment faire comprendre qu' une référence et une référence sont exactement la même chose. Ils peuvent être utilisés exactement de la même manière, mais ce n'est qu'un surnom pour tout ce à quoi ils font référence. Ils partagent même exactement la même valeur que notre impression brute ou x. C'est la même chose et ils partagent même le même emplacement en mémoire. Et comme je l'ai dit, la raison de cette vidéo, part vous montrer comment obtenir l'adresse mémoire d'une variable. Et que vous pouviez simplement ajouter la référence ici sans la changer parce que vous avez conservé la variable, si elle avait pas été prise, cette référence était destinée à vous préparer à ce dont nous allons parler dans la prochaine série de vidéos étant des pointeurs. J'espère donc que cela aura du sens, comme toujours, merci de m'avoir regardé et à bientôt. 75. Chapitre 14 (Pointeurs) : Intro aux pointeurs: Dans cette vidéo, nous allons parler de pointeurs. Maintenant, un pointeur, comme une référence, est utilisé pour stocker l'adresse d' une variable plutôt que de simplement stocker la valeur de celle-ci elle-même, comme les références dans lesquelles les pointeurs stockent l'adresse d'une variable. Maintenant, quel est l' intérêt d'un pointeur ? Eh bien, d'une part, cela permet d' assimiler les appels par référence. Ils permettent également de créer et de manipuler des structures de données dynamiques ou une allocation dynamique de mémoire. Maintenant, nous n'allons pas vraiment nous lancer dans la création et la manipulation structures de données dynamiques ou gestion de l'allocation dynamique de mémoire. Ou il le ferait dans ce cours, simplement parce que c'est un sujet beaucoup plus approfondi, que je voudrais approfondir, dans ce cours en particulier. Cela étant dit, nous allons tout examiner les pointeurs, comment les utiliser, quand les utiliser, les différences entre cela et références et quand vous le souhaitez utilisez l'un plutôt que l'autre, car vous ne pourrez aller nulle part dans la programmation en C plus sans savoir ce que sont les pointeurs. Il est donc important de savoir ce qu'ils sont, comment les utiliser et quand les utiliser. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 76. 75: Dans cette vidéo, nous allons créer notre premier pointeur. La syntaxe d'un pointeur est donc la suivante. abord, vous allez avoir le type de données de la variable pointée vers. C'est similaire à la façon dont nous avons créé les références, où nous avons le type de données de ce que nous avions prévu de référencer. Vous aurez le type de données sur lequel vous comptez pointer, à quel point le symbole astérisque pour indiquer qu'il s'agit d'un pointeur similaire à la façon dont nous avons l'esperluette avec des références pour indiquer que nous entendons créer une référence. Ensuite, vous allez suivre cela avec le nom du pointeur, puis vous pouvez l' attribuer à quelque chose également. Cependant, il n'est pas nécessaire de lui donner une valeur initiale dès le départ, comme nous l'avons fait pour les références. Et nous y reviendrons un peu plus tard dans le cours. Et lorsque vous l'attribuez, vous allez lui attribuer l'adresse d'une variable. Maintenant, l'astérisque et C plus, comme nous l'avons vu maintenant, peuvent être utilisés pour de nombreuses choses différentes. abord, ils peuvent être utilisés pour déclarer que vous créez un pointeur. Il peut être utilisé pour déréférencer un pointeur et peut être utilisé pour la multiplication. Et vous verrez quelques exemples de déréférencement d'un pointeur ici dans un instant. Et puis il y a une chose que je voulais vous montrer avec ce texte ici, car que vous ayez l'esperluette lorsque vous créez une référence juste à côté du type de données ou juste à côté du nom Peu importe. Ces deux lignes de texte sont identiques et nous pouvons même créer une référence à une référence, et elles seront désormais toutes identiques. Donc x, ref et rough to here sont maintenant essentiellement exactement la même chose. Ce ne sont que des surnoms ou des pseudonymes les uns pour les autres. Et si je lance mon code ici, vous pouvez voir que cela fonctionne très bien. Donc, peu importe que vous ayez l'esperluette ici ou ici. Et vous pouvez avoir plusieurs références à la même chose, mais cela suffit pour le moment. Je voulais juste te le montrer très rapidement. Et il en va de même lorsque vous créez un pointeur, l'astérisque ici, ou que vous pourriez l'avoir ici. Cela ne fait aucune différence. Personnellement. J'aime l'avoir ici, surtout parce que lorsque vous travaillez avec des fonctions comme nous l'avons vu avec les références et que vous avez un type de retour qui ressemble à ceci. Vous n'y avez pas réellement le nom, et vous l'avez juste à côté du type de données. J'ai donc aimé cette cohérence également lors de la création de multiples de la même variable. Alors laissez-moi commencer et supprimer cela rapidement. Si j'ai dit x virgule y, alors je peux dire que x est égal à cinq et y est égal à cinq. Et lorsque vous avez quelque chose comme ça, où vous créez plusieurs variables sur la même ligne. Vous pouvez faire de même avec les références où vous dites int x reference et why reference. Certaines personnes aiment avoir le symbole à côté du nom pour des raisons de cohérence. Mais personnellement, je n'aime pas créer plusieurs variables sur la même ligne. Je pense que cela rend votre code moins lisible. C'est pourquoi je l'ai personnellement placé à côté du type de données. Mais si vous voyez les choses dans l' autre sens, ne vous inquiétez pas, c'est exactement la même chose, qu'il s'agisse d'un pointeur ou d'une référence, peu importe. Même chose. Passons enfin à l' essentiel de cette vidéo, qui est de créer un pointeur et de voir comment cela fonctionne. Donc, il va dire que int x est égal à dix, puis en bas, nous allons créer un pointeur. Nous allons donc dire int astérisque et ensuite nous dirons P, x. Certaines personnes aiment préfixer les noms des pointeurs par un pair. Donc, ici, je le vois comme ça, juste pour que tu saches que c'est un pointeur, mais tu peux le nommer comme tu veux. Ensuite, nous la définirons comme égale à l'adresse de x, comme suit, souvenez-vous de l'esperluette avant un nom de variable comme celui-ci, car c'est l'adresse de cette variable. Donc, dans ce cas, vous pouvez considérer l'esperluette comme l'adresse de l'opérateur. Nous avons donc créé un pointeur en indiquant le type de données vers lequel nous voulions pointer, coloré par l'astérisque, puis le nom du pointeur. Ensuite, nous avons dit qu'elle est égale à l' adresse de la variable. C'était donc notre déclaration et l'initialisation d'un pointeur vers. Désormais, vous n'avez pas à l'initialiser sur la même ligne que vous le déclarez, contrairement aux références. Donc, ici, je vais juste recommencer et recréer ça. Et nous aurions pu dire int astérisque x pour notre pointeur sur x, puis mettre un point-virgule à la fin comme ça pour simplement déclarer notre 23e. Ensuite, nous pouvons l'initialiser plus tard en disant que P x est égal à esperluette x comme ça. Et ça va très bien fonctionner. Donc, si je lance mon code, vous pouvez voir que nous ne recevons aucune erreur et que tout fonctionne. Quoi qu'il en soit, laissez-moi commencer et annuler cela maintenant. OK, allons-y et imprimons notre pointeur. Donc, si vous vous souvenez que dans la dernière vidéo, j'ai dit qu'un pointeur est essentiellement une variable qui contient une adresse par rapport à l'endroit où une référence contient la valeur. S'il s'agissait d'une référence, elle serait fondamentalement identique à X, mais un pointeur contient l' adresse de la variable. Donc, si nous l'imprimons comme, nous imprimerons l'adresse ici. Et vous pouvez le voir ici, et voici l'adresse de x. Et pour le prouver, allons-y et imprimons également l'adresse de x. Donc, après n lignes ici, nous imprimerons le adresse de x en utilisant l'adresse de l' opérateur, si vous le souhaitez. Et ensuite, ce qui est génial. Je suis comme ça. Et si nous exécutons notre code ici, vous pouvez voir qu' il y a notre adresse et qu'il y a exactement la même adresse. OK ? Donc, le pointeur contient naturellement l'adresse de ce vers quoi il pointe. C'est pourquoi nous venons d' imprimer le plan. Nous avons imprimé l'adresse. Maintenant, en bas, nous allons faire le contraire. Nous allons donc imprimer la valeur, l'adresse d'aide en bas . Notre pointeur pointe vers la valeur de x. Et nous allons simplement mettre ce code juste en dessous. Nous allons donc dire « C ». Ensuite, nous allons dire le symbole astérisque suivi d'un p de x, puis d'une nouvelle ligne, comme ça, je vais imprimer x et la lumière. Donc, si vous vous souvenez, comme je l'ai mentionné ici, un astérisque est également une déréférence, et il vous permet de déréférencer et d'adresser. Notre pointeur pointe donc vers l'adresse de x, c' est ce qu'il contient. Ensuite, en utilisant cet astérisque, nous pouvons le déréférencer. Ainsi, au lieu de simplement obtenir l'adresse de la variable, nous pouvons obtenir la valeur contenue à cette adresse. Ensuite, nous imprimons simplement la valeur de x et celles-ci seront exactement les mêmes. Comme vous pouvez le voir ici, nous avons commencé par afficher notre pointeur, qui ne contient qu'une adresse, et nous avons imprimé l'adresse de x. Et c'était pareil depuis nos points de pointeur à x. Ensuite, ici, nous utilisons le symbole astérisque pour déréférencer un pointeur et obtenir la valeur réelle détenue à cette adresse. Maintenant, nous n'allons pas trop approfondir les adresses, façon dont tout est stocké. Mais notez simplement qu' un pointeur contient l'adresse d'une variable et que vous pouvez obtenir l'adresse d' une variable avec ce symbole d'esperluette. est donc à cette adresse que notre valeur de x est stockée. Donc, dans ces cas-là, il est stocké à cette adresse. Et notre pointeur contient même adresse parce que c'est ce que nous lui avons demandé de faire. Il. Et en dessous, nous avons imprimé notre pointeur qui, comme je l'ai dit, pose cette adresse. Ici. Nous avons imprimé l'adresse de x, qui devrait être exactement la même chose. Ensuite, nous utilisons le symbole astérisque pour déréférencer un pointeur suivi du nom de notre pointeur, ce qui nous donne la valeur réelle détenue à cette adresse. Ensuite, nous l'imprimons en X, comme nous l'avons fait par le passé. Alors, qu'est-ce que cela signifie à propos de toutes les variables que nous avons créées ? Eh bien, cela signifie essentiellement que lorsque nous avons dit Hey, nous allons créer un entier appelé x et le mettre égal à dix, que nous créons un entier qui contient la valeur dix. Et cela est stocké à une adresse ou à un endroit en mémoire. Et nous pouvons accéder à cette valeur. Encore une fois, nous sommes à cet endroit en mémoire si vous voulez, en disant simplement x. Donc voilà. J'espère que ce n'était pas trop confus pour vous. Tout ce que je veux que vous en retiriez vraiment, c'est qu'un pointeur pointe vers l'adresse d'une variable. C'est pourquoi il tient. Donc, tout comme notre variable ici égale à cette valeur, un pointeur contient l'adresse de cette variable et indique également comment créer un pointeur. Mais nous allons nous entraîner davantage à ce sujet dans les prochaines vidéos. Maintenant, une dernière chose je tiens à mentionner est que vous n'avez pas à initialiser un pointeur lorsque vous le créez. Vous pouvez également modifier la direction vers laquelle pointe un pointeur. Par exemple, on peut dire que y est égal à 15. Et puis, en bas, après avoir imprimé tout cela, nous allons copier tout cela et le coller. Et je vais créer un espace ici afin que nous puissions voir les différences entre les deux. Ensuite, nous allons procéder à la suppression de la déclaration. Donc, cet astérisque int en bas, et nous allons simplement dire que Px va maintenant pointer vers l'adresse de y. Ensuite, nous allons réimprimer le x avec l'adresse de y. Et puis ici, nous allons déréférencer l'adresse de y, qui affichera simplement pourquoi essentiellement. Et nous l'imprimerons également. Et si nous exécutons un code, vous pouvez voir que cela fonctionne très bien. Il y a donc l'adresse de x et l'adresse de y. Ensuite, nous avons également imprimé la valeur avec la valeur de y en utilisant le pointeur et en utilisant directement notre variable. Alors voilà. Voilà comment utiliser un pointeur et savoir plus sur ce qu'est un pointeur. Merci de m'avoir écouté , et à bientôt. 77. Chapitre 14 (Pointeurs) : pointeurs NULL: Dans cette vidéo, nous allons parler de pointeurs et de null. Et si vous êtes membre, parce que nous l'avons vu dans le passé, null ne signifie rien ou 0. OK ? Alors, qu'est-ce que je veux dire par pointeurs ? Et tu sais quoi ? Jetons un coup d'œil. Alors allons-y et créons ici une variable entière appelée Exelon. Il suffit de le régler à dix. Ensuite, nous allons créer un pointeur. Nous allons donc dire astérisque p x, encore une fois, comme nous l'avons fait dans la dernière vidéo. Et nous allons mettre cela sur un pied d'égalité et savoir ce qui doit être en majuscules. Juste pour plus de clarté, je vais le mettre ici aussi. Donc, nul est identique à 0. Donc, que j'aie eu ceci ou cela, cela n'a pas d'importance. C'est la même chose. Alors allez-y et faites-le pour qu'il y ait la même chose que cela. Alors, qu'est-ce que cela signifie ? Et pourquoi voudriez-vous le faire ? Eh bien, chaque fois que vous créez un pointeur, vous ne voulez pas le faire et ensuite travailler avec ce pointeur sans l'initialiser à quelque chose. C'est incroyablement dangereux car vous pouvez finir par perdre de la mémoire ou faire planter votre programme et toute une liste d' autres mauvaises choses que vous ne voulez pas faire. Donc, lorsque vous n'allez pas l'initialiser immédiatement, je vous recommande toujours de le définir comme suit. Ou comme je l'ai dit, vous pourriez mettre 0 pour dire, Hé, je ne suis pas en train de l'initialiser en ce moment, mais je ne vais pas simplement laisser cela initialisé essentiellement. Donc, en gros, ce que cela veut dire, c'est qu' il y a un pointeur, mais il ne pointe vers rien en mémoire. Et nous n'avions pas vraiment besoin de cette variable entière appelée x. Je l'ai juste mise ici pour vous montrer le même exemple que celui que nous avions eu dans la dernière phrase. Et maintenant, ce que vous pouvez faire avant d'utiliser ce pointeur est de dire ce qui suit. Ici, en bas. Avant de faire quelque chose avec notre planète, nous pouvons vérifier si notre pointeur pointe vers quelque chose, car nous lui donnons la valeur nulle ici. En gros, il dit que cela ne pointe vers rien pour le moment. Mais comme nous l'avons fait, nous pouvons faire ce qui suit. On peut dire que Px n'est pas égal à nul. Ensuite, nous exécutons, pour exécuter notre code en n'ayant pas, ils disent explicitement que cela ne pointe vers rien. Nous pouvons vérifier qu'il pointe vers quelque chose avant d'en faire quelque chose. Très bien, et cela aidera à éviter des tonnes d'erreurs la suite, car vous allez travailler avec un pointeur et vous n'allez pas lui donner de valeur initiale, définissez-le toujours sur null, et puis vérifiez si elle est toujours égale à null plus tard, avant de travailler avec elle. Parce que, comme je l'ai dit, tu ne veux pas travailler. Si cela ressemble à ça avec votre pointeur et que c'est très dangereux. Donc, si vous ne voulez pas initialiser, définissez-le toujours sur null, en disant simplement explicitement que cela ne pointe vers aucun emplacement en mémoire. Et ensuite, vous pouvez simplement vérifier, hé, cela ne pointe vers rien et exécuter votre code ici. Pourquoi cela n'a-t-il pas fonctionné correctement si vous venez de le faire, avoir cette vérification ici ne fonctionnera pas si vous ne le dites pas. D'accord, donc c'est en gros ça que null fonctionne avec les pointeurs. Cela vous permet simplement de dire explicitement que votre pointeur ne pointe vers rien pour le moment et de vérifier s'il pointe vers chose avant de faire quelque chose avec lui. Et si tu le voulais, tu pourrais toujours faire quelque chose comme ça. Trois, disons le contraire, puis imprimez un pointeur, pointe vers n'importe quoi juste pour vous avertir lorsque votre code s'exécute qui détestait mon instruction if ne s'est jamais déclenchée. Parce que lorsque votre code devient beaucoup plus volumineux, vous pouvez avoir une instruction if comme celle-ci. Et il peut être difficile de se rendre compte que, hé, ce code n'a pas fonctionné si vous ne vous prévenez pas. Alors, tu y vas. C'est ainsi que la nature fonctionne avec les pointeurs et l'importance d'utiliser null avec les pointeurs. Et comme toujours, merci de m'avoir écouté, et à bientôt. 78. Chapitre 14 (Pointeurs) : pointeurs et fonctions: Dans cette vidéo, nous allons parler un peu pointeurs dotés de fonctions. Donc, comme nous pourrions le faire avec les références, avoir un type de retour, être une référence et un battement de périmètre que j'ai référencé. Nous pouvons faire de même avec des pointeurs. Et parce que nous en avons déjà parlé avec des références. Et comme les pointeurs, les références et de nombreuses méthodes fonctionnent de manière très similaire, je vais simplement mettre tout cela dans une vidéo plutôt que de l'avoir dans deux vidéos distinctes. Alors allons-y. Donc, en bas, sous principal, allons-y et créons une fonction qui a un pointeur pour un paramètre. Donc, ce que nous allons faire ici, disons Lloyd, changer la valeur comme ça. Ensuite, entre parenthèses, nous dirons int astérisque, et nous l' appellerons simplement x comme ça. Et puis entre crochets, nous dirons que l'astérisque x est égal à dix. Et puis là-haut, allons-y et créons une variable entière, disons que x est égal à cinq, comme ça. Et ensuite, ici, nous allons continuer et appeler nos méthodes dire changer la valeur, puis nous allons simplement insérer x comme ça. Et nous devons nous assurer de certifier un prototype ici. Donc, nous allons simplement le faire ici. Et avant notre appel de fonction, allons-y, imprimons x et créons une ligne comme celle-ci. Maintenant, remarquez que nous avons cette erreur, et c'est parce que int est incompatible avec le paramètre de type int pointer. Et si cela avait été une référence, comme celle-ci, j'aurais très bien fonctionné parce que, eh bien, nous enverrions X et ici, cela créerait une référence à notre variable étant x. Et nous pouvons la nommer comme vous le souhaitez. Et je vais juste continuer et renommer ce numéro ici, comme ça. OK, donc nous avons int num, nous l'avons imprimé, puis nous l'avons envoyé en tant qu'argument. Et si cela avait été une référence, cela aurait très bien fonctionné. Nous aurions créé une référence qui utilise des œufs et changé x et nous l'aurions en quelque sorte sortie. Ici, en bas. Je viens d'imprimer à nouveau. Et maintenant, quel changement à dix. Et nous devons également le modifier ici dans notre prototype pendant un moment et voir si nous l'avons utilisé, il fonctionnerait très bien. Toutefois, un pointeur ne stocke pas directement la valeur et stocke l'adresse. Donc, si nous rechangeons cela en pointeur maintenant, nous pouvons toujours faire la même chose, sauf que nous devons envoyer l' adresse de la variable. Nous allons donc mettre notre symbole d'esperluette ici. Et puis ici, nous ne pouvons pas simplement dire que x est égal à dix parce que nous ne voulons pas changer l' adresse du pointeur. Et vous pouvez voir que cela nous donne une erreur en fait, mais nous ne pouvons pas changer le. Donc, si nous allons de l'avant et que nous déréférençons cela, cela fonctionnera très bien. Maintenant, nous avons créé un entier appelé num, qui n' est pas égal à cinq. Ensuite, nous l'imprimons num, qui n' en imprimera que cinq, évidemment. Ensuite, nous avons envoyé l'adresse de num dans notre paramètre ici. Nous avons donc maintenant un pointeur qui pointe vers l' adresse de num, puis nous avons déréférencé un pointeur. Donc, nous disons que la valeur se trouve à l'adresse de num, nous voulons la changer à dix. Et donc cela changera également num à dix. Et si nous exécutons notre code ici, vous pouvez voir que c' est ce qui se passe. Maintenant. Et si nous avions d'abord créé un pointeur ? Donc, si nous devions définir un astérisque, nous appellerons simplement ce point comme suit, et le définirons comme étant l'adresse de num, puis nous l'enverrons. Et maintenant, si nous exécutons un code, c'est exactement la même chose. La seule différence, c'est que nous venons d'envoyer notre pointeur. Ensuite, nous avions essentiellement un pointeur qui pointait exactement la même adresse et nous avons obtenu la valeur qui y était contenue, puis nous l'avons changée en dix. Cela a donc fonctionné aussi. Enfin, allons-y et utilisons un pointeur comme type de retour. Allons-y, désinitialisons notre pointeur ici et définissons-le comme nul. N'oubliez pas que si vous n' allez pas l'initialiser à l'origine, vous devez le définir comme nul. Nous allons donc le faire. Ensuite, ici, nous allons envoyer l' adresse de Num. Donc on va dire non, engourdi, comme ça. Et nous allons le changer de vide à un type de pointeur comme celui-ci. Et nous devons faire de même ici. Ensuite, ici, ce que nous allons faire, c'est retourner X, donc maintenant nous avons un revenu égal à cinq. Ensuite, nous l'avons imprimé. Ensuite, nous avons créé un pointeur appelé point qui ne pointe actuellement vers rien. Et nous avons explicitement dit qu' en le définissant comme égal à non, nous avons exécuté notre méthode, ici appelée leur méthode, qui a pris l'adresse de num, mise dans un pointeur que nous avons appelé x, puis nous renvoyons cela pointeur, qui, si vous vous souvenez d'un point , contient simplement une adresse, et nous renvoyons l'adresse et un pointeur entier, qui sera renvoyé ici. Donc maintenant, nous avons un pointeur int qui contient l'adresse de num parce que c'est ce que nous avons envoyé. Mais nous voulons aller de l'avant et l'entreposer quelque part. N'oubliez pas que chaque fois que vous retournez quelque chose, vous devez le ranger dans quelque chose. Sinon, ça l'est. Donc, ici, ce que nous allons dire, c'est que 0 est égal à cela, et cela fonctionnera très bien. Maintenant, ce que nous pouvons faire après une méthode appelée, c'est dire que nous voulons déréférencer. N'oubliez pas que nous allons mettre un astérisque et lui attribuer la valeur dix, un peu comme nous le faisions auparavant. Donc maintenant, nous disons que nous voulons prendre l'adresse de num, en gros la déréférencer. Ils obtiennent la valeur réelle qu'aucune, qui est actuellement de cinq, et la mettent égale à cela, puis nous allons en imprimer dix ici. Et allons-y et jetons un coup d'œil à cela rapidement. Alors, tu y vas. Le top 510 et comment le souhaitons-nous ? Nous aurions pu simplement mettre cet appel de méthode ici, débarrasser ici. Et cela se serait très bien passé, car cela nous renvoie une adresse et nous devons la définir comme car cela nous renvoie une adresse une adresse. Cela fonctionne très bien et très bien. Alors, tu y vas. Il fonctionne essentiellement de la même manière que le type de référence qui, sauf qu'avec quelques mises en garde, sunset contient une adresse au lieu de la valeur, comme notre type de référence qui s'y trouve. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 79. Chapitre 14 (Pointeurs) : pointeurs et tableaux: Dans cette vidéo, nous allons parler de pointeurs et de tableaux, passer en revue certaines des similitudes et interactions intéressantes entre eux. Alors allons-y. abord, nous allons créer un tableau d'entiers. Donc, nous allons dire int, mon tableau, puis je vais ouvrir et les crochets fermés ont été placés dans un nombre comme trois ici. Et je veux que cela soit égal à trois nombres différents. Allons-y et disons 1025. Et ensuite, en bas, nous allons créer un pointeur. Nous allons donc dire int astérisque, et je vais dire PTR, abréviation de pointeur. Ensuite, nous allons juste dire qu'il est égal à mon tableau, juste comme ça. Ensuite, je pense que je veux vous montrer que cette valeur ici doit simplement être un continent et que vous n' avez pas à mettre un chiffre ici directement. Donc, si nous disons des heures et que nous appelons ensuite cette taille de tableau , par exemple, définissez-la sur trois. Nous pouvons réellement mettre la taille du tableau ici dans notre taille de tableau, si vous le souhaitez. Et puis ici, ce que nous allons faire, c'est créer une base pour que les boucles soient nécessaires pour que I soit égal à 0, I inférieur à la taille du tableau I plus plus plus. Et ensuite, à l'intérieur de notre boucle, nous allons imprimer quelques éléments différents. Nous allons imprimer les adresses de ces variables ici, ainsi que les valeurs à l' aide de notre pointeur. Alors allons-y et examinons quelques moyens de le faire. La première serait la suivante. Nous pouvons dire quelque chose comme C. Et puis entre guillemets ici, nous pouvons dire adresse mon tableau sur le panneau entre crochets ouverts. Ensuite, nous pouvons dessiner N. Ensuite, nous allons créer un autre ensemble de guillemets suivi d' un crochet fermé pour dire égal à plus comme ça. Ensuite, ci-dessous, vous allez lire CL, PTR étant le nom de notre alibi en tête. Alors maintenant, allons-y et copiez-collez ceci ci-dessous également. L'armée change celui-ci pour qu'il prenne cette valeur et laisse le reste sauf ici. Je dis C out pointeur. Nous allons déréférencer un pointeur ici, et cela affichera la valeur. Mais maintenant, comment allons-nous réellement itérer et imprimer une valeur après l'autre ? Eh bien, ce qui est intéressant, c'est que cette ligne indique essentiellement que nous sommes allés à une adresse de signe de mon tableau à l'index 0 de GTR. Donc, en gros, c'est un peu comme dire que le pointeur est égal à mon index de tableau 0 avec une esperluette ici. Et ceci, et cela sont essentiellement équivalents. La raison pour laquelle cela attribue l'adresse de notre tableau à l'index 0, un pointeur est que le nom de notre tableau contient en fait l'adresse du premier élément du tableau. Et cela agit comme un pointeur constant, qui signifie que l'adresse stockée dans nom de notre tableau ne peut pas être modifiée. Et il est intéressant de noter que les pointeurs ont en fait certains opérateurs que nous pouvons utiliser dans ce cas. Et je vais vous en montrer un ici. On peut dire pointeur plus, plus. Et au fur et à mesure que cela se déplace dans les adresses, si vous le souhaitez, il progressera en fonction de ces éléments. Et si vous vous souvenez que lorsque nous avons parlé de tableaux pour la première fois, je vous ai dit que ces valeurs étaient stockées dans un ordre séquentiel. Donc, en gros, nous pouvons simplement déplacer notre pointeur vers le haut dans ordre séquentiel pour remonter le long de ces valeurs. Puisque notre pointeur commence à l'index 0 ici et qu'à chaque exécution de notre code, vous pouvez voir que nous avons dit l' adresse de mon tableau à l'index 0, qui n'était indiqué que par cette valeur I que nous augmentions égaux pointeur. Voici donc notre adresse. Et puis nous avons défini une valeur de mon tableau à l'index 0 est égal à dix. Et c'est parce que nous avons déréférencé cette adresse ici. Ensuite, nous avons augmenté notre pointeur d'une unité ici. Et cela l'a déplacé d' un élément vers le haut du tableau, essentiellement. Et nous sommes en mesure d' imprimer l'adresse et la valeur suivantes à chaque étape. Maintenant, allons-y et voyons une autre solution parce que je l'ai fait. Alors allons-y et supprimons ce pointeur plus, plus. Et puis, juste après le pointeur de mots, C Plus Plus nous permet d'utiliser la même syntaxe que pour un tableau lorsque notre pointeur est égal à un tableau comme celui-ci. Nous pouvons donc simplement avoir des crochets ouverts et fermés mettre directement dedans et faire de même ici. Et cela nous donnera essentiellement le même effet. Mais au lieu de l' astérisque ici, nous allons mettre le symbole de l' esperluette comme ça et exécuter notre code. Et comme vous pouvez le voir, cela fonctionne en fait comme une variable maintenant, donc c'est le contraire. Donc, si nous voulons régler ce problème, vous pouvez simplement déplacer notre esperluette ici. Et maintenant, comme s'il s' agissait d'un tableau, nous allons mettre le symbole d'esperluette ici pour obtenir l'adresse de la variable. Et nous l'utiliserions normalement pour obtenir la variable elle-même. Donc, si nous exécutons un code, vous pouvez voir qu'il fonctionne exactement comme avant. Allons-y et examinons une autre solution. Nous pourrions travailler avec nous, et ce n'est pas la dernière façon de travailler avec des pointeurs et des tableaux. C'est juste le dernier que nous allons présenter ici et sur la plupart des courts. Donc, en sélectionnant de créer un pointeur ici et en le mettant comme égal à mon tableau, nous allons en faire un un ensemble de pointeurs. Je mets des crochets comme ça. Ensuite, nous allons simplement redimensionner comme ça. Ensuite, ici, ce que nous allons faire, c'est laisser ça tel quel. Nous allons commencer et couper ce code car nous l'utiliserons peut-être plus tard dans un instant. Et puis à l'intérieur d'ici, nous allons dire pointeur et esperluette mon index de tableau I. Donc maintenant, notre tableau de pointeurs qui n'est pas initialisé actuellement va se voir attribuer les adresses de ces variables. OK ? Et puis ici, allons-y et créons une, une autre pour la boucle. Mais il ressemble à celui ci-dessus. Il est égal à 0. C'est moins que la taille I plus, plus. Et l'avantage de dire la taille du tableau ici et l'utiliser pour la taille réelle du tableau, c'est que c'est très lisible et qu'il est très clair quand nous arrêtons notre boucle et combien de fois nous exécutons à travers elle, une fois par élément de notre tableau. Ensuite, ici, nous allons coller ce que nous avions avant, sauf que nous allons supprimer cette esperluette, remettre notre astérisque en bas et exécuter notre code. Et maintenant, il fonctionne de la même manière qu'avant. Nous avons donc créé un entier constant appelé taille du tableau et l' avons défini à trois. Ensuite, nous avons créé un tableau d'entiers et l'avons défini comme étant égal à la taille du tableau et lui avons donné trois valeurs. Ensuite, nous avons créé un tableau de pointeurs de nombres entiers et nous ne l'avons pas initialisé. Ensuite, nous avons créé une boucle de base à quatre qui devait s'exécuter une fois par élément de notre tableau. Et nous définissons ici chacune des adresses de ces pointeurs égale à l'adresse des valeurs de notre tableau. Ensuite, nous avons créé une autre boucle for qui s'est exécutée le même nombre de fois que celle d'ici, et nous avons simplement imprimé notre adresse comme d'habitude, comme si nous imprimions la valeur d'un tableau, puis la référence à cela une fois de plus, et juste pour récupérer, ou nous résumons également nos exemples précédents. Laisse-moi y aller et revenir ici. Nous avons donc simplement créé un tableau, puis créé un pointeur et défini l'adresse qu'il contient égale à cette adresse ici. C'est essentiellement parce que le nom de notre tableau contient en fait l'adresse du premier élément. Et c'était la même chose que si nous le disions ici. OK, donc si j' exécutais mon code comme ça, ça marchera très bien. Maintenant, C plus plus nous permettra d'utiliser réellement la même syntaxe. Nous imprimerions les éléments de notre tableau avec notre pointeur ici. OK ? Et puis, si nous revenons à notre exemple original où nous avions ceci ici, encore une fois, même chose avec un code pour la poubelle ici. Et tout fonctionnera de la même manière, sauf que cette fois, au lieu d'utiliser la syntaxe du tableau, nous augmentons simplement la position de notre pointeur et il remonte d'un élément à la fois. Maintenant, nous aurions pu faire quelque chose pour le faire à l'envers comme suit. Nous pouvons attribuer le pointeur plus égal pour le déplacer d'ici à ici, car il a été déplacé de deux places vers le haut. Donc, au lieu d'être à dix et pointe maintenant vers le 50, qui est mon tableau à l'index deux. Ensuite, nous aurions pu dire pointeur moins, moins ici et commencer notre index à trois, puis dire : Eh bien, I est supérieur à 0 moins moins moins, et exécuter notre code. Et maintenant, tout se serait passé dans l'ordre inverse. Et en fait, nos inducteurs ne sont éteints que d'une seule. Nous pouvons donc résoudre ce problème en changeant i2 pour commencer et en disant : Eh bien, je suis supérieur à un négatif. Et encore Marina, et c'est parti. Donc, l'adresse de mon tableau à l'index deux, parce que c'est là que nous avons commencé maintenant, est la suivante, et la valeur est 50, puis nous obtenons l'adresse de l'index un et ainsi de suite. Alors, tu y vas. Il existe certaines interactions intéressantes entre les pointeurs et les tableaux. Si vous êtes curieux de connaître notre nom de tableau contenant l'adresse du premier élément et pas seulement la valeur. Si vous vous souvenez de la vidéo où nous avons envoyé un tableau en tant qu' argument dans un périmètre qui a pris et il a été dépassé par référence. Et c'est parce qu'il contient l'adresse, pas la valeur. Quoi qu'il en soit, c'est tout pour cette vidéo, je sais qu'elle contenait beaucoup d'informations. Donc, si vous ne l'avez pas complètement compris, hésitez pas à le revoir ou à rechercher plus d'informations sur le sujet. Sinon, ne vous inquiétez pas, nous n'aurons pas vraiment affaire à nous pendant le reste du cours. Quoi qu'il en soit, c'est tout pour la vidéo. Merci de m'avoir regardée, et je te verrai dans la prochaine. 80. Chapitre 14 (Pointeurs) : pointeurs vs références: Dans cette vidéo, nous allons parler de certaines des différences entre les pointeurs et les références afin que vous sachiez quand utiliser, lequel. Alors allons-y. abord, les références sont utilisées comme alias pour les variables existantes, tandis que les pointeurs sont utilisés pour stocker les adresses des variables. De plus, les références ne peuvent pas avoir de valeur nulle, mais les pointeurs peuvent le faire, et les pointeurs peuvent être modifiés ultérieurement. De plus, sur une note plus petite, comme les pointeurs contiennent des adresses, ils doivent être référencés par le symbole astérisque. Alors que les références peuvent être considérées comme une constante automatiquement. Par défaut. C'est juste une façon de considérer une référence comme un pointeur qui ne peut pas être modifié. s' agit par défaut de la référence. Et puis tu l'as. quelques différences fondamentales entre les deux. Et il y a encore beaucoup de choses que vous pouvez faire avec des pointeurs que nous n'avons même pas abordés. Par exemple, vous pouvez avoir des pointeurs vers des pointeurs. Il existe plusieurs autres conteneurs que nous n'avons pas abordés dans ce cours et que vous devez utiliser des pointeurs pour travailler vous devez utiliser des pointeurs pour travailler . Vous pouvez également utiliser des pointeurs pour effectuer des opérations avec allocation dynamique de mémoire également. fait, les pointeurs sont beaucoup plus polyvalents et vous permettent d'avoir code beaucoup plus complexe pour effectuer différentes choses par rapport aux références. Donc, au lieu de vous donner tous les cas d'utilisation pour chacun, je vais simplement vous indiquer quand vous devez généralement utiliser une référence, puis, en guise de note générale, vous utiliserez des pointeurs pour tout le reste. Alors, quand devriez-vous utiliser des références ? Eh bien, d'une manière générale, vous devez utiliser des références lorsque vous travaillez avec des paramètres de fonction et des types de retour, comme nous l'avons vu précédemment. Bien entendu, cela peut varier en fonction du type de données avec lequel vous travaillez, mais il ne s'agit que d'une remarque générale. Maintenant, un autre bon moment pour les utiliser est lorsque vous souhaitez travailler avec les éléments d'origine dans une boucle pour chaque boucle. Et cela peut changer en fonction type de données et du conteneur avec lesquels vous travailliez. Ce ne sont donc que quelques règles générales. Comme je l'ai dit, cela peut certainement changer en fonction de votre situation. Ensuite, vous n'utiliseriez des pointeurs que pour d'autres choses. Et nous n'avons touché que la surface des pointeurs et vous pouvez faire beaucoup plus avec eux. Donc, si vous êtes intéressé par tout cela, allez-y et faites vos recherches à ce sujet. Quoi qu'il en soit, c'est tout pour cette vidéo. Je voulais juste aborder certaines des différences entre les pointeurs et les références, vous donner une idée générale du moment où utiliser les références. Ainsi, par proxy, vous saurez quand utiliser des pointeurs à la place, et que vous toucherez un. Une autre façon de regarder les références par rapport aux pointeurs est la suivante. tout cas, j'espère que vous avez apprécié la vidéo. Merci de m'avoir écouté , et à bientôt. 81. Chapitre 15 (cours) : Intro à OOP: Dans cette vidéo, nous allons parler de ce qu' est exactement la programmation orientée objet, également appelée o p. Maintenant, programmation orientée objet consiste créer des objets contenant les deux des données et des fonctions qui représentent des objets du monde réel. Ce type de programmation présente plusieurs avantages par rapport à la programmation procédurale, qui consiste principalement à écrire fonctions qui effectuent des opérations sur les données plutôt que de créer des objets ou des classes. Et nous n'allons pas trop nous plonger dans les détails de la programmation procédurale ou fonctionnelle. Mais très rapidement, allons-y et parlons de certains des avantages de la programmation orientée objet. Eh bien, tout d'abord, la programmation orientée objet est plus rapide et plus facile à exécuter. Il fournit une structure claire à vos programmes et vous évite d'avoir à vous répéter, ce qui facilite la maintenance, la modification et le débogage du code. Et le dernier avantage que nous allons mentionner ici est une programmation orientée objet vous permet de créer des applications réutilisables, créées avec moins de code et développées. Pasteur, jusqu'à présent, vous m'avez probablement entendu parler d'objets et de classes de la même manière. Et souvent, vous entendrez les gens utiliser le mot objet et classes de manière interchangeable, mais sur le plan technique, sont des choses différentes. Rappelez-vous donc comment j'ai dit que les effondrements représentent des objets du monde réel à l'aide de fonctions et de données. Eh bien, allons-y et parlons des différences entre les classes et objets, de ce que serait une classe par rapport à un objet du monde réel à titre d'exemple, et de ce que seraient les objets de cette classe. Et tu verras ce que je veux dire ici dans une seconde. Donc, par exemple, allons-y et utilisons des fruits, des fruits sucrés avec notre exemple d'énumération dans une vidéo précédente. Nous pouvons donc créer une classe appelée Pro. Et ce n'est pas la syntaxe d'une classe. C'est exactement comme ça que j' écris ceci ici. Cela comporterait différents ensembles de données et de fonctions. Ainsi, par exemple, vous pouvez avoir des données pour représenter la douceur, la taille et peut-être la couleur des graines. Il peut avoir des fonctions pour la croissance ou la durée de vie du fruit, à titre d'exemple ici. Ensuite, nous aurions des objets qui sont des classes de fruits ou des instances de celle-ci qui héritent ces variables et fonctions mais ont leur propre instance. Ainsi, quelques exemples d' objets de notre classe de fruits que nous pouvons avoir sont des choses comme une pomme ou une banane, une orange, des raisins, etc. Donc, essentiellement, notre classe de fruits serait le modèle de tout ce qui en hérite. Ou si a en est une instance. Ainsi, par exemple, Apple aurait un niveau de douceur de taille, un nombre de sièges et une durée de vie. Ainsi, ce que notre banane , notre orange, nos raisins, etc. Cela définit en quelque sorte ce qu' est un fruit et sont des objets de notre classe, sont des exemples du schéma directeur défini dans notre classe. Une autre chose à mentionner ici, alors que nous avons écrit cet exemple comme une pomme serait un fruit, et une banane serait un fruit, et cetera. Mais une pomme n'est pas forcément une banane. La banane n'est pas nécessairement une orange, car chacune d'elles serait différente à part entière, mais serait toutes un fruit dans ce cas. De toute façon, j'espère que tout cela a du sens. Je sais que c'était une sorte d' information à prendre en compte en une seule fois. Mais sinon, nous allons créer travailler avec des classes et les décomposer pièce par pièce, comme nous l'avons fait pour les fonctions. Alors ne vous inquiétez pas, restez à l'écoute. Merci de m'avoir regardée. Et je te verrai dans la prochaine. 82. Chapitre 15 (cours) : créer une classe: Dans cette vidéo, nous allons créer notre tout premier cours. Donc, si vous vous en souvenez, une classe est un type de données défini par l'utilisateur qui contient à la fois des données et des fonctions, appelées membres. Et ces membres constituent un plan pour les objets ou les instances de notre classe. Ainsi, dans la vidéo précédente, nous avons parlé de fruits, puis de noms de fruits différents pour les objets. Mais un autre exemple serait si nous avions une classe appelée voitures contenant les variables telles que la marque, le modèle et l'année. Et puis nous pourrions avoir des fonctions pour avancer, reculer, passer au point mort, etc. Et puis les objets de notre classe sont les exemples de véhicules différents. Ils auraient chacun leur propre modèle et leur année, et auraient également leurs propres instances des fonctions de voyage. J'espère donc que cela a du sens. Sinon, nous allons créer un exemple de classe ici dans un instant. Mais avant cela, j'ai quelques énumérations ici, un autre type défini par l'utilisateur avec lequel nous avons travaillé. Et la raison pour laquelle je les ai ici pour vous montrer les similitudes avec la syntaxe de création , c' est de travailler avec une classe, que nous aborderons ici dans un instant. Et juste pour vous montrer quelques choses supplémentaires avec les énumérations, maintenant que vous avez un peu plus de connaissances en programmation. Donc, si vous vous souvenez, nous avons juste dit « assez de gars » au nom de notre énumération. Et puis, entre crochets, nous avions en fait les différentes valeurs d'énumération. Et puis, dans le passé, nous avons simplement créé différentes variables de notre type d'énumération en disant notre type de données, qui était notre énumération, suivi du nom de la variable, puis en lui attribuant la valeur de l'un des nos valeurs possibles là-bas. Mais quelques choses que je ne vous ai pas montrées les suivantes : au lieu de créer une variable séparée sont les suivantes : au lieu de créer une variable séparée sur une nouvelle ligne ici, comme celle-ci, nous aurions pu simplement la mettre après les crochets frisés, mais avant le point-virgule. Vous pouvez donc créer autant de variables que vous le souhaitez comme ceci, il suffit de les séparer par des virgules. Ainsi, dans cet exemple, j'ai créé une variable supplémentaire appelée flavor one, puis une autre appelée flavor aussi. Et j'initialise la saveur 1 ici. Et j'ai simplement la déclaration de saveur ici. Et celui-ci ci-dessus, j'ai fait quelque chose de très similaire, sauf que j'ai oublié le nom de celui-ci, ce qui signifie que je ne peux pas créer de variable plus tard comme celle-ci, car je n'ai aucun moyen de la référencer et notre code fonctionnera très bien comme ça. Donc, pour créer des variables de celle-ci, j'ai dû la mettre ensuite comme je l'ai fait ici. Vous pouvez également les initialiser ici, comme ça. Et j'aurais pu faire pareil ici. Sinon, je peux aussi l'initialiser ici comme je l'ai fait avec celui-ci. Bref, je voulais juste te montrer ça rapidement. En gros, la seule différence est que vous pouvez supprimer complètement le nom de votre ENM, mais gardez à l'esprit que vous ne pourrez pas le référencer. Et que vous pouvez faire déclarer et initialiser les variables sur la même ligne en les plaçant simplement après les crochets et avant le point-virgule. Quoi qu'il en soit, allons-y et supprimons cela. Ensuite, nous allons créer une classe ou simplement créer une classe de manière très similaire. La syntaxe d'une classe est donc la suivante. abord, vous allez dire classe, suivi du nom de la classe. Et puis, entre crochets, vous aurez votre code réel, ou devrais-je dire, les membres de cette classe. Ensuite, après les crochets, vous pouvez séparer vos objets, si vous le souhaitez, si vous le souhaitez, par des virgules. Enfin, vous allez le fermer avec un point-virgule. Ensuite, ici, allons-y et créons une classe de base. Et ce que nous allons faire, c'est créer une classe pour les animaux. Nous allons donc parler d'animaux de classe comme cela dans la convention de dénomination normale de notre classe, CamelCase, commençant par une majuscule, crochets ouverts et fermés. Ainsi, à l'intérieur, nous aurons nos membres. Vous pouvez donc avoir une variable entière appelée âge. Ensuite, en dessous, nous aurons une variable appelée hauteur, et nous en resterons là pour l'instant. Alors voilà. Nous avons maintenant créé une classe très basique appelée animaux. Il contient deux membres de données différents. Ainsi, vos variables qui se trouvent dans une classe et vos fonctions au sein de la classe sont appelées membres de votre classe. Et certaines personnes aiment préfixer tous leurs membres avec un trait de soulignement comme celui-ci. Donc, sachez que ce sont des membres de la classe et pas seulement des variables régulières. Alors allons-y et faisons-le réellement. Et puis, comme je l'ai dit, il déclare également différents objets ici, après un crochet et avant notre point-virgule si nous le voulons. Nous pourrions donc avoir un objet pour chien et un objet pour chat, par exemple. Et si nous exécutons un code ici, et vous pouvez voir que cela fonctionne très bien. Bien évidemment, je n'ai rien fait, mais je voulais juste vous montrer que nous n'avons commis aucune erreur. Et pour l'instant, cette classe n' existe que dans notre fonction principale. Et après ce point , nous pouvons en fait supprimer cela comme cela et le mettre en dehors de notre méthode, de sorte que maintenant sa portée soit globale plutôt que locale ici. Quoi qu'il en soit, c'est tout pour cette vidéo. Mais avant de passer à la suivante, je veux que vous commenciez à enregistrer votre code. Parce que dans la prochaine série de vidéos, nous allons ajouter des éléments à notre classe pour le rendre de plus en plus complexe et examiner différents exemples de choses que nous pouvons faire avec. Donc, comme je l'ai dit, assurez-vous de sauvegarder votre code afin que nous puissions l' utiliser dans la prochaine vidéo. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 83. Chapitre 15 (cours) : objets de cours: Dans cette vidéo, nous allons créer des instances ou des objets de notre classe. Et avant cela, nous allons commencer et simplement supprimer ces deux déclarations d' objets, afin de voir comment procéder à partir de zéro. Alors allons-y et retirons ces objets pour chiens et chats. Et nous allons réellement créer deux objets ou instances différents de notre verre ici. N'oubliez donc pas que les objets sont des instances d'une classe ou d'une syntaxe d'objet. Nous allons dire le nom de notre classe, suivi du nom de l' objet, du nom de l'animal de compagnie. Enfin, un point-virgule. Alors allons-y et créons deux instances de notre classe. Et c'est tout ce que je vais faire dans cette vidéo. Nous allons dire, est-ce que les animaux sont le nom de notre classe. Et puis on dira chien par exemple. Et poursuivez avec un point-virgule. Ensuite, nous allons également créer une autre instance ou un autre objet, si vous le souhaitez, de notre classe appelée animaux chats. Et nous allons mettre un point-virgule à la fin. Et puis allons-y et faisons encore une chose avant de terminer cette vidéo. Alors là-haut, au lieu de lui dire bonjour, allons-y et donnons un nom à chaque animal. Donc, je vais dire nom de chaîne. Ensuite, juste pour vous montrer quelque chose rapidement, nous essayons de créer une instance de chacune de ces variables pour nos objets ici. Et nous pouvons le faire en procédant comme suit, en prononçant le nom de notre objet, chien, dans ce cas, suivi du nom de la variable à laquelle nous voulons accéder. Donc, vous dites le nom du point du chien et essayez de le définir comme une chaîne ici, vous remarquerez que nous obtiendrons une erreur et c'est parce que le nom de l'animal est accessible. Et nous expliquerons pourquoi dans la prochaine vidéo. Alors allez-y et dites que vous êtes reconnaissants de m'avoir regardée, et je vous verrai dans la prochaine. 84. 83: Dans cette vidéo, nous allons parler de ce que l' on appelle les spécificateurs d'accès ou qui proviennent d'une autre langue. Vous avez peut-être également entendu ce que l'on appelle des modificateurs d'accès. Maintenant, il existe trois types différents, quatre nombres. Tout d'abord, vous avez le public et les membres du public sont accessibles depuis l'extérieur de la classe. Ensuite, vous avez des membres privés et les membres privés ne peuvent pas être vus ou accessibles depuis l'extérieur de la classe. Enfin, vous avez protégé, qui n'est accessible et visualisable que par les classes héritées. Et nous aborderons la question de l'héritage dans une autre vidéo. Mais la seule chose que je veux que vous notiez ici, les classes ont par défaut des membres privés. Donc, si nous voulons pouvoir accéder à ces membres, comme notre nom de chaîne ici en dehors de la classe, nous devons le rendre accessible en passant d'une variable membre privée à un membre public et, ou variable. Et souvenez-vous de cela parce que ceux-ci font partie de la classe, on les appelle membres. Et je vais commencer et mettre un trait de soulignement avant notre nom de chaîne ici, juste pour signifier que c'est un membre. Et nous allons aller de l'avant et changer cela ici également. Et si vous vous souvenez, si nous passons la souris dessus, cela indique que le nom de soulignement des animaux est accessible et que c'est parce qu'il est privé et ne peut être visualisé et accessible que de l'intérieur de la classe et non de l'extérieur. Et d'ailleurs, vous pouvez également entendre les membres de la classe appelés attributs de classe. Maintenant, comment allons-nous procéder et les rendre publics ? Eh bien, c'est assez simple. Donc, tout ce que nous avons à faire, c'est au-dessus nos membres ici que nous voulons rendre public, public, deux points, juste comme ça. Et vous y voilà. Ces membres sont désormais publics. Et si nous regardons en bas, vous pouvez voir que nous pouvons désormais accéder au membre. Maintenant, on peut aller chercher notre chien. Je veux dire, on peut dire que le nom est égal à quelque chose comme spot. Et on peut aussi aller de l'avant et donner à son chien en H. Donc, vous pouvez dire que l'âge du chien est égal à deux, alors nous pouvons faire de même pour notre chat maintenant. On peut donc dire « soulignement », nom », quelque chose comme Garfield. Soulignez ensuite que l'âge équivaut à quatre. Nous avons donc créé une classe appelée les animaux qui possède deux membres ou attributs publics, si vous préférez. L'une étant une chaîne appelée nom du trait de soulignement, appelée âge du trait de soulignement. Et cela aurait dû être juste un entier, pas une chaîne. Et puis ici, nous avons créé deux instances ou objets de notre classe en prononçant simplement le nom de notre classe, Bonjour par un nom, l'objet et un point-virgule à la fin. Et puis chacune d'entre elles a sa propre instance de ces variables, accord, donc chacune a sa propre version. Et pour y accéder, il suffit d'utiliser l'opérateur d'accès membre pour le symbole du point ou le point là si vous voulez l'appeler. Nous avons dit le nom du trait de soulignement du point de chien et l'avons défini comme étant un point point et un point noir h égal à deux. Ensuite, nous avons essentiellement fait la même chose ici pour le chat. Quoi qu'il en soit, c'est pour terminer cette vidéo. Une autre chose que je tiens à mentionner est que pour ces autres spécificateurs d' accès, nous pourrions les ajuster, les énoncer tels qu'ils sont répertoriés ici. Donc, le public ou privé, ou nous aurions pu écrire exactement comme ça. Et cela aurait très bien fonctionné. Mais je vais aller de l'avant et le rendre public. heure actuelle, nous avons des membres publics, mais nous aurions également pu créer membres privés et protégés si nous le voulions, en les collant simplement après ou avant. Nous aurions donc pu dire privé, par exemple , et ensuite avoir quelques membres privés dessous de cela et cela aurait très bien fonctionné. Voilà comment utiliser les spécificateurs d'accès et leur importance. Et je vais aller de l' avant et taper ces variables ici juste pour les rendre un peu plus lisibles. Maintenant, comment savoir quel spécificateur d' accès utiliser ? Eh bien, tout comme lorsque vous travaillez avec une portée variable, lorsque vous travaillez avec des spécificateurs d' accès, vous ne voulez que rendre les éléments disponibles selon vos besoins. Et c'est juste une fois de plus pour éviter toute erreur humaine. Et normalement, vous voulez que vos membres soient publics comme ça. Et nous y reviendrons dans une vidéo ultérieure. Mais pour l'instant, nous allons aller de l'avant et quitter public pour avoir accès à du temps ici. Quoi qu'il en soit, c'est tout pour cette vidéo. N'oubliez pas de sauvegarder ce que vous avez. Et comme toujours, merci de m'avoir écouté et je vous verrai dans la prochaine. 85. 84: Dans cette vidéo, nous allons parler fonctions de classe ou de la façon de créer une fonction au sein d'une classe. Dans notre cas, nous allons donc créer une fonction permettant de parler. C'est juste ici, dans notre classe, nous allons dire quelque chose comme nul. Et il indiquera des parenthèses ouvertes et fermées. Et puis dans un bloc de code ici, nous allons dire C out. Juste comme ça. Et nous allons créer une nouvelle ligne et mettre un point-virgule à la fin. Et le son sera en fait une variable de chaîne qui sera prise comme argument. Nous devons lui créer un périmètre. Nous allons donc dire son de cordes. Et cela fonctionnera très bien. Et c'est la méthode de base pour créer une fonction au sein d'une classe. Mais vous pouvez également le définir en dehors d'une classe. Et la façon dont cela est fait est très similaire à la création d'un prototype de fonction. Donc, en bas, allons-y, copiez-collez notre fonction actuelle. Maintenant, pour ce faire, nous devons changer certaines choses. abord, nous allons supprimer la définition de notre fonction ici dans notre classe. Ensuite, nous allons mettre un point-virgule à la fin. Et puis ici, après notre type de retour, nous devons dire animaux côlon, côlon, côlon. Si vous vous en souvenez, il s'agit de l'opérateur de résolution de portée Et maintenant, cette définition de méthode ou de fonction dans cette partie de notre classe d'animaux, et nous avons déclaré que cela allait être quelque chose ici. Donc, si vous souhaitez le définir en dehors, vous avez besoin du nom de classe suivi l'opérateur de résolution de portée juste après le type de retour. Ensuite, vous avez besoin d'une déclaration très similaire à notre prototype de fonction ci-dessus, où vous avez juste le type de retour suivi du nom, paramètres et d'un point-virgule à la fin. Donc, maintenant, allons-y et utilisons cette fonction avec notre chien et notre chat. Donc, en bas, en dessous de nos deux objets. Allons-y et ajoutons nos appels de fonction. Donc, dites chien, vitesse, et entre parenthèses, vous verrez de l'art ou ce que vous voulez, mais cela n'a pas vraiment d'importance. Et puis Dumbo qui dira chat, parle entre parenthèses. Nous dirons, d'accord, et n'oubliez pas le point-virgule à la fin. Et si nous exécutons notre code ici, vous pouvez voir que cela fonctionne très bien. Et nous pouvons imprimer ces variables comme nous le ferions pour n'importe quelle autre variable. Il suffit de préciser à quoi nous faisons référence. Nous pouvons donc dire quelque chose comme c out, cat, name, la nouvelle ligne, comme ça, et cela fonctionnera. Alors allons-y et ajoutons du code ici pour imprimer nos différentes variables animales. Et nous pouvons réellement créer une fonction pour ce faire. Allons-y et supprimons également ces appels de fonction. Et ensuite, ici, on parlera de quelqu'un comme l'animal. Et puis entre parenthèses, nous prendrons un animal. Et le nom de notre classe s'appelle en fait les animaux. Et peut-être que pour améliorer ce son, nous allons le renommer. Et vous pouvez soit procéder très rapidement et simplement supprimer le S, soit cliquer avec le bouton droit de la souris et appuyer sur Renommer ici dans Visual Studio, le remplacer par rapidement et simplement supprimer le S, soit cliquer avec le bouton droit de la souris et appuyer sur Renommer ici dans Visual Studio, animal et prévisualiser. Maintenant, notre fonction prend un animal et je vais simplement appeler cet animal, par exemple entre crochets, nous allons continuer et imprimer toutes les valeurs à l'intérieur d'ici. Comme nous travaillons avec un objet animal, nous pouvons réellement utiliser toutes les fonctions que nous pourrions normalement Comment créer un objet animal ? Nous pouvons donc dire quelque chose comme CL, nom de l'animal, espace deux-points. Bonjour, je suis maman. Ce nom de soulignement créera une nouvelle ligne, peut mettre un point-virgule à la fin. Alors allons-y, copiez-collez ceci une fois. Et nous dirons CL, âge animal. Ensuite, cela changera simplement cela en animal mais soulignera l'âge. Et enfin, nous allons dire « C ». Ensuite, nous imprimerons le nom de l'animal. Donc, dites le nom de soulignement de l'animal, juste comme ça. Et puis, entre guillemets, nous dirons espace, dit espace deux-points. Et je vais mettre un point-virgule ici. Et puis en bas, nous allons dire animal, parenthèses ouvertes et fermées et un point-virgule à la fin. Ensuite, nous allons prendre une série d'ici. Nous allons donc dire chaîne ici pour parler. Et maintenant, revenons à notre fonction principale, allons-y et appelons cette fonction pour chacun de nos animaux. C'est ce que dit animal végétal. Entre parenthèses, on dira une virgule. Ensuite, nous allons créer notre chaîne. Nous allons donc dire, eh bien, nous allons mettre un point-virgule à la fin, et ensuite nous pouvons simplement copier et coller ceux qui apporteraient des modifications avec le chat. Et dites : « Oui ». Et ensuite, si nous revenons notre fonction animale, allons créer quelques lignes juste pour le rendre un peu plus propre à chaque fois que nous appelons cela socialize C out et ligne. Ensuite, nous allons simplement continuer et le faire une fois de plus comme ça. Et nous y voilà. Quoi qu'il en soit, je vais faire un zoom arrière ici. Vous pouvez donc regarder le code et le copier si nécessaire. Ensuite, il ne nous reste plus qu' à faire une dernière chose. Et c'est créer un prototype de fonction pour notre fonction animale imprimée ici. N'oubliez donc pas que nous devons copier cette ligne ici, coller comme ça, et mettre un point-virgule à la fin. Maintenant, si nous exécutons notre code, c'est parti. Tu as dit que le nom de l'animal était spot L'âge de l'animal est de repérer la femme de son fils. Ensuite, nous avons fait la même chose ici. Quoi qu'il en soit, c'est fini pour cette vidéo. N'oubliez pas de sauvegarder ce que vous avez. Merci de m'avoir écouté, et à bientôt. 86. Chapitre 15 (cours) : les constructeurs de cours: Dans cette vidéo, nous allons parler de constructeurs. Maintenant, un constructeur est une méthode spéciale en C plus plus qui est automatiquement appelée lorsqu'un objet, je vais créer une classe. Et nous allons examiner ce que c'est, une solution adéquate et ses cas d'utilisation. Maintenant, juste pour nettoyer les choses ici, je pourrais aller de l'avant et minimiser notre méthode ici juste pour que je puisse tout garder à l'écran. Et comme nous savons déjà à quoi cela sert, nous n'avons pas vraiment besoin de nous en occuper pour le moment. Et zoomez simplement ici. Sache juste que j' ai toujours tout ce code ici. Et je ne vais pas vraiment m'en débarrasser. Et je vais aussi créer un espace vide entre notre fonction principale et notre classe animale, juste pour séparer les choses. Maintenant, allons-y et créons un constructeur. Et C plus, en plus, il existe trois types de constructeurs différents. Maintenant, le premier type de constructeur dont nous allons parler est le constructeur par défaut. Et ça ressemble à ça. Ainsi, lorsqu'un constructeur est noté, vous aurez le nom de la classe. Comme ça. Ensuite, vous allez avoir une configuration entre parenthèses avec des périmètres potentiels , puis votre bloc de code et vos crochets bouclés, comme suit. Et voici à quoi ressemble le constructeur par défaut. Et votre classe aura automatiquement ce constructeur si vous ne créez pas votre propre constructeur . Mais une fois que vous avez créé votre propre constructeur, le constructeur par défaut n'existe plus. Donc, au cas où je serais confuse, vous êtes perdu à ce stade. Allons-y et créons simplement un constructeur autour de. Je vais regarder comment fonctionnent les constructeurs. Red Bull ou une déclaration de méthode Speak ici, nous allons créer notre constructeur. Nous allons donc dire animal étant le nom de notre classe, entre parenthèses ouvertes et fermées. Ensuite, nous aurons notre bloc de code en dessous. Et à l'intérieur de cela, normalement, vous voulez traiter avec le constructeur comme initialiser tous vos membres afin de initialiser tous vos membres afin de ne pas les utiliser avant qu'ils initialisés de la manière suivante garanti car le constructeur est appelé automatiquement lorsque vous créez un objet de votre classe. Donc, si c'est le cas ici, nous avons dit que le nom du trait de soulignement est égal à 0 et que l'âge du trait de soulignement est égal Et en fait, comme notre nom est une chaîne, nous voulons juste en faire une chaîne vide. Donc, cela fonctionnera très bien car cela ne prend aucun paramètre. Cela n'affectera pas notre code ici lorsque nous avons créé notre objet chien et chat, par exemple. Donc, si nous exécutons notre code ici, vous pouvez voir qu'il fonctionne exactement comme avant. Mais maintenant, ce que nous allons faire, c'est définir notre constructeur ici en dehors de notre classe, comme nous l'avons fait avec la méthode. OK, donc pour ce faire, nous allons le copier ou construire et le coller ci-dessous, comme ça. Et il ne vous reste plus qu'à le déclarer en haut. Donc, si nous supprimons la définition ici et que nous avons juste ce qu'il y a sur cette ligne supérieure et que nous mettons un point-virgule comme ça. Et ensuite, ici, nous devons faire la même chose qu'ici. Nous allons donc dire animal, suivi de l'opérateur de résolution de la lunette. Ensuite, il y aura à nouveau « animal » étant le nom du constructeur et aussi le nom de notre classe suivi de nos parenthèses. Et enfin, notre définition ici. Donc, tout ce que nous avons à faire est fondamentalement la même chose que nous avons fait ici, sauf que nous n'avions pas de type de retour, donc nous l'avons juste mis avant le nom du constructeur, et cela fonctionnera très bien. C'est ainsi que vous pouvez déclarer un constructeur soit dans votre classe, soit en dehors de celle-ci, comme nous le pouvions avec notre fonction ici. Maintenant, une chose que je tiens à mentionner, c'est qu' un constructeur doit être public. Et c'est parce que, comme je l'ai dit, un constructeur est une méthode spéciale qui s'exécute lorsque vous créez un objet de la classe. Et puisque nous créons les objets de notre classe en dehors de la classe, le constructeur doit être public. Alors ne l'oubliez pas. Et si nous voulions ajouter des paramètres à notre constructeur ? Eh bien, nous avons quelques options. Premièrement, nous pouvons les ajouter à ce constructeur ici, ou nous pouvons le surcharger comme nous pouvons surcharger des fonctions en créant un autre constructeur avec le même nom exact qui prend des paramètres différents. Mais allons-y et changeons simplement celui que nous avons ici. Donc, ce que nous allons faire, c'est dire nom de chaîne de caractères virgule h, juste comme ça. Et nous allons le copier dans notre constructeur actuel ci-dessous. Et puis, au lieu de simplement leur donner une valeur vide pour commencer, allons-y et inscrivons ici ce que font nos paramètres. Nous dirons donc que le nom du trait de soulignement est égal au nom et que l'âge de soulignement est égal à N'oubliez pas que ce sont de vrais membres de la classe. Et ce sont les paramètres qui nous ont été transmis. Et c'est une autre raison pour laquelle il est intéressant de faire précéder vos membres d'un trait de soulignement. Faites-vous savoir qu' il s'agit d'un membre. Lorsque vous travaillerez avec elle à l'avenir, vous n'avez pas à vérifier certaines choses. Donc maintenant, si nous descendons ici, vous pouvez voir que nous avons une erreur. Et c'est parce que le seul constructeur actuel de notre classe animale nécessite deux paramètres. Parce que si vous vous souvenez, depuis que nous avons créé un constructeur, celui par défaut qui aurait ressemblé à ceci n'existe plus. Et tu pourrais avoir n'importe quel Cody, l'un d'entre eux ici. Je pourrais donc dire que peut-être imprimer un nouvel animal a été créé ou quelque chose comme ça. Et tout ce code s'exécuterait à chaque fois que nous créions un nouvel animal et utiliserions ces paramètres pour appeler spécifiquement ce constructeur. Maintenant, instant, nous n'en avons qu'un, mais si l'a surchargé, alors nous aurions dû avoir ces paramètres pour l' appeler spécifiquement ici, comme nous l'avons vu lorsque nous avons surchargé des fonctions et par le passé. Donc maintenant, si nous revenons ici, si nous lisons ce que dit cette erreur, dès qu'il n'y a plus de constructeur par défaut pour animal, ce qui signifie que nous avons maintenant besoin de paramètres et que nous pouvons corriger ce problème. Comme je l'ai dit, en surchargeant ça et en ayant un qui ne prend pas de paramètres et qui ressemble exactement à ceux d'ici. Ou on peut laisser ça et dire : « Maintenant, si tu veux créer un animal, tu dois intégrer ces deux valeurs, et c'est ce que nous allons faire. Donc, ici, tout ce que nous avons à faire si le chien est d'avoir deux parenthèses et ensuite nous devons insérer nos paramètres. Donc au lieu de dire place ici, je vais juste le mettre ici. Minnesota a sombré ici, principalement à virgule. Nous allons le mettre ici. Ensuite, nous pouvons simplement nous en débarrasser complètement, puisque nous l'avons déjà fait ici, quand il s'initialisera, il donnera le nom du chien, le nom que nous avons saisi selon l'âge du chien, l'âge que nous saisi, et ça va faire de même avec notre chat. Non, cela ne change pas les variables de la classe ici. Cela modifie votre instance spécifique de ces variables. Donc, faire quelque chose comme ça dans notre cas ici, c'est exactement la même chose que cela. Alors allons-y et faisons de même pour le chat. Je vais donc commencer par une parenthèse ouverte. Et ensuite, si vous voyez ici, je peux réellement cliquer sur ces flèches. Et il dira : « Hé, l'animal prend un nom de chaîne h. Donc, nous allons mettre un nom. Je vais mettre une virgule R et un H. Et maintenant, quand nous exécuterons notre code, il fonctionnera comme avant. Et qu'il existe en fait notre deuxième type de constructeur. Nous avons donc déjà parlé de ce qu' est un constructeur par défaut, qui est essentiellement un constructeur vide qui ne prend aucun paramètre et n'exécute aucun code dans le constructeur que nous créé ici en fait comme le deuxième type de constructeur, appelé constructeur paramétré. Et un constructeur paramétré est essentiellement ce à quoi il ressemble. Il a un constructeur qui prend paramètres et n'oubliez pas le but principal d'un constructeur est de donner généralement aux membres de votre classe ici une valeur initiale. Alors, tu y vas. Ensuite, nous avons un dernier type de constructeur, appelé le constructeur de copie. Ce qu' est un constructeur de copie en tant que fonction qui initialise un objet en utilisant un autre objet de la même classe. Alors allons-y et voyons à quoi cela ressemble. Et nous n'allons pas jeter un œil à la version détaillée de ce document sous le capot. Et nous n'allons pas en créer un nous-mêmes aussi bien que celui créé par défaut. Cela fonctionne très bien dans la plupart des cas. Alors, comment cela fonctionne-t-il ? Eh bien, par exemple, nous avons un animal appelé chien, dans un animal appelé chat. Mais nous pouvons également avoir une instance de notre classe animale et simplement la mettre comme égale à une autre instance qui existe déjà. Et cela va essentiellement le copier. Et c'est là que votre constructeur de copie entre en jeu. On pourrait donc dire animal, chat pour les libéraux, chat et queue de chat sont désormais une copie de chat. Et puis ici, on peut l'imprimer en disant « imprimer animal ». Ensuite, nous allons dire cat 2 et ensuite disons oui, comme ça, d'accord, et lançons notre code. Et vous y voilà. Nous l'imprimons maintenant « chien » avec le nom spot H02 et il est écrit « Spots » dit quoi ? Parce que c'est ce que j'ai mis ici que ça n'a fait de même pour Garfield que pour le deuxième chat. Et remarquez que toutes les valeurs sont les mêmes, mais que cela dit quelque chose d'un peu différent, car nous avons envoyé un argument différent avec notre fonction d'animal d'impression que nous avons créée dans le passé vidéo. Alors, tu y vas. Ce sont les trois types de constructeurs différents. Vous avez votre constructeur par défaut, qui est complètement vide et ne nécessite aucun paramètre. Vous avez un constructeur paramétré, qui est un constructeur avec des paramètres. Et puis vous avez votre constructeur de copie, qui, comme je l'ai dit, est créé par défaut. Et la plupart du temps, cela fonctionne très bien, ce qui vous permet de prendre une instance d' une classe et d'en créer une copie. Et n'oubliez pas que les constructeurs doivent être publics. Et que souvent, leur utilisation principale est d' initialiser les membres de la classe. Et là, je veux juste aller de l' avant et supprimer ce chat animal ici avec la fonction qui l'accompagne. N'oubliez pas de sauvegarder ce que vous avez. Merci de m'avoir écouté , et à bientôt. 87. Chapitre 15 (cours) : liste des Initializers: Dans cette vidéo, nous allons parler de listes d'initialisation. Mais avant de le faire, nous allons simplement supprimer une partie du code dont nous n' avons pas vraiment besoin pour les prochains exemples. Donc, tout d'abord, nous allons supprimer notre méthode d'impression animale qui prend un animal comme paramètre. Nous allons donc continuer et simplement supprimer cela complètement. Ensuite, nous supprimerons également les appels R2 à cette fonction. Enfin, il supprimera le prototype de fonction. Pour. Maintenant, nous n'avons que nos deux instances ou objets animaux , ainsi que notre classe animale, la fonction vocale et notre constructeur animal. Et vous l'avez peut-être remarqué, je viens d'ajouter quelques commentaires ici, juste pour vous rappeler ce que tout est. Une liste d'initialisateurs est donc ce que vous souhaitez utiliser lorsque vous souhaitez fournir des données aux membres de votre classe. Par exemple, nos deux variables ici, une valeur initiale. Donc, dans la dernière vidéo, nous sommes allés de l'avant et nous l'avons fait avec notre constructeur ici. Et c'est aussi ainsi que vous pourriez voir choses se faire dans d'autres langues, mais en C plus, ce n'est pas la bonne façon d'initialiser vos membres. Et il y a plusieurs raisons à cela. D'une part, certains types de membres ne peuvent pas être initialisés de cette façon. De plus, il est moins efficace en termes de performances et pour diverses autres raisons. Alors allons-y et examinons la bonne façon de procéder. De plus, si vous vous souvenez, une façon de créer une variable est de dire, int x. Et puis, au lieu d' avoir un signe égal suivi d'une valeur, vous pouvez simplement dire int x. Et puis entre parenthèses ont la valeur, peuvent mettre un point-virgule à la fin. Et c'est exactement la même chose, non ? La raison pour laquelle je voulais vous rappeler cette option de syntaxe, c'est parce que nous allons utiliser quelque chose de très similaire lorsque nous initialiserons similaire lorsque nous initialiserons les membres et notre classe ici à l'aide d'une liste d'initialisateurs. Quoi qu'il en soit, allons-y et voyons comment en créer un. Donc, ici, dans notre constructeur, tout ce que nous avons à faire à la fin de cette parenthèse, je dis deux points puis le nom du trait de soulignement, par exemple, parce que c'est la variable ou le membre que nous voulons initialiser. Ensuite, entre parenthèses, nous pouvons simplement y mettre le paramètre que nous allons lui transmettre. Donc, nous allons le mettre comme nom, juste comme ça, puis tous les autres membres étaient séparés par une virgule, donc disons que la virgule souligne l'âge et puis, entre parenthèses, égal à l'âge, attardez-vous sur leur paramètre ici, et C'est à peu près ça. Donc, cela va essentiellement faire la même chose que nous avons fait ici, c'est-à-dire que nous pouvons réellement supprimer ce code et notre bloc de code ici. Et cela nettoie aussi les choses. Donc maintenant, disons que nous avions une tonne de membres ici, au lieu d'avoir à les initialiser dans notre bloc de code ici et que x soit égal à 0, y est égal à 0, z est égal à 0, et ainsi de suite, maintenant tout est réglé . Et tout ce qui se trouve dans notre bloc de code est du code réel que nous voulons exécuter en plus de l'initialisation de nos membres. C'est donc la bonne façon d' initialiser les membres de vos classes. Et tu devrais le faire de cette façon à chaque fois. Donc, vous n'avez pas à vous demander quand dois-je le faire cette façon et quand dois-je le faire de l'autre façon ? Je le fais toujours de cette façon. Et n'oubliez pas de le faire. Tout ce que tu vas faire, c'est après tes parenthèses et un deux-points suivi par le membre. Et entre parenthèses, vous aurez la valeur à laquelle vous souhaitez lui attribuer la valeur. Ensuite, pour chaque membre supplémentaire que vous souhaitez initialiser, vous allez simplement le séparer par une virgule, comme suit. Maintenant, cela ne doit pas nécessairement prendre un périmètre. Nous pouvions le fixer à ce que nous voulions. Mais dans ce cas, comme nous avions des paramètres et notre constructeur conçus pour initialiser ces valeurs, nous sommes allés de l'avant et avons simplement utilisé nos noms de périmètre également. Une dernière chose que je tiens à souligner est que ceux-ci doivent être exactement dans le même ordre que celui dans lequel vos membres sont listés dans votre classe. Donc, parce que notre nom vient en premier, puis nous avons notre entier pour l'âge et nous devons être initialisés. Exactement le même ordre. Ceci est extrêmement important car ce sont multiples erreurs qui peuvent survenir si vous les faites dans le désordre. Assurez-vous donc de toujours le faire dans l'ordre comme vous l'avez ici de haut en bas. Et maintenant, si nous exécutons notre code, vous pouvez voir qu'il a fonctionné correctement sans aucune erreur. Et en fait, dans notre constructeur ici, allons-y et ajoutons du code pour imprimer quand un animal a été créé et pour spécifier les variables qu'il contient. Ainsi, disons que CL et l'animal ont été créés. Ce qui suit. N'oubliez pas que les attributs sont un autre nom que vous pouvez voir pour les membres ou les variables de votre classe. Et puis des lignes comme celle-ci. Et puis ici, nous allons dire nom, espace deux-points. Nous allons suivre cela avec moi. Et nous aurions également pu mettre le nom du trait de soulignement ici. Ça ne fera vraiment aucune différence. Et nous allons également créer une nouvelle ligne par la suite. Et puis en dessous, il y aura un espace de page comme ça. Et nous allons suivre cela avec h. Et nous allons également créer une nouvelle ligne par la suite. Et juste pour vous montrer que cela ne fait aucune différence, nous allons ajouter un âge de soulignement pour celui-ci. Et si nous exécutons notre code ici, vous pouvez voir qu'il a très bien fonctionné. Et si nous voulions nettoyer un peu cela, nous pouvons créer quelques lignes vierges supplémentaires ici. Et vous y voilà. Et je vais juste reprendre le nom de notre paramètre ici, à savoir l'âge. Quoi qu'il en soit, c'est tout pour cette vidéo, vous savez maintenant comment initialiser les membres de votre classe, étant une liste d'initialisateurs, que pour résumer, vous reste plus qu'à faire à la fin de votre constructeur ici, juste après les parenthèses, vous allez mettre deux points suivis de chaque membre dans l'ordre et entre parenthèses, vous aurez la valeur à laquelle vous allez définir chacun d'eux n. Vous pouvez le faire pour chaque constructeur que vous avez. Parce que si vous vous en souvenez, vous pouvez surcharger les constructeurs, ce qui signifie que nous pouvons en avoir plusieurs pour notre classe d'animaux ici, qui porteront tous le nom animal, puisqu'un constructeur porte le même nom que la classe. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 88. Chapitre 15 (cours) : l'encapsulation, l'abstraction, et les propriétés: Dans cette vidéo, nous allons parler de plusieurs choses différentes. Le premier est un concept appelé encapsulation, qui repose sur l'un des quatre grands principes de la programmation orientée objet. Mais nous aborderons également les trois autres grands principes plus tard dans ce cours. Et puis l'autre chose dont nous allons parler dans cette vidéo en tant que getters and setters, qui nous aidera à mettre l'encapsulation en action. Alors, qu'est-ce que l'encapsulation ? En résumé, l'encapsulation est essentiellement le processus qui consiste à encapsuler ou à combiner des données et du code qui agit sur ces données en une seule unité. Et cette unité unique ressemblerait à une classe. Et cela conduit souvent à cacher vos données derrière un code capable d'interagir avec elles. Allons-y et voyons comment l' implémenter correctement dans notre classe d'animaux ici, ainsi que son cas d'utilisation. Vous savez donc quand et comment l'implémenter dans vos propres programmes à l'avenir. Alors allons-y. La première chose que nous allons faire ici c'est ici, dans notre classe d'animaux, nous allons créer un autre entier appelé santé. Donc, juste en dessous ou en dessous de l'âge, allons-y et disons que M souligne la santé. Et puis dans notre constructeur, allons-y et ajoutons cette variable à notre liste d'initialisateurs. Donc, après avoir souligné l'âge avec l'âge et mis l'accent sur ce point, nous allons dire que la virgule souligne la santé. Ensuite, entre parenthèses, nous allons simplement le définir comme étant égal à 100. OK ? Donc, cela aura juste une valeur par défaut de 100, ce qui représente un 100 % ou la manière dont vous voulez le voir. départ, chaque animal aura 100 points de santé. Et nous n'allons même pas prendre cela comme un paramètre. Ce sera juste la valeur par défaut pour chaque animal puisqu'il s'agit de notre seul constructeur. Maintenant, actuellement, si nous voulions changer la santé de notre chien ici, nous pouvons dire quelque chose comme ceci. Donc, dans notre fonction principale sous laquelle nous avons créé notre chien, nous pouvons dire que le point chien souligne la santé moins est égal à 50. Et ça va très bien fonctionner. Rien ne nous empêche de changer cette variable comme nous le souhaitons. Et si nous allons de l'avant et que nous imprimons la santé ici, nous dirons C sur Dark Dot Health et créerons simplement une nouvelle ligne. Allons-y et imprimons également que c' était la santé du chien. Nous allons donc dire que les chiens synonymes d'alibi ou de santé pour créer une nouvelle gamme. Maintenant, si nous exécutons un code, vous pouvez voir que les animaux ont été créés avec les attributs suivants, nom est Spot à deux ans et la santé des chiens était F D. Et je vais ajouter quelques lignes vierges supplémentaires ici. Nous allons donc juste dire ligne M plusieurs fois. Ainsi, lorsque nous exécutons notre code ici, il est un peu plus lisible. OK ? D'accord, désolé, la santé des chiens est de 50. Et si nous allions de l' avant et soustrayions 50 points de santé supplémentaires à notre chien pour quelque raison que ce soit. Mais maintenant, si nous exécutons notre code, vous pouvez voir que sa santé est de 0. Et si on le faisait encore une fois ? Alors allons-y et collez-le ci-dessous, comme ça. Eh bien, maintenant, cette valeur est négative de 50 et nous ne voudrions peut-être pas que cela se produise pour un. Et même si nous avons oublié de programmer en une semaine, ne voulions pas que notre état de santé soit inférieur à 50 si nous voulions changer cela plus tard. Actuellement, nous devrions faire quelque chose comme ça. Tout d'abord, il faudrait découvrir toutes les fois où nous avons changé la santé des chiens. Ensuite, il faudrait mettre ça dans une déclaration IF ou quelque chose comme ça. Vous dites que si le point du chien souligne que la santé est supérieure ou égale à 50, par exemple. Ensuite, nous voulons faire ce qui suit. Ensuite, nous pourrions le coller. Ou nous pourrions dire quelque chose comme si la santé est inférieure à 0. Ensuite, nous voulons attribuer à un chien une santé égale à 0. Comme ça. Et cela fonctionnerait, mais cela pourrait devenir assez ennuyeux. Et puis, si nous voulions faire autre chose plus tard, nous devons maintenant retrouver tous ces spots et les changer tous. Encore une fois. J'espère que vous pouvez constater que cela pourrait devenir un très gros problème au fil du temps, en particulier à mesure que notre programme se développe. Et il se peut que nous ayons plusieurs sections de code ou que la santé d'un chien soit supprimée. Ou si nous créons un jeu ici, plusieurs facteurs peuvent affecter santé de nos chiens ou quelque chose comme ça. Alors, que pouvons-nous faire à la place ? Eh bien, allons-y et laissons ça ici pour l'instant. Passons ensuite à notre classe d'animaux ici. Donc, ce que nous pouvons faire, c'est avoir quelques fonctions pour chacun de nos membres ici, pour obtenir et définir les valeurs respectivement. Nous pouvons avoir toutes les règles pour les obtenir et les configurer dans le cadre de ces fonctions. Et si nous rendons ces membres uniquement accessibles via ces fonctions, alors nous savons que nulle part dans notre code, il ne peut y avoir quelque chose comme ça qui changera la variable d'une certaine manière que nous n'avons pas précisé. Alors allons-y et faisons-le. Donc, ces fonctions que nous allons créer sont appelées getters and setters. Et avant de les créer, nous allons rendre tous nos membres privés, afin qu'ils ne soient accessibles que depuis les fonctions de nos getters et setters. Donc, en dessous de notre déclaration du constructeur, nous allons dire deux-points privés. Si vous vous en souvenez, c'était notre spécificateur d'accès. Nous avons maintenant nos membres publics et nos membres privés. Et ce que nous allons faire, c'est copier tous nos membres d'ici. En fait, nous allons les couper et les coller ici. Et maintenant, ils sont privés et transportent des marchandises. Maintenant, au lieu d'en créer un pour chacun d'entre eux, nous allons simplement dire que le nom et l'âge ne peuvent pas être modifiés une fois l'objet est créé en utilisant ces paramètres ici. Nous allons donc simplement en créer un pour la santé. Et même si nous aurions pu en créer un pour ceux-ci, cela nous fera gagner du temps et vous aurez une idée de la façon dont cela fonctionne malgré tout . Donc, là-haut, nous allons créer quelques fonctions publiques. première mise en santé et une autre pour obtenir de l'aide. Alors allons-y et faisons-le d'abord. Nous dirons « Sortez ». Et puis, entre parenthèses, nous n'aurons aucun paramètre suivi par notre bloc de code, comme ça. Et ce que nous allons dire, c' est renvoyer un trait de soulignement. Et puis en bas, cela créera une fonction pour définir l'état de santé. Nous allons donc dire que le vide a créé la santé. Et puis, entre parenthèses, nous allons réellement prendre un argument. Nous allons donc devoir créer un paramètre ici et nous allons dire int. Et puis dans notre bloc de code, on dira « souligner », la santé est égale à. Et c'est la syntaxe la plus élémentaire pour créer un getter et un setter. Et si vous venez d'un autre langage de programmation, vous pouvez les reconnaître comme des propriétés. Quoi qu'il en soit, celui-ci du haut est notre meilleur parce qu'il nous donne de la valeur et celui-ci du bas est notre centre. Maintenant, vous vous demandez peut-être quoi c'est mieux que si nous le rendions public ? Maintenant, ce n'est pas le cas actuellement. Mais nous verrons comment cela peut devenir plus complexe et s'avérer utile en un instant. Donc maintenant, si nous revenons à notre fonction principale ici, vous pouvez voir que nous avons une erreur disant : « Hé, la santé n'est pas accessible et c'est parce que nous l'avons rendue privée. Donc, ce que nous allons devoir faire maintenant est le suivant. Donc, ici, au lieu de cela, nous allons devoir dire «  Dog Set Health ». Ensuite, nous ajouterons un moins 50 comme ça. Et nous allons le coller trois fois pour reproduire ce que nous avions auparavant. Et puis, ici même, quand nous avons voulu imprimer l'état de santé du chien, dirons que le chien est bon pour la santé. Et cela nous renverra la valeur entière. Et maintenant, si nous exécutons notre code, vous pouvez voir que cela a bien fonctionné et qu'il fonctionne de la même manière qu'auparavant. Et vous vous demandez peut-être : «  En quoi est-ce que c'est mieux ? Eh bien, allons-y et examinons les avantages de ce que nous venons de faire. Donc, si nous revenons à notre classe d'animaux, je voudrais vous montrer une chose rapidement. abord, notez que nous pouvons accéder à Underscore Health ici avant même de mentionner ce qu'était Underscore Health. Et au fait, très rapidement, normalement, lorsque vous avez des membres publics et des membres privés, vous voudrez d' abord avoir les membres publics pour que lorsque quelqu'un regarde votre classe, il obtienne toutes les informations dont ils ont besoin ici. Comme d'habitude, les membres privés ne sont pas vraiment aussi importants s' ils en ont besoin et ils devraient être en mesure de dire tout ce qui se passe à partir d'ici. Quoi qu'il en soit, revenons à ce dont je parlais, pourquoi pouvons-nous y accéder alors que c'est ici ? Et c'est parce que ce que nous avons ici actuellement, qui concerne les cours, n' est pas vraiment lu comme il en a l' air et la façon dont il a réellement été lu l'est en tant que telle. Donc, ce que nous allons faire pour vous montrer à quoi cela ressemble réellement pour notre programme lorsqu'il lit notre code, c'est que nous allons simplement copier ces deux fonctions et les coller ci-dessous ici. Et nous allons simplement les coller tout en bas pour le moment. Et allons-y également et déplaçons notre fonction vocale là-bas. Désolé, constructeurs de l'époque, comme ça. Et maintenant, nous allons les changer ici, dans notre classe. Permettez-moi de faire un zoom arrière pour que vous puissiez voir la Grande-Bretagne les changer ici pour qu'ils ne soient que des prototypes fonctionnels. Nous allons donc mettre un point-virgule et ensuite supprimer le bloc de code. Chacune de ces lignes est ici. Ensuite, en bas, nous allons ajouter le nom de notre classe, suivi de l'opérateur de résolution de la portée, comme nous l'avons fait avec notre fonction Speak. Permettez-moi donc de le copier et de le coller dans les deux. C'est ainsi que notre code était réellement lu auparavant. C'est pourquoi nous pouvons avoir la déclaration de variable après la définition de notre méthode car elle a été réellement lue. C'est là que nous avons notre prototype ou la déclaration de notre fonction ici, puis la définition après la fin du cours. C'est donc quelque chose qui ne fonctionne pas normalement. Mais quand il s'agit de cours, par exemple, c'est le cas. Donc je voulais juste vous informer à ce sujet. Elle n'était pas très confuse. Pourquoi cela a-t-il fonctionné comme cela n'a jamais fonctionné pour nous dans le passé ? Alors maintenant, allons-y et voyons comment ces getters et setters sont réellement utiles. Et aussi ce que nous avons fait ici en faisant en sorte que ce membre de la santé soit privé et encapsulant dans ces deux fonctions. Voici un excellent exemple d'encapsulation. Maintenant, ce que nous pouvons faire dans notre configuration est le suivant. Donc, après avoir dit, mettez l'accent sur la santé. La santé des personnes. Nous pouvons également définir une valeur minimale et une valeur maximale pour cela. Donc maintenant, si nous le voulions, nous pourrions dire que la santé du score de soulignement F est supérieure à 100, par exemple. Soulignez ensuite que la santé est égale à 100. Et en dessous, nous pourrions dire f, ou nous pourrions simplement créer une autre déclaration if ici. Nous allons donc continuer et dire que santé du score de soulignement F est inférieure à 0. Ensuite, soulignez que la santé est égale à 0, juste comme ça. Et maintenant, quand quelque chose affecte la santé de notre chien ou tout objet ou instance de notre classe animale. Donc, il s'agissait du chien, du chat ou un autre animal que nous pouvons créer à tout moment et que nous essayons d'affecter la santé, nous devons maintenant passer par cette fonction de santé définie et nous pouvons ajouter n'importe quel code à ceci plus tard sans décomposer notre code ici. Remarquez que nous n'avons rien eu à modifier ici pour ajouter une valeur minimale et une valeur maximale maintenant, et nous pouvons soit imprimer quelque chose tout moment, soit configurer la santé pour afficher notre nouvelle valeur de santé si nous le voulons ou ce que vous voulez faire. Et nous n'avons rien à changer ici. Donc, comme nous avons ces getters et setters, notre code est beaucoup plus dynamique et nous n'avons pas à nous soucier de toutes les fois où nous avons essayé d'obtenir et de définir cette variable. De plus, nous n'avons pas à nous soucier de contourner ces fonctions et de simplement modifier cette variable directement parce qu'elle est privée, signifie qu'elle n'est disponible que dans notre classe, qui signifie qu'elle n'est disponible que dans notre classe, c'est pourquoi notre La fonction ici, qui fait directement partie de notre classe, a accès, mais quelque chose comme cette fonction principale ne le ferait pas. Donc, après ces deux déclarations si, je vais juste dire que la santé maximale est égale à 100. Et ici, je vais dire santé minimale 0, comme ça, juste pour nous rappeler ce qu'ils font ici. Maintenant, si nous exécutons notre code, vous pouvez voir que la santé du chien ne descendra plus que à 0 maintenant grâce à cette fonctionnalité supplémentaire que nous avons ajoutée. Et remarquez encore une fois que nous n'avons rien eu à changer ici. Quoi qu'il en soit, c'est tout pour cette vidéo. Mais allons-y et récapitulons ce que nous avons appris ici. D'une part, en ce qui concerne les classes, vous pouvez réellement avoir une méthode, déclaration et une définition avant toutes les déclarations de variables qu'il utilise , car elles sont lues comme ceci. Cependant, cela étant dit la bonne façon de le faire à partir de maintenant pour écrire une définition de méthode est d'avoir votre déclaration dans la classe et la définition en dehors de la classe. D'une part, cela aide à encombrer votre code et, à l'avenir, s'il sépare cette classe et crée son propre fichier d'en-tête et son propre fichier CPP ou C plus plus. Cela facilitera beaucoup les choses. Vous devriez donc toujours avoir vos définitions en dehors de la classe. Donc, en règle générale, votre classe ne doit contenir que des déclarations et en dehors de la classe doivent se trouver vos définitions. Gardez donc cela à l'esprit pour l'avenir. Maintenant, l'autre chose que nous avons apprise, c'est comment créer un getter et un setter. Et même si nous savions déjà comment créer des fonctions, nous connaissons maintenant les cas d'utilisation pour créer des fonctions spécifiques, pour obtenir et définir variables privées au sein de notre classe. Et nous apprenons également la bonne façon de répertorier nos membres publics par rapport à nos membres privés en étant publics en haut et privés en bas, vous pouvez le faire comme vous le souhaitez. Mais c'est la manière appropriée et probablement la plus préférée de le faire. Parce que, comme je l'ai dit, quand quelqu'un regarde votre classe en bas de la ligne en respirant, si vous regardez le code de votre classe, c'est bien d'avoir toutes les informations publiques en haut de la page parce que c'est généralement tout ce qui me tient à cœur. Et souvent, les membres actuels sont un peu comme des personnages de fond qui peuvent vous intéresser ou non. En fait, je jette un œil à. Si ma classe était plus grande, il y aurait peut-être encore plus d'informations privées à passer au crible pour obtenir ce qui nous tient à cœur si elles étaient écrites dans l'autre sens. Donc, en règle générale, vous devriez avoir vos membres publics en haut de la liste. Ensuite, nous avons appris à utiliser notre getter and setter cas d'utilisation et certains des avantages liés à leur création. La principale chose à retenir est donc savoir comment utiliser l'encapsulation. Vous avez donc toutes vos déclarations dans votre classe et vos définitions en dehors de celle-ci sont écrites en dehors de celui-ci. Et puis, lorsque vous le pouvez, vous devriez toujours garder vos membres privés afin qu'ils soient accessibles de manière à ne pas les ralentir. Vous voulez changer la façon dont ils ont travaillé avec eux. Vous n'avez pas à le chercher partout dans votre code et à chercher comment le corriger, en particulier pour les erreurs ou quelque chose comme ça. Tout ce que tu as à faire c'est de regarder ici. Ce que nous avons fait ici, c'est travailler avec deux des quatre principaux piliers de la programmation orientée objet. L'un étant l'obstruction et l' autre l'encapsulation. Et nous en reparlerons un peu plus en détail dans une vidéo ultérieure. Mais ils résument rapidement de quoi il s'agit et de la façon dont nous les pratiquons ou avons travaillé avec les deux. Abstraction en tant que méthode ou processus de masquage d'informations indésirables. Lorsque nous avons pris nos membres comme variables ici et les avons consultées depuis le monde extérieur ou depuis le reste de notre code, nous pratiquions l'abstraction. Alors que l'encapsulation était le véritable processus de confinement de l'information. Ces deux éléments travaillent donc main dans la main. Nous avons donc extrait les informations ou les informations cachées du monde extérieur ou le reste de notre code en rendant ces membres privés, par exemple. Ensuite, nous avons également encapsulé ces informations dans ces méthodes ou fonctions. Alors, vous l'avez. Quoi qu'il en soit, c'est tout pour cette vidéo. N'oubliez pas de sauvegarder ce que vous avez. Merci de m'avoir regardée, et je te verrai dans la prochaine. 89. 88: Dans cette vidéo, nous allons parler de l'héritage. L'héritage sera en fait notre troisième pilier de la programmation orientée objet. Maintenant, ils ne sont pas dans un ordre précis. Il se trouve que c'est le troisième dont nous avons parlé jusqu'à présent. Alors, qu'est-ce que l'héritage ? Eh bien, c'est la capacité d'une classe à hériter ou dériver des propriétés ainsi que des caractéristiques d'une autre classe. Et nous allons créer et examiner un exemple. Commençons donc d' abord, allons-y et supprimons certains éléments de notre code juste pour nettoyer les choses ici. Ce que nous allons faire en dehors de la création de notre chien et de notre chat, c' est ne pas déplacer les autres lignes de code et notre fonction principale comme ça. Ensuite, je vais aussi aller de l'avant et minimiser notre setter et notre getter puisque nous savons déjà ce qu'ils font. Ensuite, je vais aussi aller de l'avant et minimiser notre constructeur d'animaux. Ensuite, je vais commencer et déplacer notre fonction vocale. Je vais donc le descendre très rapidement en dessous de notre centre ici. Ensuite, je vais également le modifier ici où nous avons notre déclaration à ce sujet. Donc je vais juste le mettre ci-dessous comme ça. Et nous y voilà. heure actuelle, c'est beaucoup moins de code à regarder. Donc, ce que nous allons faire, c'est au lieu d'avoir notre classe d'animaux et de simplement donner le nom de notre objet ou une instance de celui-ci en tant que chien et chat. Marxisme et créez deux sous-classes et/ou des classes dérivées. L'un pour un chien, l'autre pour un chat qui hériteront tous deux de la classe des animaux, mais qui ont tous deux quelque chose d' unique. Et cela nous permet de récupérer tout ce que nous avons créé dans le cadre de notre classe d'animaux et de le placer dans une autre classe sans avoir à le répéter. Cela ne conduit pas seulement à une erreur humaine, mais cela ne fait que compliquer les choses lorsque nous savons quelque chose comme : « Hé, chaque animal aura cette fonctionnalité et autre chose. Donc, ce que nous pouvons faire, c'est simplement créer des sous-classes qui sont des classes dérivées qui en héritent. Commençons donc en bas notre définition de fonction, nous allons procéder comme suit. Nous allons dire chien de classe. Ensuite, entre crochets, nous aurons notre code pour notre classe de chiens, mais nous ne voulons pas simplement créer une classe appelée Dog. Nous voulons qu'il hérite de notre classe animale, car le chien est un animal et nous avons déjà créé une définition de ce que chaque animal possède. accord, donc ce que nous allons faire pour hériter de notre classe d'animaux, c' est simplement après le nom de notre classe, disons deux points, suivi d'un spécificateur d'accès. Dans ce cas, nous allons dire public. Et j'y reviendrai dans un instant. Et puis le nom de la classe dont nous voulons hériter d'un animal public, juste comme ça. Et nous y voilà. Nous avons maintenant créé une sous-classe ou une classe dérivée. Vous entendez souvent ces mots utilisés de manière interchangeable qui héritent de notre classe de base ou de notre super classe. Vous pouvez donc entendre ce que l'on appelle « super » et sub » ou « base » et « dérivé ». Maintenant, pourquoi avons-nous dit public ici ? Eh bien, laisse-moi te dire. Donc, si vous placez le public avant le nom de la classe de base, voici ce qui va se passer. Donc, si vous vous en souvenez, vous avez trois spécificateurs d'accès différents. Publique, protégée. Et privé. Public rend tous les membres disponibles partout. Protégé, rend tous les membres uniquement disponibles dans la classe et dans toute classe qui en hérite. Et puis, le mode privé rend tous les membres uniquement disponibles au sein de la classe en particulier. Et il se trouve que si vous dites public ici, tous les membres de l'animal que nous sommes publics sont publics pour notre classe de chiens. Tout ce qui a été protégé est protégé pour notre classe de chiens. Et tout ce qui était privé l'est pour notre classe de chiens. Cela étant dit, les membres privés d'une classe de base ne sont pas directement accessibles à partir de la classe dérivée. Alors que les membres protégés peuvent, c'est-à-dire tout ce qui était privé, ne seront pas accessibles directement depuis notre classe de chiens ici. Que se passerait-il si, au lieu de dire public ici, nous modifiions cela pour le protéger ? Eh bien, essentiellement, tout ce dont nous avons hérité et qui était public serait protégé. Tout ce qui était protégé le resterait. Et tout ce qui était privé, qui le reste. Donc maintenant, nous supprimons tout ce qui était public et nous le déplaçons dans la production. Et si nous disions « privé » ici, les membres dont nous avons hérité seraient tous privés. Cependant, seuls les objets privés de la classe de base ne seraient pas accessibles directement depuis notre classe pour chiens. Et tout ce qui a été rendu privé mettant ici le sera désormais dans notre classe de chiens et la façon dont cela nous affecte. Si vous êtes un peu confus, vous pouvez hériter d' une sous-classe comme celle-ci. Nous pourrions créer une autre classe héritée du chien, qui hérite de l'animal. Et tu peux le faire encore et encore si tu le souhaites. Et tout comme nous pourrions avoir d'autres classes qui héritent du chien. Le chien peut également hériter de plusieurs classes. Et pour cela, il suffit de dire une virgule animale. Et poursuivez avec la ou les autres classes que vous souhaitez hériter de chacune d'elles, séparées par une virgule. Ensuite, vous mettriez le spécificateur d'accès en premier, encore une fois pour chacun d'entre eux, et vous suivriez avec le nom. Donc, tout ce que nous avons ici, vous devez le mettre après cette virgule pour chaque autre classe dont vous allez hériter. C'est tellement simple. Maintenant, nous n'allons pas nous plonger dans toutes les différentes formes d' héritage que vous pourriez voir dans ce cours ou avec lesquelles vous travaillerez. Mais sachez simplement que vous pouvez hériter de plusieurs classes. Et vous pouvez même hériter de sous-classes. Et vous pouvez même en hériter si vous le souhaitez, et la liste est longue. Mais pour nous, ici, nous allons simplement examiner la forme d'héritage la plus élémentaire, à forme d'héritage la plus élémentaire, avoir une classe qui hérite d'une seule classe de base. Quoi qu'il en soit, allons-y et avançons. J'espère que tout cela avait du sens pour vous. Donc, parce que nous avons dit que le public entendait tout ce qui était public, je serais resté public dans notre classe de chiens parce qu'elle hérite de tous les membres de notre classe d' animaux. Tout ce qui était protégé, ce que nous n'avions rien, serait resté protégé et tout ce qui était privé à notre classe d'animaux ne sera pas directement accessible depuis notre classe de chiens parce que c'était privé, accessible uniquement à cette classe ici. Et maintenant, ce que nous allons faire, c'est créer un constructeur pour notre classe de chiens. Mais une chose dont nous devons être conscients c'est que chaque fois qu'un chien est créé et qu'un animal est créé en arrière-plan. Et si vous vous souvenez, nous nous sommes débarrassés de notre constructeur animal par défaut, qui ne prenait aucun paramètre, ce qui signifie qu'actuellement, pour créer une instance d'un animal, animal a besoin d'une chaîne pour et un entier pour un âge. Alors, comment allons-nous procéder et mettre cela en œuvre ? Une chose que nous pourrions faire est de créer un constructeur par défaut qui ne prend aucun paramètre. Et même si cela fonctionnerait et nous permettrait créer un chien sans avoir à saisir de paramètres pour initialiser notre nom h ici, n'est pas vraiment ce que nous voulons car cela contournerait la façon dont nous, nous initialisons notre nom et notre âge en nous permettant de lui donner un nom et un âge plus bas. Au lieu de cela, nous pourrions simplement aller de l'avant et hériter de tous les constructeurs de notre classe animale en disant «  utiliser » suivi du nom de la classe « animal » pour Colin » étant notre résolution de portée opérateur, suivi à nouveau du mot animal et d'un point-virgule à la fin. Cela aurait pour effet d'hériter de tous les constructeurs. Donc maintenant, si nous sommes venus ici et que nous disions quelque chose comme chien, mon chien peut mettre nos parenthèses. Vous pouvez voir que l'une de ces options, et d'ailleurs, je les fais défiler et flèches vers le bas indiquent que, hé, nous avons besoin d'un nom et d'un âge maintenant, et nous pouvons simplement ajouter un un nom et un âge comme nous l'avons fait par le passé. Cela fonctionnerait très bien, mais nous n'allons pas le faire. Et je vais vous montrer pourquoi ici dans une seconde. Nous allons donc aller de l'avant et nous en débarrasser. Mais c'est ainsi que vous pouvez hériter de tous les constructeurs de votre classe de base. Au lieu de cela, nous allons faire ce qui suit. Nous allons créer un nouveau constructeur pour chien en disant chien, parenthèses ouvertes et fermées. Ensuite, nous allons mettre un point-virgule à la fin, car ce ne sera que notre déclaration. Mais celui-ci va prendre les mêmes paramètres que ceux de notre classe animale. Nous allons donc dire le nom du chien, virgule, l'âge entier, juste comme ça. Ensuite, nous allons copier cette ligne et la coller en dessous de notre classe pour implémenter la définition. Nous allons donc respecter nos crochets bouclés ouverts et fermés , comme toujours. Ensuite, ici, nous allons utiliser un initialiseur de liste pour le constructeur de notre classe d'animaux. Nous allons donc dire animal du côlon. Et puis, entre parenthèses, vous allez insérer les paramètres requis par un constructeur animal. Nous allons donc prendre ce nom comme nom de périmètre ici, et simplement l'insérer comme nom ou comme variable de chaîne pour ce constructeur ici, puis nous dirons la virgule h, comme ceci. Et puis, si vous vous en souvenez, nous devons revenir ici et dire chien étant le nom de notre classe, deux-points, pour préciser que c'est la définition pour cette année. Et maintenant, tout va très bien fonctionner. Alors maintenant, lorsque nous créons un chien, c'est notre seul constructeur pour un chien et il faut un nom et un âge. Il faut maintenant insérer ce nom et cet âge dans le nom et l'âge du constructeur pour notre classe d'animaux. Et nous allons passer en revue tout cela ici à la fin. Alors ne vous inquiétez pas, si vous êtes un peu confus, suivez simplement. Et ensuite ce que nous allons faire à l'intérieur de notre constructeur ici. Et passons à l'endroit où nous avons notre constructeur animal et supprimons tout le code qu'il contient comme ça. Nous allons le coller ici. Ensuite, on dira « C ». Un chien a été créé avec les attributs suivants : nom, nom, âge, âge. Et si nous le voulions, nous pourrions même dire quelque chose comme c out health. Colon Space 100, puisque nous savons que notre santé sera toujours de 100 au départ. Ensuite, nous allons simplement ajouter un point-virgule. Ensuite, ce que nous allons faire, c'est copier les n lignes d' ici ou les couper, devrais-je dire, les coller ici, non ? Donc maintenant, chaque fois que nous créons un chien, cela signifie qu'un chien a été créé avec les attributs suivants. Le nom étant quel que soit le nom que nous donnons lorsque nous créons un chien, l'âge étant quel que soit l'âge que nous avons saisi lorsque nous créons un chien, la santé sera par défaut de 100. Et c'est parce que dans notre constructeur d'animaux, quand il s'agit de Ram, la santé est automatiquement réglée à 100. Alors allons-y et copions tout cela ici. Donc, tout, de notre classe de chiens à notre constructeur de chiens, en passant par notre définition ici. Et collez-le ci-dessous. Et nous allons dire classe, chat, changez-le de chiens. Le nom de la chaîne est Cat, le nom de la chaîne. Et ici, ça va changer les deux, Cat aussi. Je dirais chat sur côlon, chat, et nous pouvons laisser le reste tel quel. Et puis, ici, dans le bloc de code, on dira qu' un chat a été créé avec les attributs suivants. Et nous y voilà. Maintenant, ici, au lieu de créer deux animaux et de faire appel à un chien et quand c'est un chat, créons un chien et un chat. Alors allons-y et supprimons cela. Et nous dirons chat. Et on va juste l'appeler mon chat pour l'instant. Et puis, entre parenthèses, nous avons besoin d'une chaîne, puis d'une pour le nom et d'une autre pour l'âge. Nous l'appelons donc à nouveau Garfield. Et nous allons régler l'âge à deux virgules manquantes, comme cela. Ne mettez pas de point-virgule à la fin. Maintenant, remarquez ici qu'il est dit que cat, cat ou le constructeur de cat est inaccessible à la ligne 81. Et c'est parce que nous n'avons pas rendu public notre constructeur. N'oubliez pas que les membres en fin de cours sont privés par défaut. Les constructeurs doivent être publics pour qu'ils puissent travailler. Nous allons donc simplement dire public. Donc, mettez deux points à la fin, et je vais simplement le mettre en retrait pour le rendre un peu plus lisible et nous ferons de même pour notre chien. Donc, là-haut, on dira deux-points publics. Ensuite, je vais le saisir juste pour le rendre plus lisible. Et nous y voilà. Maintenant, l'erreur a disparu. Qui sont tous prêts à partir ? Ensuite, en bas, si je dis mon point de chat, remarquez que je peux retrouver la santé parce que j' ai accès à cette fonction publique. Et je peux régler la santé parce que nous avons également accès à cette fonction publique. Et nous pouvons aussi parler, c'est la fonction que nous avons créée ici pour simplement imprimer la chaîne que vous entrez. Alors allons-y et changeons-y un tout petit peu. Donc on va dire que mon chat est mort. Réglez la santé. Et nous allons simplement dire quelque chose comme dix et mettre un point-virgule à la fin. Et cela portera notre santé à dix. Parce que si vous vous souvenez de notre fonction ici, SAT Health prend simplement la quantité de santé que vous entrez et la définit comme étant égale à celle-ci. Et si nous l'avions voulu, nous aurions pu créer une fonction permettant modifier la santé en fonction d'une valeur spécifique. Et allons-y et faisons-le rapidement. Donc, là-haut, nous allons créer une nouvelle, autre fonction pour changer la santé. Je veux dire « nul », « changer de santé ». Et nous prendrons en main la santé. Juste comme ça. Je ne mets pas de point-virgule à la fin. Ce sera une fonction de changement pour vous aider. D'accord, je vais juste ajouter un petit peu à ces commentaires ici. Vous avez donc un améliorateur de santé, un passeur et un changeur. Et si nous copions cette déclaration ici, puis que nous descendons ici, je vais réellement continuer et minimiser notre fonction cellulaire pendant un moment, ainsi que notre fonction vocale. Et essentiellement entre notre santé définie dans la fonction R Speak. Je vais juste y aller et coller ça. Ensuite, nous allons créer une nouvelle fonction comme celle-ci. Et à l'intérieur, je vais copier tout le code de notre fonction set L et le coller ici. Et maintenant, nous allons dire que souligner la santé équivaut à la santé, puis nous pouvons laisser le reste. Et cela nous permettra de dire « changez de santé » , puis d'insérer une valeur positive ou négative et de l'ajouter directement à notre membre de santé. Et remarquez que nous avons cette erreur, sauf si nous devons encore l'ajouter ici juste avant le nom de notre fonction. Et cela clarifiera cet article. Ensuite, nous irons de l'avant et les minimiserons. Et maintenant, si nous descendons ici, nous pouvons dire quelque chose comme mon chat, retrouver la santé, pour obtenir notre valeur pour la santé. Et nous allons l'imprimer. Donc, dites CL health, alors nous pouvons aller de l'avant et dire quelque chose comme mon chat, changer de santé et nous la changerons par moins 15. Disons que notre chat a été blessé ou quelque chose comme ça. Ensuite, nous imprimerons à nouveau la santé. Donc on va juste dire C, mon chat est mort. Aucune. Allons-y également et créons un chien. Donc, en bas , on dira chien. Mon chien va changer son nom pour Spotty. Et il a 23 ans. Je vais juste mettre un point-virgule à la fin. Et allons-y également et ajoutons quelques lignes vierges ici. Disons en ligne et ligne comme ça et exécutons notre code. Et comme tu peux le voir, ça a l'air un peu bizarre. Alors allons-y et réglons ce problème très rapidement. Donc, ici, à l'intérieur de notre constructeur de chiens et d'animaux, nous devons mettre une ligne N après H et une après l'âge et le chat. Maintenant, si nous exécutons à nouveau notre code rapidement, nous pouvons voir que cette partie a été corrigée. Maintenant, nous avons juste cette étrange centaine de 85 ici. Et le changement qu'il vous suffit d' ajouter du texte ici. On pourrait dire quelque chose comme « c out ». Garfield. La santé est l'espace du côlon. Nous allons ajouter un autre opérateur d'insertion comme celui-ci. Ensuite, nous allons simplement le copier. Enfin, cela créera simplement une ligne blanche après avoir dit que Garfield est en bonne santé pour la première fois ici. Donc, à la fin de la deuxième ligne exécutez un code, et vous voilà. Maintenant dit qu'un chat a été créé avec les attributs suivants nommés Garfield H2, Health 100. Garfield, sa santé est de 100. Ensuite, nous l'avons modifiée avec notre fonction change health, à laquelle nous avons pu accéder en utilisant simplement le nom de notre instance ou de notre objet ici car cette fonction était publique. Ensuite, nous avons pu jouer avec le simple député sur la santé de la classe animale dont elle est dérivée, parce que nous avions ces getters et ces setters à notre disposition. Et puis nous avons imprimé son état de santé, à nouveau âgé de 85 ans, puisque nous venons d' en retirer 15, nous avons simplement créé un chien qui a fait la même chose. Si nous imprimons un chien créé avec les attributs suivants, nom spotty age 300. Alors, tu y vas. Quoi qu'il en soit, je sais que c'était probablement beaucoup de choses. Revenons donc en arrière et passons rapidement en revue l'ensemble de notre code ici. Je vais donc m'y prendre , dézoomer un peu et minimiser tout ce que nous avons jusqu'à présent. Alors allons-y et partons du haut. Comme je le sais, nous travaillons avec ce code depuis un certain temps maintenant, car nous l'avons appris et nous l'avons ajouté étape par étape. Nous avons donc créé une classe appelée animal, puis nous lui avons donné des membres publics et privés. Maintenant, commençons par un membre privé. Donc, d'abord, nous avons dit essentiellement que chaque animal aura un nom. Nous allons le stocker dans une chaîne. Ils auront un âge qui stockera un entier et une valeur de santé. Il sera également stocké dans un entier. Et chaque fois qu'un animal est créé, nous allons commencer à initialiser ces valeurs. Et nous l'avons fait avec notre constructeur, qui, si vous vous en souvenez, juste une fonction qui sera appelée contient juste une fonction qui sera appelée automatiquement chaque fois qu' un animal la créera. Pour ce faire, nous utilisons le nom de notre animal ici, suivi de certains paramètres que nous voulions prendre en compte, dans la définition que nous avons donnée ci-dessous. Il n'exécute donc aucun code seul, mais il prend une chaîne et un entier, un pour notre variable de nom et un pour la variable d'âge. Et nous avons utilisé une liste d'initialisateurs juste ici avec ce deux-points suivi chaque membre que nous voulions mettre dans l'ordre. Il a donc dit que le nom de soulignement étant notre nom de membre, ils seront définis comme étant égaux au nom ou à l'argument qui a été transmis pour ce paramètre. Ensuite, nous avons fait de même pour H ici même. Enfin, nous sommes allés de l' avant et avons donné une santé et une valeur initiale de 100 à chaque fois que nous ne prenions aucune entrée utilisateur pour celui-ci. Ici. Je vais aller de l'avant et minimiser cela maintenant. Ensuite, nous avons créé un getter for health, ou simplement une fonction qui nous a permis d'obtenir la valeur de notre variable de santé privée. Et il s'agissait de l'encapsuler afin qu'il ne puisse être utilisé que dans les limites que nous avons décidées C'est pourquoi nous avons un getter et un setter pour cela, ainsi que cette méthode de modification que nous venons d'ajouter. Passons donc en revue celles-ci maintenant. Donc, obtenir de la santé ne prend aucun paramètre. Tout ce qu'il fait est renvoyé à l'appelant ou au code qui appelle cette méthode et la fonction OR. renvoient donc un entier parce que notre membre de santé est un entier et qu'il renvoie simplement la santé. Donc, si vous voulez savoir ce qu'est la santé, vous pouvez appeler cette fonction et nous vous la donnerons. Et nous aurions pu ajouter n'importe quel autre code ici, mais c'était juste un caniveau de base que nous avons décidé de créer. Ensuite, nous avons une autre fonction pour définir l'état de santé. Cela permet à la couleur d' insérer la valeur de santé de son choix et nous définirons la santé comme égale à cette valeur. Cependant, nous ajoutons un code supplémentaire pour dire : «  Hé, nous allons avoir une santé maximale et une santé minimale. Donc, si la santé, après avoir été réglée sur ce que l'utilisateur a saisi ici, est supérieure à 100. Hey, on va y aller et remettre ça 200. Et s'il est inférieur à zéro, nous allons le mettre à zéro. Ensuite, nous avons créé cette nouvelle fonction appelée change health, qui permet à la couleur de modifier la valeur de santé, quelle que soit la quantité qu'elle introduit. Ils envoient donc notre fonction ici, un entier et nous ajoutons cette valeur à la santé. Et cela aurait pu être un chiffre négatif ou positif, et il aurait été ajouté. Alors, même chose. Nous avons dit : « Hé, si la santé est maintenant supérieure à 100, nous la ramènerons à 100 et que la santé est inférieure à zéro, nous la mettrons à zéro. Et nous aurions pu ajouter le code supplémentaire que nous voulions ici pour pouvoir imprimer à nouveau à l'état de santé de l'utilisateur. Est-ce Andrew a été remplacé par ceci ou ce que nous voulions, mais nous venons de créer un fonction de base pour changer la santé de quelque manière que ce soit et s'assurer qu'elle ne dépasse pas le maximum que nous voulons et le minimum que nous voulions. Nous aurions pu créer des getters et des setters pour le nom et l'âge également. Mais nous l'avons fait ici pour des raisons de simplicité. Enfin, nous avons une dernière fonction pour notre classe d'animaux, qui permet à n'importe quel objet animal de dire parler, en insérant une chaîne. Et il y imprimera simplement ce son. Et nous pourrions même y revenir et en faire plus dans une vidéo ultérieure. Bref, j'espère que tout cela avait du sens pour vous. Allons-y et passons à notre classe de chiens. Et nous allons simplement ignorer la classe des chats, car elle sera essentiellement la même. Nous avons donc dit que le chien de classe allait hériter de l'animal de classe et que tous les membres dont nous avons hérité, nous voulions laisser exactement la même accessibilité qu'avant. Donc, tous les membres privés sont restés privés. Cependant, nous n'y avons pas accès car les membres privés ne sont disponibles que dans la classe dans laquelle ils ont été créés. Mais nous avons eu accès au public et aux sites protégés, et ils sont restés publics et protégés ici. Et comment se protéger ? L'ensemble du public aurait été protégé. Et comment définissons-nous le caractère privé ? Tout aurait été fait avant cela. Mais n'oubliez pas que nous aurions eu accès à ces variables, à l'exception de celles qui étaient à l'origine privées de l'animal. Donc, par exemple ce que je veux dire par là, c'est que si nous avions dit qu'avant fonction publique sur la santé animale, par exemple aurait maintenant été essentiellement ici ce qui vient de devenir privé. OK. Bref, nous avons simplement laissé les membres travailler. Ensuite, nous sommes allés de l'avant , nous avons parlé en public ici et créé un constructeur pour chiens. Pour ce faire, nous avons dit chien suivi de certains paramètres. Nous avons donc pris un nom et un âge qui correspondent à ceux que notre animal a pris ici. OK. C'est parce que chaque fois qu'un chien est créé, un animal est également créé essentiellement parce qu' un chien est un animal et parce que nous n'avions pas constructeur par défaut qui ne prend rien. Nous avons besoin d'un constructeur qui corresponde au seul constructeur disponible pour anima. Et n'oubliez pas que nous aurions pu créer plusieurs constructeurs pour les animaux et plusieurs pour les chiens, mais nous l'avons fait de cette façon. Je peux m'assurer que chaque fois qu'un Douglas a créé une donnée anonyme et qu' un âge a été donné, nous aurions pu y inscrire autant de choses que nous le voulions. Nous aurions pu inscrire un nom et un âge, une race ou quelque chose comme ça chez notre constructeur d'animaux à Londres. Pareil ici, mais nous l'avons fait de cette façon pour plus de simplicité. Ensuite, nous avons créé une autre liste d'initialisateurs pour appeler le constructeur essentiellement pour animal directement à partir d'ici. Ainsi, quels que soient le nom et l'âge ont été insérés lors de la création d' un chien, seront désormais insérés dans le nom et l'âge de notre constructeur d'animaux. Parce que, comme je l'ai dit, chaque fois qu'un chien est créé, un animal est créé et un animal est créé et nous l'avons fait directement de cette façon. Mais sur le plan technique, comment le souhaitons-nous ? Nous aurions pu ne rien prendre, créer une variable appelée string, name, equal to spot, et juste le père Noël dans notre constructeur d'animaux à chaque fois qu'un chien était créé. Ensuite, nous avons simplement imprimé un tas de trucs. Et cela va de soi. Nous avons déjà travaillé avec des fonctions, d'accord, puis nous avons fait exactement la même chose pour Cat. Évidemment, cette classe s'appelait chat et nous avons dit un nombre incalculable de notes au lieu d'un chien. Qu'est-ce qui est noté ? Enfin, si nous venons ici, nous avons créé un chat appelé mon chat, et nous lui avons donné un nom de Garfield et un chat âgé de deux ans. Ensuite, nous avons imprimé Garfield is health is, puis nous avons utilisé la fonction getter, n'est-ce pas ? Et nous avons pu y accéder directement depuis mon chat parce que c' était un membre du public. Et lorsque nous en avons hérité, public pouvait toujours y accéder de cette manière et obtenir la valeur Santé. Ensuite, nous avons changé cet état de santé parce que c'était également une fonction publique également une fonction publique et nous l'avons imprimé à nouveau lorsque nous avons simplement créé un dark ici-bas. Alors, tu y vas. Juste pour te montrer quelque chose ici. Si je devais aller dans notre cours sur les chats ici et changer animal public pour protéger l'animal et essayer de faire fonctionner notre code. Vous verrez que nous obtenons une erreur. Et c'est parce que maintenant, ces fonctions, en ce qui concerne les chats, parce que c'est la classe avec laquelle nous travaillons , sont protégées, ce qui signifie qu'elles ne seront accessibles à rien autre que lui-même et toutes les classes qui en héritent ou en dérivent. De même, si nous avions dit privé, cela aurait rendu ces fonctions privées en ce qui concerne le chat, et elles n'auraient pas du tout été disponibles ici. OK. Je voulais donc simplement vous montrer comment cela fonctionne là-bas, puisque nous avions un exemple raisonnable à notre disposition. Et maintenant, je le remets au public dans nos travaux de code une fois de plus. Cependant, pour vous montrer une dernière chose à ce sujet, si je remettais cela à protégée ou même privée d'ailleurs, ils ne le seraient qu'en ce qui ils ne le seraient qu'en concerne les cours de chats. Donc, ici, je pourrais toujours dire quelque chose comme animal, mon animal. Donnez-lui un nom. Appelons-le comme Jeff ou quelque chose comme ça à l'âge d'un an. Et notre point-virgule à la fin. Et on peut toujours parler de ma santé animale ainsi. Cela fonctionnera très bien. C'est parce qu'en ce qui concerne un animal, santé est publique, n'est-ce pas ? Et si je commente ce code ici momentanément et que je lance notre code, vous pouvez voir que cela fonctionne très bien. Nous l'avons débarrassé d'un chien, du nom de Spotty, âgé de trois ans et en bonne santé de 100 ans. Ensuite, nous avons également créé un animal. Remarquez cependant que nous n'avons rien imprimé. Et c'est parce que notre constructeur Animal n'imprime plus aucun texte. Et la principale raison pour laquelle nous l'avons fait est que sinon, chaque fois que nous créons un chien ou un chat, non seulement le nom de notre constructeur de chats et de chiens, mais le constructeur d'animaux aurait été appelé Eh bien, lorsque l'on crée un chien ou un chat, on crée un animal. Très bien, et c'est notre seul constructeur disponible. Alors vous l'avez. Et juste pour vous montrer que cela fonctionne, ici, je peux dire que la santé de mon animal et la valeur du pKa sont de 100. Quoi qu'il en soit, je vais continuer, supprimer cela et décommenter ces lignes de code. Et allez-y, changez notre classe de chats ici pour qu'ils héritent d'un animal public, non d'un animal privé. Alors, tu y vas. Tout fonctionne à nouveau. Et je vais également supprimer cette création animale ici. Et je sais que beaucoup de nos exemples précédents fonctionnaient avec un très petit code. Mais maintenant que nous avons appris beaucoup de choses de base et que nous en avons encore beaucoup plus à portée de main. Je voulais créer un programme plus vaste avec vous lentement, au fil d'une poignée de vidéos, juste pour que vous puissiez voir à quoi cela pourrait ressembler dans le processus et comment mettre Tout est réuni, pièce par pièce, ici. J'espère donc que vous les avez appréciés. Quoi qu'il en soit Tu y vas. C'est une sorte de résumé de tout ce que nous avons actuellement et que nous utiliserons dans les prochaines vidéos de toute façon Si vous avez tout compris jusqu'à présent, félicitations. Vous n' aurez aucun problème dans les vidéos à venir. Cependant, pour ceux d'entre vous qui ont des problèmes, ne vous inquiétez pas. Dans la vidéo suivante, je vais prendre tout ce dont nous avons parlé avec les cours et le décomposer forme plus petite ou un exemple pour que vous puissiez le voir et travailler avec. Quoi qu'il en soit, c'est tout pour cette vidéo. Encore une fois, assurez-vous de sauvegarder là où vous en avez. Merci de m'avoir écouté , et à bientôt. 90. 89: Dans cette vidéo, je vais reprendre tout ce que nous avons appris dans les dernières vidéos sur les cours et le décomposer pièce par pièce sous une forme plus basique. Comme je le sais, il se passait beaucoup de choses à l'écran. J'espère donc que cette vidéo vous aidera si vous êtes un peu confus avec tout ce que nous avons eu à faire Cela étant dit, ne supprimez pas le code que vous avez, car nous allons toujours l'utiliser dans vidéos à venir. Donc, si vous voulez suivre, je vous recommande de l'enregistrer lors l'ouverture d'un nouveau projet si vous souhaitez suivre ici. Sinon, vous pouvez simplement regarder ce que j'ai à l'écran et vous assurer de bien comprendre chaque sujet au fur et à mesure. Quoi qu'il en soit, allons-y. Très bien, tout d'abord, allons-y et revenons au début. Comment créer une classe ? Eh bien, disons le cours suivi du nom. Vous pouvez donc dire quelque chose comme animal, puis nous aurons un ensemble de crochets bouclés ouverts et fermés et un point-virgule à la fin. Et vous y voilà. C'est ainsi que vous créez une classe. Ensuite, dans la vidéo suivante, nous avons expliqué comment créer une instance d'une classe. Et bien, comment s'y prendre ? Eh bien, nous disons simplement le nom de la classe suivi du nom de l'objet ou de cette instance de la classe. Je pourrais donc dire animal, mon animal si je le voulais. Il suffit de mettre un point-virgule à la fin. Et maintenant, nous avons créé une instance de cette classe ici. Dans cette instance, a accès à tous les de cette classe et dispose de sa propre version membres et/ou variables de cette classe et dispose de sa propre version. Donc, si nous avons dit nom de chaîne, comme ceci, et pour l'instant, nous allons simplement nous donner une valeur par défaut comme celle-ci. Et maintenant, mon animal ici, ou une instance de notre classe animale ici, a maintenant sa propre version ou instance de ce membre ou de cette variable ici. Et c'est parce qu'il s'agit objet animal son propre objet animal, de sa propre instance ou version de la classe qui le compose. Donc, en bas, nous pourrions dire que mon animal est le nom de cette version, de cet objet ou de cette instance ou quel que soit le nom que vous voulez , et le définir comme point ou comme nous le voulons. Cependant, si vous vous souvenez qu'en ce qui concerne les classes, chaque membre, variable, attribut ou quel que soit le nom que vous voulez donner à la classe, est par défaut privé, ce qui signifie qu'il n'est disponible que à cette classe. Donc, si nous voulons le mettre à la disposition des objets ou des instances de la classe, nous devons en faire une entité publique que nous pouvons simplement dire espace deux-points public comme ça. Et nous y voilà. Maintenant, tout ce qui se trouve en dessous sera un membre public. Et si nous voulions créer des membres privés, nous allons simplement dire quelque chose comme ça et nous pouvons mettre tout ce que nous voulons en dessous. Et ceux-ci ne seraient disponibles que pour la classe. Et puis il y a un dernier spécificateur d' accès appelé protected, dont les membres protégés ne sont disponibles que pour la classe et pour toutes les sous-classes ou classes qui en héritent. Et nous y reviendrons dans une minute. Le nom est donc public. Nous pouvons dire que le nom de mon point animal est maintenant égal à spot parce que mon animal a sa propre version de cette variable de nom dans, nous pouvons le prouver en procédant comme suit et en créant un autre animal et en l' appelant mon animal tuer. Disons que mon animal est égal à Salomon. Et si vous l'avez remarqué, nous l'utilisons comme n'importe quelle autre variable, sauf que nous devons spécifier à laquelle nous faisons référence puisque chacune a sa propre instance. Et puis ci-dessous, les deux seront imprimés. Dites donc C sur le nom de mon alimentation animale. Et puis nous dirons CL, nouvelle lignée, mon animal pour moi. Et comme je l'ai dit, parce que chacun d'eux a son propre nom. Le nom de mon animal est Spot et nom de mon animal 2 est Solomon. Alors, tu y vas. L' autre chose dont nous avons parlé était de créer une méthode dans une classe. Et je vais simplement vous montrer la bonne façon de procéder. Permettez-moi donc de retirer notre deuxième animal et d'imprimer le nom ici. Très bien, maintenant, nous avons juste notre classe que nous avons créée détenue par une chaîne publique afin que les objets soient des instances de cette classe, aient accès à cette variable. Maintenant, souvenez-vous qu'ils en auront chacun leur propre instance. Et puis nous n'avons pas de variables ou de fonctions privées , mais nous avons également un espace pour cela ici. Jusqu'à présent, nous n'avons fait que créer un animal appelé mon animal et changer son nom en spot ou en son instance de la variable name. OK, alors maintenant, comment créer la méthode de classe ? Eh bien, tout d'abord, nous créons quelque chose qui ressemble beaucoup à un prototype de fonction parce que c'est fondamentalement la même chose. Nous allons donc dire quelque chose comme des parenthèses vides, ouvertes et fermées et un point-virgule à la fin. Juste comme ça, rappelez-vous qu' à l'intérieur de votre classe, vous ne voulez que vos déclarations et en dehors de votre classe, vous voudrez mettre vos définitions. C'est la bonne façon de faire les choses. Comme je l'ai dit par le passé. Cela vous aidera à transférer notre classe ici dans un en-tête et un fichier CPP. Et cela ne fait que rendre les choses plus claires et nous y reviendrons dans une vidéo ultérieure. Mais pour l'instant, ne vous inquiétez pas. Allons-y et passons à la création de cette fonction. Donc, ce que nous avons ici, nous allons créer le corps réel ou la définition de la fonction. Et on va juste dire « C ». Mon nom est un espace deux-points comme ça. J'ai reçu la ligne après. Ensuite, pour spécifier que cette fonction nous venons de créer dans le cadre de cette classe animale, nous allons simplement copier le nom de la classe et le placer juste avant le nom de notre méthode. Ensuite, nous insérons l'opérateur de résolution de la lunette juste là. Nous avons maintenant déclaré et défini une fonction dans notre classe. Et à cause du public, notre objet d'une classe ou d'une instance de celle-ci y a également accès maintenant. Et en fait, ici, nous voulons aussi imprimer le nom. Supposons que mon nom soit suivi d'un nom et ensuite, d'accord, donc ici, nous avons créé une instance de notre classe animale, changé la version de la variable name. Ensuite, nous allons simplement dire le nom de mon empreinte animalière, juste comme ça. Ouvrez et fermez des parenthèses et un point-virgule à la fin, car nous l'appelons comme nous le ferions pour n'importe quelle autre fonction. Et si nous exécutons notre code ici, vous y êtes. Je m'appelle Spot. Et une autre chose dont nous avons parlé, c'est que ce type d'animal fonctionne comme n'importe quel autre type. Vous pouvez donc réellement prendre cela comme paramètre. vite, allons-y, supprimons cette fonction animale et réchauffons-la ici aussi. Maintenant, nous n'avons plus qu' une variable ici, n, ou déplacez cette ligne là. Ensuite, je vais juste dire « nom nul ». Et entre parenthèses, il y aura un animal, un animal. Alors, ici, je vais avoir un bloc de code et je vais dire CL. Je m'appelle One Space. Je vais imprimer le nom de l'animal. Nous allons donc dire le nom du point animal parce que cela crée une copie de tout ce que nous transmettons, cette valeur sera la même que celle que nous transmettons. Donc, là-haut, je peux dire le nom d'impression, puis les parenthèses. Je peux insérer mon animal comme ça et mettre un point-virgule à la fin. Et nous avons besoin d'un prototype de fonction là-haut. Je vais donc simplement copier cela. Je prends ça et je mets un point-virgule à la fin. Et si je lance mon code ici, et vous voilà, nous imprimerons mon nom, mais vous pouvez aussi l'utiliser comme type de retour. Nous pouvons transmettre cela par référence, etc. Vous pouvez donc l'utiliser comme vous le feriez pour n'importe quel autre type. La seule différence est que ce type est défini par l'utilisateur. Nous l'avons créé, essentiellement nous-mêmes, accord, parce que nous avons défini ce qu'est un animal. D'accord, de toute façon, donc je vais m' en débarrasser. Euh, ouais. Nous n'avons donc que ces quelques éléments de base ici. Ensuite, nous avons parlé des constructeurs, qui ne sont que des fonctions spéciales qui s'exécutent automatiquement. Lorsqu'une instance de la classe est créée. Par défaut, vous en avez un qui ressemble à cela. Et d'ailleurs, tous les constructeurs doivent y être publics à titre de rappel. Le constructeur par défaut ressemble donc à ceci. Animal étant le nom de la classe, ouvertes et fermées et parenthèses bouclées ouvertes et fermées. Et si vous créez votre propre constructeur, celui-ci n'existe plus. Et vous pouvez avoir plusieurs constructeurs vous permettant de le surcharger de plusieurs manières tout comme vous pouvez surcharger des fonctions. Et en n'ayant que deux constructeurs, vous le surchargez. Chantez car le nom est identique au nom de la classe. Très bien, alors allons-y et créons un constructeur. Et nous allons simplement commencer par créer une copie de la version par défaut. Je vais donc juste dire quelque chose comme ça. Et vous y voilà. Nous avons maintenant un constructeur par défaut. Si nous voulions le faire correctement, nous pourrions le déclarer ici et ensuite la limite finie. Eh bien, n'oubliez pas que nous devons enregistrer ce que cette petite partie f. Donc, nous allons dire animal tenu par l'animal opérateur de résolution de la lunette, puis nos crochets bouclés. Voici donc notre constructeur par défaut. Et c'est ce qui nous permet de créer un objet ou une version d'un animal sans avoir à prendre de paramètres. Et c'est parce que cela n'en prend pas, mais nous pouvons créer un autre constructeur qui le fera. Et puis, avant que j'oublie, souvenez-vous que chaque fois que nous avons une variable membre de la classe, nous voulons juste mettre un trait de soulignement avant le nom, juste pour que nous sachions, hé, c'est un membre de la classe tout en le modifiant ici aussi. Et comme je l'ai dit, nous pouvons aller de l'avant et surcharger ce constructeur ici. Je viens de créer un autre constructeur. Et celui-ci sera comme vous l'appelleriez, un constructeur paramétré. Parce que cela va prendre certains paramètres. Donc, ici, nous allons dire l'animal. Et puis entre parenthèses, nous dirons chaîne, couleur. Comme ça. Nous ne mettons pas de point-virgule à la fin. Ensuite, nous allons créer la définition de cette enveloppe. Je vais juste le copier et le coller ici. Ensuite, nous aurons nos crochets frisés pour le bloc de code. Ensuite, on dira « C ». Une couleur conductrice de l'espace. L'animal spatial a été créé exactement comme cet animal. Mettez un point-virgule à la fin et nous devons spécifier où vient ce constructeur ou à quoi il sert. Nous allons donc dire animal avant cela, suivi de nouveau de l'opérateur de résolution de la lunette. Alors, tu y vas. Nous avons maintenant un autre constructeur. Et maintenant, si nous voulons utiliser celui-ci au lieu de ceux par défaut, je vais simplement effacer tout ce code. On peut dire animal. Animal. Entre parenthèses, nous allons mettre une chaîne. Je dirais donc personnellement qu'il faut mettre un point-virgule à la fin. Et si je lance le code ici, je dirais qu'un animal bleu est créé. Et c'est parce que c'est le code qui s'exécute lorsque nous avons créé cet animal, puisque ce sont les paramètres que nous avons utilisés et qu' une autre utilisation d' un constructeur ou l'une des principales utilisations de celui-ci est de assurez-vous que votre classe est prête à être utilisée. Ce que je veux dire par là, c'est que vous voulez vous assurer que tout a une valeur initiale. Comme d'habitude, vous ne devez pas le faire ici, toutes vos déclarations ici et vos définitions ici. Très bien, alors quelle est la meilleure façon de donner un nom et une valeur initiale à notre constructeur ? Eh bien, juste après les parenthèses, nous allons dire deux-points, nom du trait de soulignement entre parenthèses mettra la valeur. Nous allons donc juste dire guillemets et nous n'y mettrons rien. Et nous ferons de même ici, sauf qu' ici, nous allons dire le nom en trait de soulignement. Et puis entre parenthèses, nous allons dire nom. Et pour obtenir cette valeur ici, nous allons simplement ajouter un autre paramètre. Nous allons donc dire chaîne, couleur, chaîne. Nous devons nous assurer de l'ajouter à notre déclaration de cette méthode ici. Nous avons donc créé un autre constructeur qui prend une chaîne pour la couleur et une chaîne pour le nom. Et il va insérer le nom que nous avons mis dans notre variable de nom. La raison pour laquelle j'ai eu cette erreur ici est parce que je n'avais tout simplement pas ce deux-points juste là. Et voilà, tu l'as trouvé ici. Nous avons reçu une erreur car nous n'avons plus constructeur qui ne prend qu'un seul paramètre. Et si je le supprime et que je le mets à nouveau entre parenthèses ouvertes, je verrai mes différentes options Let's do. Et il dit que j'ai besoin d'une couleur et d'un nom, ou je ne pourrais rien faire puisque nous avons ce constructeur par défaut. Donc, comme je l'ai dit, le but principal du constructeur est de rendre votre classe prête à être utilisée en initialisant tous les membres qu'elle contient. Ensuite, vous pouvez également avoir n'importe quel code que vous souhaitez exécuter. Une instance de votre classe est créée à l'aide de ce constructeur. Comme je l'ai dit, la meilleure façon de l'initialiser est d'utiliser une liste d'initialisateurs. Et tout ce que vous avez à faire est de dire deux-points suivis la variable et de la valeur que vous souhaitez lui donner entre parenthèses. Et si nous avions plus d'une variable, nous dirions une virgule. Ensuite, mettez-le dans l' autre nom de variable, puis mettez cette valeur et des parenthèses. Et n'oubliez pas qu' ils doivent être en ordre de haut en bas, et il vous suffit d'aller de gauche à droite ici. Je vais donc simplement continuer et supprimer cela puisque nous n' avons qu'une seule variable. Et vous y voilà. Maintenant, je peux y aller et mettre une couleur. Je pourrais donc redire bleu. Ensuite, notre nom sera spot. Maintenant que nous en avons terminé, nous pouvons dire qu'un animal bleu a été créé, nommé par son nom. Et nous y voilà. Si je lance mon code ici, cela devrait indiquer qu'un animal bleu a créé un endroit nommé spot, et c'est ce qu'il fait. Ensuite, nous avons également parlé de l'encapsulation. Alors allons-y et jetons un coup d'œil à cela. En gros, pour le moment, je peux jouer avec ma variable de chaîne. Je pourrais dire le nom de mon animal en trait de soulignement et le définir comme je le voulais. Et rien ne peut m'arrêter. Et cela peut sembler peu important ici, mais croyez-moi, vous ne voulez pas que vos membres soient publics. Si vous pouvez l'éviter, vous devez tout avoir dans une fonction getter et setter, que nous aborderons ici dans un instant afin que vous puissiez définir règles supplémentaires et mettre un code supplémentaire chaque fois que quelque chose veut modifier une variable. Et si vous décidez d'en faire quelque chose plus tard, votre code est désormais plus dynamique car vous n'avez qu'à regarder ces deux fonctions plutôt que d' essayer de trouver partout où trouvait cette variable ajusté. Alors allons-y et changeons-les. Tout d'abord, nous allons prendre notre variable de chaîne ici et la placer sous private ici. Alors maintenant, c'est un membre privé, c'est ce que tu veux. Ensuite, ici, nous allons créer deux fonctions pour un getter et un setter. Et avant de le faire, je vais juste aller l'avant et minimiser cela ici. Ce n'est donc pas notre chemin. Nous allons donc dire set name comme nom de la fonction, et nous allons mettre un point-virgule à la fin, et cela prendra un nom de chaîne. Ensuite, nous allons dire GetName en bas. Et cela ne prendra rien. Cependant, il renverra une chaîne. Et celui-ci ne vous rapportera rien. D'accord, nous allons donc dire void, setName, string name et String getName. Et ça y sera. Ensuite, il créera les définitions pour ces deux éléments ci-dessous. Donc, si je copie celui-ci ici et que j'ajoute notre bloc de code, le code le plus élémentaire pour un setter serait de faire ce qui suit. Je dirais que le nom de soulignement est égal à nom. Et maintenant, cela permettra à tout ce qui appelle cette fonction de modifier cette variable privée. Ensuite, nous ferons de même avec notre méthode getName ici. Ou la fonction créera la définition ici, comme ceci. Et nous allons dire le terme souligner le nom. Ensuite, nous devons nous assurer de préciser que ces deux fonctions font partie de notre classe animale. Nous allons donc dire animal suivi de l' opérateur de résolution de la lunette sur les deux. Et évitez de devoir venir avant cela. Exact, parce que ça va se placer juste avant le nom de la méthode et la chaîne transparente. Donc je vais passer de l' autre côté, non ? Et si nous exécutons notre code maintenant, les animaux bleus ont créé le nom spot, donc tout fonctionne toujours. Et puis ici maintenant, si je veux changer de nom, je dois dire setName dans mon animal et y mettre une valeur de chaîne, comme Solomon, par exemple mettre un point-virgule à la fin. Vous vous demandez peut-être : « En quoi est-ce différent ? Eh bien, actuellement, ce n'est pas très différent si ce n'est que c'est la bonne façon de faire les choses. Mais si je l'avais à 100 endroits différents de mon code où je changeais le nom ou n' importe quelle variable c'était encore et encore. Et c'est moi qui décide, tu sais quoi ? Je vais aller de l'avant et imprimer, hé, le nom a été changé quand je ai changé à 100 endroits. Mais comme j'ai le centre ici, je peux simplement dire le nom de soulignement CL. L'espace a été modifié pour donner un nom comme celui-ci et créer une nouvelle ligne. Et puis, ici, c' est essentiel pour l'avion. Et si je lance mon code maintenant, il indiquera que j'ai appris le nom le plus créatif , puis Spy, qui est devenu Solomon. Ok, alors tu y vas. C'est pourquoi un getter et un setter sont utiles et importants. Surtout si je l'ai eu à plusieurs endroits. Maintenant, je n'ai pas à m'en occuper. Je peux juste regarder ici et changer mon truc juste là. Donc, si je me retrouvais avec une sorte d'erreur en le modifiant, tout ce que j'ai à faire est de regarder mon code ici et de voir ce qui en est la cause. Plutôt que de regarder les cent endroits où j'ai déconné. Et je peux avoir des restrictions Voici du code pour mettre la première lettre en majuscule ou faire en sorte le nom ne contienne dix caractères ou ce que je voulais faire, n' est-ce pas ? Alors, tu y vas. C'est ainsi que vous créez un setter et un getter de base. Et ce que nous avons fait ici où nous avions la fonctionnalité de notre variable privée dans ces fonctions publiques s' appelle l'encapsulation. Et la toute dernière chose dont nous avons parlé s'appelait l'héritage. Alors laissez-moi commencer et supprimer tout ce qui se trouve ici très rapidement. Et dites ce qui suit. Disons animal de classe sur mon bloc de code, et je vais dire nom de chaîne, et je dirai aussi âge, juste comme ça. Chaque animal aura donc un nom et un âge. N'oubliez pas qu' ils sont tous les deux privés, donc c'est exactement la même chose que de dire en privé. Et c'est parce que les membres d'une classe sont privés par défaut. Donc, juste comme ça. Ensuite, nous allons créer une classe qui hérite de notre classe d'animaux. Ce sera donc la classe de base et la classe qui en héritera sera la sous-classe. Donc, en bas, je vais dire chien de classe, par exemple hériter d'un animal. Et j'ai besoin d'un spécificateur d' accès ici. Et dans ce cas, nous allons dire public. Et en gros, si vous vous souvenez, si je dis public, écoutez que tout ce qui était public sera transféré au chien et sera public. Tout ce qui était protégé sera transféré au chien et sera protégé, ainsi que tout ce qui était privé. Eh bien, ce n'est pas accessible en dehors de cela, donc peu importe si je disais protégé, tout ce qui était public serait transféré et protégé. Tout ce qui était protégé serait transféré pour rester protégé et tout était privé. Eh bien, peu importe, je ne pouvais pas y accéder de toute façon. Et ensuite, si je disais privé, tout ce qui ne l'était pas déjà serait transféré et deviendrait privé. Quoi qu'il en soit, allons-y et mettons du code ici. Et en fait, je vais changer le spécificateur d'accès avec nous pour le protéger afin que le chien ait accès à ces variables. Et il ne s'agit évidemment que d'un exemple très élémentaire. Ne prenez donc pas ce que je fais ici pour vous expliquer comment créer des choses. Je veux juste vous montrer l'utilisation de base de l'héritage. Et n'oubliez pas que nous pouvons hériter de plusieurs classes en les suivant par une virgule. On pourrait dire public , puis un autre nom de classe et d'autres classes qui héritent du chien, non ? Ensuite, en bas, allons-y, cliquons avec le bouton droit de la souris, créons une variable publique par souci de simplicité, et ajoutons une brève. Ainsi, chaque animal aura un nom et une variable d'âge, et chaque chien aura une variable de race en plus de celles-ci ici. OK ? Et maintenant, nous pouvons dire , d'accord, nous allons créer un nouveau chien. Mon chien, juste comme ça. Et comme ceux-ci ont tous deux un constructeur par défaut, je n'ai pas besoin de paramètres ici. Et si vous voulez en savoir plus à ce sujet, revenez simplement à la dernière vidéo où nous avons parlé de l'héritage et approfondissez. Ensuite, allons-y et créons quelques constructeurs pour initialiser toutes ces valeurs. Et en fait, je vais juste le rendre privé. Et je m'excuse. J'ai oublié de mettre un trait de soulignement sur tous les noms de nos membres ici. Alors allons-y et faisons-le. Eh bien, pour initialiser cela, il suffira de créer quelques constructeurs. Nous allons donc dire animal. Et celui-ci prendra une chaîne, un nom et un âge. Et nous allons mettre la définition ci-dessous. Et nous allons préciser que dans cette partie de la classe, nous aurons notre bloc de code comme ça. Ensuite, après nos parenthèses, nous allons simplement dire le nom du trait de soulignement à deux points. Et puis entre parenthèses, vous allez insérer le nom. Dites que la virgule souligne l'âge, puis les parenthèses insèrent l'âge. Ensuite, j'ai juste voulu les ajouter. Nos crochets bouclés sont comme ça , juste pour que ce soit à l'écart. Ensuite, nous pouvons créer un constructeur très similaire pour chien, sauf que nous allons y ajouter. Et n'oubliez pas que nous devons créer notre constructeur ici, public Jose Public colon comme ça. Et juste pour le rendre un peu plus beau. Et puis, ici, pour notre chien, allons créer un constructeur. Mais avant cela, nous allons dire pièce privée comme ça pour garder notre ficelle. Ensuite, nous allons créer un constructeur. Nous dirons donc que les parenthèses dog et m prendront une chaîne pour le nom, pour l'âge et une chaîne pour le brief. Ensuite, nous allons créer la définition ci-dessous. Et n'oubliez pas que nous devons spécifier le front de Liz dans la classe des chiens. Et je vais juste entourer quelques crochets bouclés comme ça. Ensuite, nous ajouterons notre liste d'initialisateurs. Ensuite, parce que chaque fois qu' un chien est créé dans, un animal est créé, puisque nous en dérivons, nous devons également utiliser ce constructeur lorsque nous utilisons notre seul constructeur de chiens ici. Donc, pour ce faire, nous allons dire animal, côlon, animal du côlon. Et puis entre parenthèses, nous allons dire nom, virgule H et ainsi de suite. Et nous disons que nous faisons référence à vous en tant que membre de la classe Animal. Ensuite, nous voulons le constructeur Animal. Et nous allons insérer ces deux valeurs ici, c'est ce que prend notre constructeur d'animaux. Ensuite, nous pouvons ajouter notre race à initialiser après cela, des constructeurs et des virgules soulignent brièvement. M parenthèses inséreront le brief, et tout cela fonctionnera très bien. Ensuite, il ne vous reste plus qu'à modifier notre déclaration ou la création de notre objet pour chien. Donc on va dire chien, et ensuite je l'appellerai mon chien. Et entre parenthèses, vous pouvez voir que nous avons maintenant besoin de trois valeurs de constructeur correspondant au nom. Nous l'appellerons donc spot, suivi de son âge. Donc, nous allons juste dire quelque chose comme deux. Ensuite, nous allons suivre cela avec une race. Nous pouvons donc dire boxer ou quelque chose comme ça et mettre un point-virgule à la fin. Et tout cela fonctionnera très bien. Et nous pouvons soit tout imprimer ci-dessous, soit mettre le code pour l'imprimer à l'intérieur de notre constructeur de chiens. Et cela fonctionnerait aussi. Et n'oubliez pas que ces deux constructeurs sont en cours d' exécution lorsque nous le créons ici. Et juste pour vous montrer que si j'ai dit CL, espace du côlon animal, et ensuite ici si je sous-appelle chien, comme ça et que je lance le code, vous pouvez voir que nous avons imprimé animal et chien. Et c'est parce que ces deux constructeurs sont en cours d'exécution. Parce que lorsqu'un chien est créé, un animal qui est créé. Et nous avons juste le seul constructeur ici qui prend trois valeurs. Deux d'entre eux sont utilisés comme constructeurs d' animaux, puis nous avons ajouté une race. Très bien, alors voilà. Il s'agit d'un exemple de base de la manière d'utiliser l'héritage. chien a désormais essentiellement accès aux choses de cet animal, ainsi qu'à celles du Sud. Et pour faire comprendre ce point très rapidement, un animal créera une méthode publique appelée crier. Et nous allons créer la définition ci-dessous. Je vais donc les copier ici. Dites Chow et précisez que cela vient d'un animal. Et à l'intérieur de nos crochets frisés ici, et nous dirons étagère vide, d'ailleurs. On dira qu'il n'y a pas de refuge pour animaux, comme ça. Et puis, à l'intérieur, on va juste dire bonjour. Et comme le chien provient d'un animal, il peut utiliser cette fonction, autant plus qu'elle est publique. Alors maintenant, juste en dessous, je pourrais dire que mon chien est mort, crie. Si nous exécutons un code, vous pouvez voir qu'il fonctionne très bien. Nous le crions haut et fort. Bonjour. Et je vais supprimer l' impression « chien et animal » ici. Déjà. J'ai bien compris ce point. Et je le dirige à nouveau pour toi. Et comme vous pouvez le voir, il ne fait que dire bonjour. Et même si notre méthode existait, notre fonction était protégée. Ainsi, nous y aurions eu accès au sein de la classe elle-même. Donc, si je supprime cette ligne de code ici et à l'intérieur de notre constructeur, par exemple, j' aurais pu utiliser un shell. Ainsi, le code avec interclass aura accès à cette variable de protection puisqu'elle est disponible pour la classe et pour tout ce qui en dérive. Donc je peux dire criez ici, maintenant allez-y et déplacez ça juste pour que ce soit un peu plus lisible pour vous et exécutez notre code. Et maintenant, lorsque nous créons un chien, il crie bonjour. Et nous aurions pu mettre cela dans une fonction ou quelque chose pour notre chien également. Et cela aurait tout aussi bien fonctionné. Et si nous avions eu d'autres variables ou fonctions protégées ou publiques, nous y aurions eu accès dans le code de notre classe de chiens. Donc, juste pour vous montrer un exemple, je pourrais dire x et puis ce n'est pas un excellent exemple de la façon de les utiliser. Mais vous comprendrez le point ici. J'aurais pu dire quelque chose comme x est égal à dix et ensuite l'imprimer sur la ligne. Et si j'avais exécuté mon code, il aurait bien fonctionné parce que notre classe ici a accès au code. Cependant, même si le code a accès à un ici, nous n'aurions pas été en mesure de dire quelque chose comme mon chien, x est égal à dix, par exemple cela n'aurait pas fonctionné, mais cela aurait été le cas si c' était public. Tu y vas. Le code fonctionne très bien, ou nous pouvons même l' imprimer comme ceci. Et cela fonctionnera également. Alors laisse-moi partir quand même. J'espère que cette vidéo vous a un peu aidé si vous obteniez un gros découpage et tout le code supplémentaire que nous avions à l'écran auparavant. Merci de m'avoir regardée, et je te verrai dans la prochaine. 91. Chapitre 15 (cours) : mot-clé statique: Dans cette vidéo, nous allons examiner le mot clé statique dans C plus plus. Le mot-clé static peut désormais être appliqué à des éléments tels que des variables, des fonctions et des objets. Et ce qu'il fait exactement va changer en fonction de ce à quoi il est connecté. Et j'examinerai brièvement quatre exemples différents de comment, quand et comment ils pourraient être utilisés sorte que si jamais vous deviez le voir à l'avenir, vous n'auriez aucune idée de ce qu'il est aujourd'hui d'une manière générale ou générale. Bien que vous puissiez penser que le mot clé statique est désormais permanent et en sera la seule copie, tout ce à quoi il est lié . Et nous allons voir exactement ce que je veux dire par là dans un instant. Alors commençons par examiner le mot clé static lorsqu'il est utilisé sur des variables et des fonctions. Comme vous pouvez le voir ici pour la définition ou la façon dont cela fonctionne, j'ai essentiellement dit que cela crée une copie permanente et unique d'une variable. Alors allons-y et créons simplement une fonction au-dessus de la principale pour en voir un exemple. Donc ce que nous allons faire c'est dire Boyd, compter le temps, dram, comme ça, ouvrir et fermer des parenthèses. Et nous allons créer le bloc de code à l'intérieur. Nous allons dire statique. À l'université, je le mets à 0, puis en dessous, je dirai I plus, plus comme ça. Et puis à l'intérieur, allons-y également et imprimons. Mettez-le donc sur une nouvelle ligne à chaque fois. Et puis, ici, dans notre fonction principale, nous allons simplement appeler cette méthode cinq fois. Ensuite, je vais simplement commenter notre autre code ici. Pour l'instant. Nous allons juste arriver comme suit. Lorsque notre méthode sonne pour la première fois ici, elle va exécuter et créer une variable entière statique appelée i et la mettre à 0. Et si vous vous souvenez, j'ai dit que cette variable sera désormais permanente et sera la seule copie de cette variable. Et ce que cela signifie, c'est que lors de sa première exécution, il le créera et le mettra à 0. Et comme elle est statique, ce sera la seule copie de notre variable entière appelée i dans le champ d'application ici. Nous ne pouvons donc toujours pas dire quelque chose comme si j'étais égal à dix ici sans avoir d'erreur parce que c'est toujours dans ce cadre. Ensuite, il va imprimer I, qui sera 0, puis augmenter I d'un. Normalement, s'il ne s'agit pas d'une variable statique, elle créera une nouvelle variable appelée I. Chaque fois que cette méthode est exécutée, affiche 0 augmente d'une unité. La prochaine fois, créez un autre entier appelé Die set égal à 0, imprimé et cristallisé par un et ainsi de suite. Et nous obtiendrions toujours le même résultat. Et si nous avons exécuté notre code sans le mot clé statique ici rapidement, vous pouvez voir que c'est le cas. Donc, juste là, nous avons imprimé 05 fois depuis que nous avons appelé la méthode cinq fois. Mais si nous mettons du statique ici et que nous nous souvenons que tout est en minuscules. Et avant le type de données, lorsque nous exécutons notre code maintenant et qu'il augmente en fait d'un à chaque fois. Et c'est parce que lorsque nous appellerons à nouveau notre méthode, parce que j'ai déjà été créée après la première utilisation, elle utilisera simplement la même variable. Donc, essentiellement la deuxième fois, cette première ligne sera ignorée. L printout, je l'augmente d'une unité. Et puis quand elle reviendra autour de L, ignorez à nouveau cette ligne car I est déjà créée et il n'y en aura qu'une seule copie. Donc, chaque fois que nous appelons cette méthode maintenant, cette déclaration et cette initialisation sont ignorées et nous allons l' imprimer puis l'augmenter d'une unité. Alors, tu y vas. C'est ainsi le mot clé static fonctionne avec les variables des fonctions. Il crée une copie permanente et unique de la variable. Et vous vous demandez peut-être et si nous faisions quelque chose comme ça et exécutions un code ? Eh bien, maintenant que seule cette ligne supérieure sera ignorée là où elle a été déclarée, je serai définie sur 0 à chaque fois, puis elle affichera 0. Donc, si vous voulez faire quelque chose comme ça, vous devez l'initialiser sur la même ligne afin que cela puisse être ignoré à l'avenir. Par tous les moyens, nous pouvons supprimer cette fonction maintenant, supprimer les appels à celle-ci, et passer à ce deuxième cas d' utilisation pour static, qui contient des variables dans les classes. Et cela crée une variable permanente qui est partagée entre tous les objets de cette classe. Donc, ce que je vais faire, c'est décommenter notre code ici comme ça. Ensuite, nous pourrions le mettre dans classe des chiens, des chats ou des animaux, et cela fonctionnerait tout de même. Alors allons-y et mettons-le dans notre classe de chiens ici. À titre d'exemple, ce que nous allons faire, c'est dire statique. Je mettrai un point-virgule à la fin. Et ensuite, ce que nous devons faire pour initialiser cela ici, je dis statique. Et puis chien étant le nom de la classe, deux-points, deux-points ou l'opérateur de résolution de la portée. Et puis dites « I », mettez-la à 0, par exemple. Et nous allons effectivement supprimer le mot clé statique cette deuxième fois. Donc, nous allons simplement dire le côlon du chien, le côlon I est égal à 0. Nous prenons cette variable entière statique, que nous avons déjà créée. Et nous n'avons pas besoin d'utiliser le mot clé static après ce point. Ensuite, nous l'initialisons en dehors de la classe en disant int étant le type détenu par le nom de la classe avec l'opérateur de résolution de portée, puis le nom de la variable, en la mettant à 0. Il suffit donc de noter ici qu'après avoir créé la variable, vous n'avez plus besoin d'utiliser le mot clé static pour y faire référence à l'avenir. Et la seule raison pour laquelle nous utilisons anterior est simplement à cause de la façon dont cette variable est initialisée lorsqu'elle est placée dans une classe. C'est une variable statique, et c'est la façon de procéder. Mais normalement, nous pouvons simplement nous y référer car je suis une fonctionnalité. Et nous allons simplement le rendre public afin de pouvoir facilement voir comment cela fonctionne. Donc, ici, nous avons déjà un objet ou une instance de notre classe de chiens appelée my dog. Et allons-y, sauvegardons mon point et mettons-le à cinq. Alors créons un autre chien, le mien aussi. Et nous allons simplement lui donner un nom comme Sparky et lui donner un âge de deux ans, par exemple. Ensuite, nous allons imprimer mon chien pour voir comment mon chien aussi. Et nous allons le mettre sur une nouvelle ligne, comme ça, ou créer une nouvelle ligne après, je dois dire. Et si nous exécutons notre code, vous pouvez voir qu'ici, mon chien à mourir avait cinq ans. Et c'est parce que cette variable entière statique , telle qu'elle est écrite ici, est une variable permanente qui est partagée entre tous les objets de cette classe. Peu importe le nombre instances de la classe que nous créons, elles partageront toutes la même variable. Donc, si nous devions dire que mon chien à moi plus est égal à cinq et ensuite imprimer mon chien. J'en aurais dix et je vais vous le montrer maintenant. Donc, si je disais mon chien, deux points plus égale, eh bien, nous avions initialement dit que j'étais égal à cinq et maintenant nous venons d'augmenter de cinq. Et comme ils partagent exactement la même variable, si nous imprimons mon chien, j'en imprimerai dix. OK. Alors, tu y vas. Comme je l'ai dit, nous aurions pu mettre, j'ai créé cette variable statique dans animal ici. Et alors, non seulement chaque instance de chat aurait partagé cette variable puisqu'il s'agit d'un animal. Mais chaque instance que le chien aurait, en plus de chaque instance d'animal, nous en aurions créé deux. Donc, tout ce qui est un animal aurait partagé cette variable. Pour que tu aies, de toute façon, je vais aller de l'avant et retirer ça du chien ici. Et nous supprimerons également ce code supplémentaire. Passons maintenant au troisième cas d' utilisation de la variable statique. Donc, si je crée un objet de classe statique, il crée une copie permanente et unique de cet objet. Et le moyen le plus simple de vous le montrer serait probablement de créer une autre fonction. Donc, ici, nous allons dire vide, créer un objet, ouvrir et fermer des parenthèses. Ensuite, nous aurons nos crochets bouclés comme ça à l'intérieur. Nous allons créer un chien appelé mon chien. C'est plutôt triste. Ensuite, nous lui donnerons un nom. Nous allons donc dire étincelant et lui donner un âge similaire. Ensuite, on dira que mon chien est mort, qu'il a changé de santé. Et nous dirons que moins cinq sont considérés comme une valeur de moins cinq. Ensuite, nous publierons que mon chien est en bonne santé, comme ça. Et nous allons l'imprimer sur un angle. Mon chien intérimaire ne reçoit pas d'aide. Line, juste comme ça. Ensuite, nous allons appeler cette fonction plusieurs fois. Et notre méthode principale. Maintenant, quand notre code s'exécute et qu'il arrive à cette fonction, L, crée un chien, mon chien, et donne-lui le nom sparky et un âge de deux ans. Ensuite, nous allons dire que mon chien temporaire change de santé moins cinq, ce qui va changer sa variable de santé, qui, si vous vous en souvenez, a une valeur par défaut de 100 et puis ça va pour imprimer 95. Ensuite, la prochaine fois, il ignorera cela. Si nous rendons cela statique ici, c'est-à-dire que nous disons qu'un chien comme ça, la prochaine fois, il l'ignorera, comme il l'a fait avec la variable statique que nous avions dans une fonction, parce que mon chien temporaire déjà été créé et qu' il ne peut y en avoir qu' une seule copie et qu'il est permanent , puis nous allons réduire son état de santé que j'ai eu à nouveau et l'imprimer. Donc, si nous exécutons notre code ici, vous pouvez voir qu'il est réglé à 95 mois parce qu' il a commencé 100 soustractions 05 imprimées par 100 soustractions 05 imprimées et ensuite il va baisser de cinq à chaque fois que nous l'appelons. Et puis, juste pour vous montrer que cela ne s'est produit qu'à cause du mot clé statique, si nous le supprimons et que nous exécutons notre code, vous verrez que notre constructeur de chiens va réellement courir quatre fois. Donc, après que le corps de notre chien a été créé pour la première fois ici, nous avons lancé cette fonction qui a créé un nouveau chien appelé Sparky H2, imprimé sa santé. Et puis, ici, après l'avoir soustrait, sa santé et l'avoir imprimé à nouveau. Et puis nous avons fait la même chose plusieurs fois. Alors la prochaine fois et relisez ce code, créditez à un autre chien appelé Sparky H2 Health un 100 imprimé à nouveau, H2 Health un 100 imprimé à nouveau, et ils repartent et répètent sans cesse. Ainsi, lorsque nous ajoutons du statique ici, toute cette ligne est ignorée. Donc, avec cette statique, cela en crée une copie permanente et unique. Et chaque fois que cette ligne fonctionne à nouveau, elle le fait. Alors, tu y vas. Les objets de classe statiques et les variables statiques des fonctions fonctionnent de la même manière. Passons maintenant à un autre cas d'utilisation pour cela. Il s'agit de fonctions statiques dans les classes. Mais avant cela, allons-y et supprimons ce code ici ainsi que la fonction elle-même. Très bien, alors allons-y et examinons maintenant les fonctions et les classes statiques. Donc, si nous passons à notre classe animale ici, par exemple, et à l'intérieur du public, nous créerons une fonction statique. Nous pouvons le faire comme ça. Nous allons dire statique, vide, imprimer, bonjour, ouvrir et fermer des parenthèses et un point-virgule à la fin. Ensuite, nous le définirons ici juste à titre de bonne pratique. Nous allons donc dire animal, deux-points, bonjour, parenthèses ouvertes et fermées. Ensuite, nous allons créer le bloc de code ici. Ensuite, avant l'animal, nous devons encore dire « évitez cela », car c' est notre déclaration de retour. Encore une fois, notez que nous n'avons pas besoin d' utiliser à nouveau le mot clé static. Et ensuite, ici, je vais, nous ferons et dirons bonjour après, juste comme ça. Et maintenant, n'importe quelle instance de notre classe animale, nous n'aurons qu'une seule version de cette fonction. De plus, comme il n'existe qu' une seule version de cette fonction, n' est pas autorisée à accéder à des variables non statiques. Ainsi, par exemple, nous ne pouvons pas dire que l'âge du soulignement est égal à cinq ans. Si je passe la souris dessus, vous verrez qu' une référence de membre non statique doit être relative à un objet spécifique. Et cela signifie que, comme notre fonction est statique et qu'il n'y a pas de nouvelle instance de celle-ci pour chaque objet de la classe animal que nous créons, ils ne peuvent pas utiliser des instances spécifiques de cette variable, car il y a un âge de soulignement pour chaque objet de notre classe. Il peut toutefois utiliser des variables et des fonctions statiques. Donc, si nous avions quelque chose comme du statique, j'aime qu'il puisse être utilisé, donc voilà. Et rappelez-vous également que lorsque vous utilisez une variable statique, nous devons dire côlon animal, deux-points, puis l' initialiser ainsi. Et il faudrait quand même le dire ici également. Alors, tu y vas. fonctions et les classes statiques sont partagées entre chaque objet de cette classe. Et ils ne peuvent utiliser que des variables et des fonctions statiques , car elles ne sont pas spécifiques à chaque objet. Maintenant, si nous changeons ça en quelque chose comme si je plus égale cinq et que nous allions ici et créons quelques animaux. Donc, s'il s'agit d'un animal, il faudra lui donner un nom et un âge. Donc, nous allons dire Jack, âgé d'un an. Et je dirais animal pour dire que Karl B en est un aussi. Et puis on peut dire animal d'un kilo, juste comme ça. Empreintes animalières Bonjour. Dans les deux cas, cela fonctionnera très bien. Et ils partagent la même fonction ici. Et juste pour vous montrer quelques choses à ce sujet, nous pouvons dire que x est égal à cinq. Ensuite, nous dirons x plus comme ça. Ensuite, nous dirons que je plus est égal à cinq. Et nous allons imprimer ce qui suit. Nous dirons que x est égal à. Pour imprimer x. La plupart du temps, Cl I est égal à. Et nous les mettrons également sur vos lignes. Maintenant, nous avons appelé cette fonction deux fois. N'oubliez pas qu'ils partagent exactement la même fonction. Et avant d'exécuter un code, nous avons besoin de parenthèses ici, comme cela, comme nous le ferions pour n'importe quel appel de fonction, d'ailleurs, au cas où j'aurais oublié de mentionner plus tôt dans le cours. Parfois, lorsque les gens parlent d' appeler une fonction, ils peuvent aussi parler d' invocation de la fonction, n'est-ce pas ? Donc, juste un avertissement à ce sujet. Cela signifie que les mêmes choses à invoquer dans l'appel, une fonction sont les mêmes. Maintenant, si nous exécutons un code ici, vous pouvez voir qu'il a imprimé Hello parce que x n'était pas une variable statique. C'était pareil à chaque fois que ce code RAM était, cependant, j'étais une variable statique. Ainsi, chaque fois que cette fonction s' exécutait, elle fonctionnait avec la même variable. Donc, la première fois, nous en imprimons cinq et la deuxième fois, nous en avons imprimé dix. Et la chose fondamentale à retenir à propos d'une fonction statique est que chaque instance de la classe partage la même fonction et qu'elle ne peut utiliser que des membres et des fonctions statiques. Et il y a une autre chose importante à noter à propos des fonctions statiques dans les classes. Et c'est parce que la fonction est statique et qu'il n'y a pas de nouvelle version par objet ou instance de la classe. Vous pouvez en fait appeler cette fonction sans créer d'objet. Donc, ce que nous pouvons faire ici pour dire côlon animal, côlon ou opérateur de résolution scopique. Et puis dites simplement « print hello ». Et cela fonctionnera très bien. Et vous y voilà. J'ai encore été augmenté de cinq parce que c' était une variable statique et que nous pouvions utiliser la fonction sans aucun objet. Donc c'est vraiment cool. Maintenant, je suis sûr que vous pouvez déjà penser différents cas d'utilisation où vous pourriez avoir besoin d'une variable permanente dans une fonction, ainsi que lorsque vous voudriez une variable statique dans une classe. Par exemple, nous pourrions l'utiliser pour qu' une fonction compte le nombre de fois où elle a été utilisée. Et puis pareil pour ici. Nous pourrions simplement augmenter notre variable statique d' un ou de chacun de nos différents constructeurs pour une classe. Ensuite, nous saurions combien d'objets de cette classe ont été créés. Et ce n'est qu'un exemple pour vous, pour chacune d'entre elles. Et puis nous avons déjà vu un exemple de cas où vous pourriez vouloir utiliser un objet de classe statique, où nous avons pu créer une fonction qui créait spécifiquement un objet dans son champ d'application, et était capable de faites quelque chose à l'objet à chaque fois qu'il s'exécute, sans qu'il soit en dehors de cette portée, et sans en créer un nouveau à chaque fois. Enfin, les fonctions et les classes statiques. L'un des principaux cas d'utilisation, raisons de leur utilisation, est le suivant, où nous pouvons appeler cette fonction sans créer d'instance de cette classe. Cela peut être très utile. Par exemple, si vous avez eu quelque chose comme un cours de mathématiques, vous n'avez probablement pas besoin d'une instance de votre cours de mathématiques. Au lieu de cela, il se peut que vous souhaitiez simplement utiliser toutes les fonctionnalités disponibles. Et ce serait un cas d' utilisation parfait pour cela ici. Quoi qu'il en soit, il existe quatre cas d'utilisation différents du mot clé static et quelques exemples qui l' accompagnent , ainsi que quelques cas d'utilisation. Donc, si vous voyez cela à l'avenir, j'espère que vous ne serez pas complètement perdu dans ce que c'est et pourquoi, et qui sait ? Peut-être que nous l'utiliserons même dans l'un de vos propres programmes. Quoi qu'il en soit, avant de terminer cette vidéo, je vais simplement supprimer les textes supplémentaires que nous avons créés dans cette vidéo. Qu'il en soit ainsi lorsque nous l'avons commencé. Quoi qu'il en soit, ne voyez rien. Merci de nous avoir regardés et je vous verrai dans la prochaine. 92. Chapitre 15 (cours) : cours contre structure: Dans cette vidéo, nous allons parler des différences entre les structures et les classes dans C plus. Maintenant, je sais que nous n'avons même pas examiné les structures ou les structures, mais croyez-moi, si vous savez quelles classes vous savez essentiellement ce que sont des structures. Alors allons-y et examinons la syntaxe de ces deux éléments. Ensuite, nous parlerons des différences réelles et des raisons pour lesquelles vous devriez utiliser l' une plutôt que l'autre. Donc, les deux premières classes de crédit, comme nous le savons, vous allez dire quelque chose comme classe. Vous devrez ouvrir et fermer les crochets et un point-virgule à la fin. Et pendant un certain temps, pour créer une structure, vous allez dire struct, ou ils ouvrent et ferment des crochets et un point-virgule à la fin. Et vous y voilà. C'est la syntaxe d'une structure. Et c'est la syntaxe d'une classe. Alors, quelle est la différence ? Eh bien, en ce qui concerne la théorie de notre programme, ou le compilateur, cela n'a pas vraiment d'importance. Il pourrait tout aussi bien s'agir exactement de la même chose à l' exception d'une différence essentielle. Et ne laissez personne vous dire le contraire parce qu' réalité, les petites différences mineures sous le capot ne feront aucune différence. Alors, quelle est cette différence fondamentale ? Eh bien, les membres de la classe, si vous vous en souvenez, par défaut sur privé, et les membres de la structure par défaut sur public. Et vous y voilà. C'est la différence entre une classe et une structure. Donc, juste pour clarifier ici, à l'écran, les membres d'un accès à un effet de classe. Les membres d'une structure, par défaut, sont publics. Et d'ailleurs, quand je parle de la différence entre ceux-ci, je ne fais référence qu'à C plus plus et à ces autres langages de programmation. Alors, tu y vas. C'est vraiment la seule différence entre une classe et une structure, à part le mot clé ici étant struct ou une classe en conséquence. Alors pourquoi utiliseriez-vous une structure plutôt qu'une classe ou vice versa ? Maintenant, en termes de technicité, vous pouvez utiliser celui que vous voulez. Cool. Comme je l'ai dit, ils sont fondamentalement les mêmes, à part l'accessibilité par défaut de ses membres, que vous pouvez toujours modifier de toute façon. Mais d'une manière générale, si un autre programmeur ou quelque chose comme ça regardait votre code et voyait un trait, il supposerait que vous n'aurez essentiellement rien privé ou de caché et qu'à peu près tout ce qui s'y trouve serait rendu public. Donc, si vous voulez créer une classe quelconque, c'est peut-être une classe pour les fonctions mathématiques ou quelque chose comme ça. Et tout sera public et disponible et vous n'avez aucune raison de cacher des informations, alors allez-y et utilisez une structure. Sinon, si vous prévoyez d'avoir des membres privés ou protégés, vraiment, je vous recommande d'utiliser une classe et c'est comme une chose de type conventionnel. Mais comme je l'ai dit, et tout ce qui est technique et C plus plus, c'est essentiellement la même chose, c'est clair que cette différence. Utilisez donc ce que vous préférez, mais c'est simplement la manière conventionnelle d'utiliser une structure, c'est-à-dire lorsque vous n' aurez rien de privé ou de protégé. Quoi qu'il en soit, c'est tout pour cette vidéo. Je vais donc effacer ce manteau. Merci de m'avoir regardée, et je te verrai dans la prochaine. 93. Chapitre 15 (cours) : prévenir la création de cours de base: Dans cette vidéo, nous allons parler de la manière dont nous pouvons rendre notre classe de base instanciée ou crédible. Donc, actuellement, dans notre code, nous pouvons créer un Animal Crossing et lui donner un nom. Et ensuite, en donnant un nom à l' animal, comme Sparky Exemple, et en lui donnant un H. Donc ça marchera très bien. Mais que se passerait-il si nous voulions faire en sorte que vous ne puissiez créer qu' une instance de chien ou chat, étant donné que nos classes héritent d' un animal ou les sous-classes de la classe de base des animaux ? Eh bien, c'est assez simple, mais nous devons passer à notre classe d'animaux ici. Et si nous l'ouvrons, vous pouvez voir notre constructeur ici. Et rappelez-vous comment je vous ai dit qu'un constructeur devait être public. Eh bien, c'était pour que nous puissions en créer une instance car le constructeur doit être disponible pour le faire. Mais dans ce cas, comme nous avons déjà des sous-classes « chat et chien » avec lesquelles nous voulons travailler au lieu d'utiliser directement des animaux, nous suffit de supprimer notre déclaration de constructeur ici. Ensuite, nous ajouterons protected en tant que spécificateur d'accès. Nous allons donc dire mine de charbon protégée, juste comme ça. Et juste en dessous, nous allons simplement coller notre constructeur. Et maintenant, la seule chose qui a accès à ce constructeur est la classe elle-même et ses sous-classes ou tout ce qui hérite de la classe Animal. Et maintenant, si nous essayons de descendre ici et de créer n'importe quel animal, nous aurons une erreur. Et c'est parce qu' il n'y a plus de constructeur à notre disposition. Et vous y voilà. C'est ainsi que vous pouvez rendre un cours crédible. Mais gardez à l'esprit que vous ne voudriez vraiment pas faire cela à moins d' avoir une sous-classe ou quelque chose comme ça avec laquelle travailler. Au lieu. Quoi qu'il en soit, nous allons continuer et laisser notre code comme ça pour l'instant. Alors allez-y et sauvegardez ce que vous avez. Merci de m'avoir écouté , et à bientôt. 94. Chapitre 15 (cours) : opérateurs d'accès aux membres: Dans cette vidéo, je vais vous montrer une autre forme d'opérateur d'accès aux membres. Donc, celui avec lequel nous avons travaillé présent était le point, mais il existe une autre version de celui-ci. Et un exemple de cas où vous verrez cela, par exemple lorsque vous travaillez avec des pointeurs vers des classes ou des structures. Alors allons-y et voyons comment cela fonctionne. Et d'ailleurs, l' opérateur ressemble à ceci, qui est un tiret et un symbole supérieur à. Donc, pour voir cela, nous allons créer un pointeur vers une classe. Et dans ce cas, il suffira de pointer vers mon chat. Nous allons donc dire astérisque PTR pour planaire et le définir comme étant égal à l'adresse de a. Très bien, donc maintenant, si nous imprimons plus proprement, Très bien, donc maintenant, si nous imprimons plus proprement, créez une nouvelle ligne. Et nous savons que cela imprimera l'adresse de mon chat où que ce soit ici. Cependant, nous pouvons également utiliser ce pointeur pour accéder aux membres de ce vers quoi pointe. Et comme je l'ai dit, ce n' est qu'un exemple de la situation dans laquelle vous pouvez voir cet opérateur. Et nous n'allons pas entrer dans les différents moments où vous allez voir ça. Mais si cela vous intéresse, n'hésitez pas à vous renseigner. Je voulais juste m'assurer de vous en montrer un exemple. Vous verrez que vous n'êtes pas complètement bouleversé quand vous verrez ces opérateurs. Et j'ai décidé de suivre cet exemple car avoir pointeurs vers des objets n'est pas si rare. Et puis, en bas, si nous disons PTR et que nous avons notre flèche ici, ou si nous avons un opérateur d'accès aux membres, vous pouvez voir que j' ai immédiatement accès à tous les membres de mon chat. Allons-y, utilisons ces compétences, obtenons de l'aide. Et ce que fait cet opérateur d' accès aux membres en dehors de nous donner accès au membre, c'est qu'il va également le faire ici. Donc, plutôt que de nous donner l'adresse maintenant, il va simplement lancer get help, qui, comme nous le savons, nous allons simplement renvoyer la valeur santé de mon chat, qui a commencé à 100 et nous la soustrayons par 15 ici. Nous l'avons déjà imprimé à l'écran au numéro 85. Donc, ici, cela imprimera également 85. Si nous nous contentons de dire « Voyez comme ça ». Et si nous exécutons un code ici, vous pouvez voir que nous avons imprimé l'adresse de mon chat. Et nous avons exécuté cette fonction ici normalement. Et c'est parce que cet opérateur d'accès aux membres, lorsqu'il est utilisé avec des pointeurs, nous donne non seulement accès au membre, mais aussi aux références qui. Donc, au lieu de nous donner une adresse, nous utilisons ce membre normalement. Quoi qu'il en soit, ce n'est qu'un exemple du moment où vous verrez cet opérateur. Et si cela vous intéresse, vous pouvez examiner d'autres cas d'utilisation. Mais c'est celui qui suivra ce cours et celui que vous verrez probablement le plus souvent. Quoi qu'il en soit, je vais supprimer ce code supplémentaire. N' oubliez pas de le faire en toute sécurité. Tu l'as fait. Merci de m'avoir écouté et je vous verrai dans la prochaine. 95. Chapitre 15 (cours) : le polymorphisme: Dans cette vidéo, nous allons parler notre quatrième et dernier principe principal et/ou pilier de la programmation orientée objet, le polymorphisme. Et ce que signifie le polymorphisme, c'est prendre de nombreuses formes. Quoi qu'il en soit, allons-y et examinons quelques exemples de polymorphisme. Donc, si nous passons à notre classe d'animaux ici, vous vous souvenez, nous avons créé cette méthode de parole. Et si nous regardons la définition de cela, il suffit de prendre un son et de l'imprimer. Cependant, nous ne disposons pas actuellement de cette version spécifique pour nos chiens et chats ou pour toute autre classe et sous-classe pour enfants Nous souhaiterons peut-être créer un héritage de notre classe d'animaux. Maintenant, il n'est pas très efficace de devoir insérer une corde spécifique chaque fois que nous utilisons cette fonction, puis le son que l'animal produit spécifiquement à chaque fois que nous l'utilisons utilisons cette fonction, puis d'ajouter le son que l'animal produit spécifiquement à chaque fois que nous l'utilisons. Allons-y et corrigeons ce problème en utilisant le polymorphisme. Donc, la première chose que nous allons faire est supprimer complètement ce périmètre. D'accord ? Et il va juste imprimer des sons d'animaux comme ça. Très bien, et la raison pour laquelle nous obtenons cette erreur est que dans notre déclaration ici, nous devons également supprimer le paramètre. Une façon de résoudre notre problème initial avec notre classe de chiens et de chats est de procéder comme suit. abord, nous pouvons simplement copier toute cette fonction et coller dans chacune d'elles, comme suit. Et maintenant, sur les deux, il ne nous reste plus qu'à retirer cette partie animale ici. Donc maintenant, il suffit de dire «  nul, parler » et je vais simplement supprimer ces commentaires également. Souvenez-vous, normalement, de ce que vous allez vouloir faire. Ayez la déclaration ici et la définition en dehors de la classe. Mais on va juste continuer et laisser les choses comme ça pour l'instant. Et notre exemple de toute façon, ce que nous pouvons faire maintenant, c'est dans notre classe de chiens ici, il suffit de les changer pour dire Park et notre classe de chats ici, nous pouvons simplement changer cela pour dire, Oui, ça marcherait très bien. Donc, si nous allions ici, allons-y et imprimons simplement quelques pages vierges. Ensuite, en bas, c'est mon chat qui parle. Et si vous vous souvenez, avant de remplacer ces fonctions, cela aurait simplement utilisé notre définition qui se trouvait dans la classe de base. Mais maintenant que nous les avons annulés, nous pouvons procéder comme suit. Alors dites à mon chien de ne pas parler maintenant et exécutez notre code ici. Vous pouvez voir que nous avons imprimé et aboyé. Et juste pour vous rappeler comment cela fonctionnait auparavant, si nous supprimons simplement notre implémentation pour la classe cat et exécutons à nouveau notre code. Vous pouvez voir qu'il est simplement dit que les animaux sonnent puis marquent, n'est-ce pas ? Donc, bien que cela fonctionne ici, le problème est que cela permet vraiment l'erreur humaine. Parce que maintenant, chaque fois que nous avons une classe pour enfants dont la classe mère est un animal, nous devons nous souvenir d'implémenter la méthode speak. Sinon, on dira simplement que les animaux parlent, ce qui n'est pas du tout idéal. Nous voulons que chaque animal ait un son différent intégré à la classe. Et normalement, si vous remplacez une fonction comme celle-ci et que la classe de base est animale, dans ce cas, elle a sa propre implémentation. Ce que vous voulez faire, c'est faire ces implémentations une fonction virtuelle. Et je vais vous montrer ce que c'est et pourquoi dans un instant. Donc, si nous revenons à notre code principal ici et créons un pointeur vers notre classe de base. Donc, si nous disons Astros animaux, nous appellerons cet animal clignotant. Et nous allons le faire correspondre à l'adresse de mon chat. La raison pour laquelle cela fonctionne d'ailleurs, et vous pouvez même demander un animal dans un périmètre de fonction et utiliser mon chat comme argument, est la suivante. Et c'est une autre forme de polymorphisme en fait, parce que notre chat est un animal, alors nous savons que tout ce à quoi cet animal a accès, chat a accès. Donc, si nous demandions un animal dans une fonction, par exemple, et que nous exécutions différentes fonctions animales et que nous travaillions sur certaines des différentes variables de l'animal. Eh bien, nous savons déjà que le chat a une implémentation de toutes ces choses parce que notre chat est un animal, car il hérite de l'animal, et donc il prend différentes formes. Un chien n'est pas seulement un chien, c'est un animal. Le chat n'est pas qu'un chat. C'est aussi un animal. Mais nous ne pouvons pas utiliser animal comme implémentation pour chien ou chat, par exemple, car tous les animaux ne sont pas des chats, mais tous les chats sont des animaux. Cela ne fonctionne donc que dans un sens. C'est pourquoi ici, nous disons, d'accord, fonctionne, puis-je créer un pointeur vers un animal et attraper l'animal ? Donc ça fonctionne. D'accord, mais le problème, c'est que si je devais dire cratère animal, utilisez notre opérateur d'accès aux membres. Souvenez-vous des pointeurs que vous allez utiliser : un tiret et un symbole supérieur à. Cela ressemble à une flèche puis dites parler. Et exécutez notre code. Vous pouvez voir qu'un animal fixe sonne un animal, peu d'écorce, ce qui est logique pour le moment. Mais même si notre chat ici avait une implémentation de Speak. Alors allons-y, remettons ça dans notre classe de chats ici et changeons-le en miaou. Ensuite, si nous exécutons à nouveau notre code, vous pouvez voir que nous obtenons un résultat étrange. Et c'est parce que notre pointeur ici qui accède Speak référencera en fait la version de la classe de base. En revanche, ici, où nous avons utilisé nos objets cat en particulier, nous utiliserons la classe dérivée ou notre version de classe enfant, et ce n'est peut-être pas toujours ce que vous voulez. Alors allons-y et voyons un moyen de les résoudre. Donc, si nous montons dans notre classe de base ici, en étant des animaux et que nous passons à notre fonction orale ici. Ce que nous allons faire, c'est mettre le mot clé virtuel devant lui. Et il suffit de le faire dans la déclaration. Et ce que fait ce mot clé virtuel ici est essentiellement de dire explicitement que nous voulons que les sous-classes de notre classe animale aient leur propre implémentation de cette fonction. Et nous pouvons toujours laisser notre implémentation de base ici. Cependant, nous laissons notre programme maintenant ici. Hé, nous voulons que chaque classe dérivée animal ait sa propre implémentation de cette fonction, c'est pourquoi nous en avons fait une fonction virtuelle. Donc, c'est ce que cela fait, c'est simplement dire explicitement : « Hé, nous voulons que les sous-classes de notre superclasse ou classes enfants de notre classe parente créent leurs propres versions de cette fonction. Donc maintenant, si nous exécutons notre code, vous pouvez voir qu'il imprime maintenant miaou et notre pointeur ici. Et puis, comme référencement, notre fonction speak fonctionne désormais avec les sous-classes, la réversion de celle-ci. Et c'est parce que nous avons explicitement dit : « Hé, nous voulons que nos sous-classes aient leur propre implémentation de cette fonction. Et je ne vais pas entrer dans les détails de la raison pour laquelle cela fonctionne de cette façon. Mais sachez simplement que si vous prévoyez d'avoir une fonction dans la classe de base qui remplacée et dans vos sous-classes, vous voudrez ajouter le mot clé virtuel. Et souvenez-vous de tout ce que nous avions à traiter rituel dans la déclaration et dans notre classe de base, mais pas dans la définition ci-dessous. Juste pour vous montrer cela rapidement, FOR cat, par exemple, n'avait pas sa propre implémentation. Cela fonctionnerait toujours très bien. D'accord, donc ça ne l' oblige pas, mais nous avons toujours un problème au cas où nous voudrions que notre classe de base n'ait pas sa propre implémentation. Et nous voulions forcer chaque sous-classe à avoir sa propre implémentation sans avoir à nous inquiéter de l'oublier. Cela ne suffira tout simplement pas. Ce n'est peut-être pas toujours le cas. Dans certaines circonstances, vous souhaiterez peut-être que la classe de base sa propre implémentation, comme nous l'avons fait ici. Mais dans le cas où vous ne le feriez pas, laissez-moi vous montrer comment nous pouvons y remédier. Ainsi, au lieu d'avoir une simple fonction virtuelle ici, nous pouvons en fait créer une fonction purement virtuelle. Alors laissez-moi vous montrer comment procéder. abord, nous allons simplement supprimer la définition de vitesse entièrement religieusement, nous pouvons nous en débarrasser. Ensuite, dans notre déclaration, nous allons dire après les parenthèses fermées, mais avant le point-virgule, nous allons dire égal à 0. Et maintenant, il s'agit d'une fonction purement virtuelle. Maintenant que nous avons vu une fonction purement virtuelle dans une fonction virtuelle normale, il y a juste quelques points que je veux que vous gardiez à l'esprit. abord, les fonctions rituelles ne peuvent pas être statiques, d'accord, donc ce ne peut pas être la seule version de cette fonction parce que vous dites, Hé, je veux que mes sous-classes en aient leur propre version, d' accord, donc cela n'a donc aucun sens. De plus, une fonction virtuelle peut être une fonction amie d'une autre classe, et nous aborderons les fonctions et les classes d' amis dans une prochaine vidéo. Juste quelque chose à noter. Ne t'inquiète pas pour l'instant. Qu'est-ce donc qu'une fonction purement virtuelle ? Eh bien, nous pouvons dire que nous voulons le mettre à 0. Nous disons que cette fonction n' a pas de définition. Cela pourrait tout aussi bien ne pas exister. Par conséquent, chaque sous-classe doit avoir sa propre version. Et vous vous demandez peut-être pourquoi nous n'avons pas simplement supprimé un vide, parlé ici entièrement et l'avons simplement jeté dans chaque sous-classe, comme notre chien ou notre chat. Si nous en créions un autre, comme un nœud coulant ou un cheval, etc. Eh bien, nous pourrions oublier une chose, et alors chaque animal pourrait ne pas avoir de fonction vocale. De plus, par exemple, si nous créions une méthode ou une fonction prenant l' animal comme périmètre, nous ne serions pas en mesure d'utiliser la fonction de parole puisque notre fonction ne sait plus si chaque animal peut parler, parce que cela n'est pas défini dans la classe animale, non ? C'est pourquoi vous voudriez d'abord l'avoir ici. Ensuite, comme je l'ai dit, il enlève simplement les poils humains. Donc maintenant, si nous passons à notre classe de chiens, nous avons déjà une implémentation de la liste. Mais ce n'est pas le cas de notre classe de chats. Et comme vous pouvez le constater, cela nous donne immédiatement une erreur. Il s'agit d'un objet de type de classe abstrait. Cat n'est pas autorisé car il existe une fonction purement virtuelle. Maintenant, une classe abstraite est une classe dont vous ne pouvez pas créer d' objet directement. On ne peut donc plus parler d'animal. Mon cours, par exemple, et donnez-lui un nom comme Jack. Et un âge. Cela ne fonctionnera pas car il s'agit d'une classe abstraite. Et si c'est abstrait c'est parce qu'il contient une fonction qui n'a pas de définition. Fondamentalement, il n'existe pas et les sous-classes doivent créer la définition pour cela. Par conséquent, nous ne pouvons pas créer d'objets dessus dans une classe abstraite, c'est-à-dire n'importe quelle classe ayant une fonction purement virtuelle. Comme cette fonction n'a pas de définition réelle , nous ne pouvons pas créer d'objet de cette classe car elle possède désormais une fonction qui n'est pas définie. D'accord ? fait d'avoir une fonction purement virtuelle pour une personne rend la classe crédible, ce que nous avons déjà un peu mort en protégeant notre constructeur animal. Mais même si c'était public, il ne serait toujours pas possible de le créer simplement cause de notre fonction purement virtuelle ici, il est maintenant considéré comme abstrait d'une chose à noter, pour ceux d'entre vous qui viennent à partir d'autres langages de programmation, en particulier pour vous, ainsi que si chaque membre de la classe est purement virtuel et qu'il n'a aucune implémentation de quoi que ce soit à lui seul. Cette classe est maintenant considérée comme une interface pour d'autres choses car elle n'a aucune définition de quoi que ce soit. Ce ne sont que des déclarations. Il possède donc ce que l' on appelle une interface n'est essentiellement qu'un plan pour tout. Et Haritsa avec une fonction purement virtuelle, c'est une classe abstraite. Et si tout était purement virtuel, ce serait une interface, de toute façon considéré comme une interface, comme vous l'avez vu, parce que nous avons cette fonction purement virtuelle, il n'y a pas de place pour l'erreur humaine lors de la création de différents animaux. Donc, lorsque nous avons créé notre chien ici, que nous avons dit en tant qu'animal ou que notre chat était un animal, etc. Chaque animal que nous créons devra désormais avoir une version de la fonction Speak, n'est-ce pas ? Parce qu'il n'y a pas de définition en soi. Et techniquement, tu pourrais le laisser comme ça. Et cela est maintenant considéré comme une classe essentiellement abstraite car elle a une fonction sans définition. Et puis vous pouvez avoir une classe qui dérive du chat ou qui hérite du chat. Et finalement, l'un d' entre eux aurait besoin d'une définition pour parler, parce que vous ne pouvez pas avoir d' objet d'une classe qui ait une fonction ou une méthode purement virtuelle parce que cela ne nous permet pas de le faire maintenant, haut-parleurs désormais correctement implémentés. Il a donc dit que chaque animal doit parler et avoir sa propre façon de parler. Donc, ici, dans notre classe, nous allons continuer et coller notre méthode de parole. Et juste pour faire les choses correctement, allons-y et réglons ça maintenant. Nous allons donc dire « annuler », « parler point-virgule », juste comme ça. Et il copiera cette enveloppe, un cours de chiens, par exemple ici. Ensuite, pour les mots bec, nous dirons chien, deux-points, deux-points parlent, et là, jusqu'au point-virgule, juste comme ça. Et débarrassez-vous de notre définition ici, comme nous l'avons fait pour toutes nos autres fonctions, comme je l'ai déjà dit, et c' est la bonne façon de procéder. Nous allons donc le copier à nouveau, point-virgule à la fin pour créer la déclaration. Découpez-le et inscrivez la définition ci-dessous. Et je vais en fait le mettre en dessous de notre constructeur ici. Ce sera l'érosion du langage des chats. Et d'ailleurs, au cas où j'aurais oublié de le mentionner auparavant, dans nos constructeurs où nous avions notre constructeur animal, voici le constructeur de classe de base. Cela doit venir en premier avant que tout autre élément de notre liste ne l'initialise ici. Mais comme je l'ai dit, tout dans l'initialiseur de liste doit être un ordre de haut en bas, et un constructeur de classe de base doit passer en premier. Je voulais juste vous en informer au cas où j'aurais oublié de le mentionner. Et puis, en bas de notre définition de la vitesse en majuscules, modifions-la pour exécuter notre code. Voilà, tout fonctionne correctement. Maintenant, notre pointeur animal, qui pointe vers notre chat, utilise la bonne version de celui-ci. Et nous pourrions même changer notre pointeur vers mon chien, et tout fonctionnerait très bien. Et en plus de cela, il ne nous est plus possible de créer un nouvel animal ou une sous-classe d'animaux qui n'ait pas sa propre version du langage. Très bien, donc c'est fantastique. Tout fonctionne et fonctionne. Et c'est le dernier exemple de polymorphisme que nous allons examiner, car maintenant notre fonction de parole en possède plusieurs versions, n'est-ce pas ? N'oubliez pas que le polymorphisme signifie que prendre de nombreuses formes, pour ainsi dire, n'est pas seulement un pur rituel, une fonction sans définition, mais il a sa propre version à l'intérieur de notre classe de chiens, et il a sa propre version dans sa classe de chats. Voici donc quelques exemples de polymorphisme pour vous. D'accord ? Nous avons appris ce qu'est une fonction virtuelle, qui est simplement une fonction que vous avez explicitement indiquée utilisant les sous-classes pour avoir leur propre version de celle-ci. Nous avons également examiné comment créer une fonction purement virtuelle, qui a été créée en définissant cette fonction sur 0, en disant essentiellement qu' elle n'est égale à rien. Il n'existe pas pour le moment. Et supprimez la définition qui non seulement rend la classe abstraite automatiquement, mais si tout était purement virtuel dans la classe, ce serait ce que l'on appelle une interface qui est essentiellement un plan pour tout ce qui en hérite dans une fonction purement virtuelle par rapport à une fonction virtuelle normale, qui ressemblerait à ceci, est juste une fonction qui a maintenant besoin d'une définition pour être créé au sein d'une classe qui en dérive. Et si notre classe de chiens n'en avait pas sa version, alors nous ne pourrions pas créer de chien non plus. Il a besoin d'une définition à un moment donné. faudrait donc avoir des races de chiens sous forme de classes ou quelque chose comme ça et leur donner une définition. À un moment donné, il vous faudra une définition pour créer des objets de toute classe dérivée de l'animal, n'est-ce pas ? Nous avons également appris que chaque sous-classe ou classe enfants est également considérée comme une classe de base, mais que toutes les classes de parents ne sont pas considérées comme des classes d'enfants. Et pour rappel, dans notre exemple, cela revient essentiellement à dire que chaque chien est un animal, mais que tous les animaux ne sont pas des chiens. Et juste pour vous montrer rapidement un autre moyen , j'en ai un exemple. Nous aurions pu créer une fonction comme celle-ci, disant « animal vide » ou quelque chose comme ça. Et puis en tant que paramètre, car ils peuvent être un animal et un animal. À l'intérieur, on aurait pu dire animal, mourir, parler. Comme vous pouvez le constater, nous avons reçu une erreur. Et c'est simplement parce que l'animal est actuellement une classe abstraite. Alors allons-y, réglons ce rapidement ici et changeons cette fonction d' une fonction purement virtuelle à une fonction virtuelle normale. Et nous allons lui donner une définition rapide comme ça, juste comme ça. Maintenant, si nous descendons ici, laissez-moi vous parler mal et dire passion, ce soit notre chat ou notre chien. Alors, devenons un chat passionné. Et comme vous pouvez le voir lorsque nous exécutons notre code, il n'imprime rien après aboiement. Et c'est parce que cette version de cette fonction utilisait en fait des animaux , puisque nous avons créé une copie des valeurs des chats et que nous l'avons mise essentiellement dans un animal. Mais pour résoudre ce problème, il suffit de faire référence à l' animal Peston, et maintenant cela fonctionnera très bien. Donc, si nous exécutons à nouveau notre code, c'est parti. Il l'imprime. Oui. Et comme je l'ai dit, parce qu'un chien est aussi un animal, nous aurions pu transmettre mon chien. Et notre code et notre fonction auraient fonctionné la même manière, sauf que maintenant il imprime des aboiements. Alors, tu y vas. Alors, tu y vas. J'espère que vous avez maintenant une compréhension de base du polymorphisme dans les différentes manières de l'utiliser, ainsi que certains mots clés qui l'accompagnent. Nous avons donc examiné les classes et les interfaces abstraites. Nous avons également examiné la création de fonctions virtuelles qui ont leur propre implémentation et qui le disent explicitement de cette façon. Quelles sous-classes pour créer leurs propres versions de cela dans des fonctions purement virtuelles, qui disent essentiellement qu'il n' y a pas de définition et sous-classes doivent en créer leur propre version. Et les sous-classes, nos classes de base, ces classes de base ne sont pas nécessairement des sous-classes. Nous n'aurions donc pas pu prendre un chat comme paramètre et leur envoyer un animal. Quoi qu'il en soit, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 96. Chapitre 15 (cours) : quatre principes principaux du PO: Dans cette vidéo, nous allons revisiter les quatre principaux piliers ou principes de la programmation orientée objet. Et elles ne sont pas dans un ordre particulier. Autre remarque : nous n'avons pas abordé tous les aspects possibles de chacun de ces quatre piliers principaux, mais nous avons abordé les bases et l'essentiel de ceux-ci, divisés, vous savez ce qu'ils sont, comment et quand vous peut les implémenter dans vos propres programmes. Donc, dans le premier cas, nous allons parler de la pollution. Et si vous vous en souvenez, l'encapsulation consiste à masquer des données de l'extérieur en encapsulant dans des fonctions accessibles. Donc, par exemple, lorsque nous avons fait cela, c'est lorsque nous avions nos fonctions getter et setter qui aident toutes nos variables privées à l' intérieur de celles-ci. Les variables privées étaient encapsulées dans notre getter et fonctions de réglage. D'accord, donc c'est notre premier. Ensuite, nous allons parler d'abstraction. Et en gros, vous pouvez considérer cela comme une extension de l'encapsulation et de abstraction lorsque vous ne montrez l'utilisateur que des données ou des informations pertinentes. Ainsi, par exemple, lorsque vous allumez votre téléphone ou que vous ouvrez une application, vous ne voyez que les informations pertinentes. Et un exemple de ce que nous avons fait est qu'une fois de plus, lorsque nous avons eu notre getter et notre setter, vous n'aviez pas besoin de savoir ce qu'il y avait dans ce bloc de code, comment il affectait exactement nos variables privées. Tout ce dont vous avez besoin pour savoir quel est le nom de la fonction et les paramètres. Tout le reste vient de se passer en arrière-plan. Par exemple, lorsque nous avions notre variable santé et qu'elle ne vous permettait pas de dépasser 100 ou moins de 0. L'utilisateur n'avait pas besoin de savoir tout cela. Lorsque nous appelons le pion nos fonctions pour modifier ou définir notre variable de santé, nous devons simplement indiquer le nom de la fonction et ce que l'insert tant que périmètre et tout le reste a été abstrait. de notre part. Elle était cachée en arrière-plan. C'était donc de l'abstraction. Ensuite, nous avons l'héritage, en gros, lorsque quelque chose hérite de quelque chose d'autre. Ainsi, par exemple, en programmation, héritage se produit lorsque vous héritez de membres d'autre chose, ce qui vous permet de trouver des similitudes dans une classe parente. Ainsi, par exemple, notre classe animale, qui définissait en quelque sorte ce qu'est un animal, nous avons pu avoir des éléments tels qu'une fonction de parole, une variable de santé nommée variable. Nous avons pu établir les bases de ce qu'était un animal. Et puis les choses dont nous pouvons hériter pour rester en quelque sorte, hé, c'est un animal. Il y aura donc tout ce que possèdent tous les animaux. Et puis elle peut aussi avoir sa propre identité, sa propre singularité. Ainsi, par exemple, nos chats et nos chiens ont imprimé différentes choses. Ainsi, quand notre chat a parlé et quand l'obscurité a parlé à aboiement, et quand il a été créé, il avait imprimé des choses légèrement différentes, disant soit un catalyseur créé, soit un chien qui a été créé. spécifiquement. Mais ils avaient tous une chose en commun la classe mère ou la classe animale que nous avons créée, n'est-ce pas ? Et c'était un exemple d'héritage de deux classes d'une classe de base. Et n'oubliez pas qu'il y a beaucoup d'autres choses que vous pouvez voir appeler les cours pour enfants et parents, mais la plupart du temps, la classe parent et enfant est utilisée plus souvent. Et c'est une façon simple d'y penser. Parce que, par exemple, les enfants héritent de choses de leurs parents. Ce sont donc des connexions faciles dans la vie réelle. Enfin, il y a le polymorphisme. Et ce que signifie le polymorphisme, c'est prendre de nombreuses formes. Et nous venons d'en voir quelques exemples dans la dernière vidéo. Ainsi, certains exemples d' utilisation du polymorphisme sont des fonctions prépondérantes. Nous avons également utilisé des sous-classes comme classe de base. Par exemple, nous avons utilisé un chat et un chien pour remplacer le périmètre d'un animal parce que nous savons que tout et qu'un animal peut faire. Un chat et un chien peuvent aussi le faire parce qu'ils héritent des mêmes membres et plus encore. Et puis quelques autres exemples de cela que nous avons examinés où fonctionnent nos fonctions virtuelles et purement virtuelles, qui indiquaient nos fonctions virtuelles et purement virtuelles, explicitement : « Hé, si elles doivent être écrasées et qu'il y aura autres implémentations de cette fonction. Quoi qu'il en soit, vous y voilà. Ce sont les quatre grands principes ou piliers, plutôt qu'une colonne de programmation orientée objet. Vous avez donc l'encapsulation, l'abstraction, l'héritage et le polymorphisme. Je sais que beaucoup de cours pour débutants n'abordent pas ces quatre sujets. Mais personnellement, vu que ce sont les quatre grands principes de la programmation orientée objet. Je ne vois pas comment les laisser de côté dans un cours pour débutants, surtout parce que la plupart du temps, une fois que vous aurez terminé un cours de programmation pour débutants, vous allez sortir et commencer à travailler avec vos propres programmes et essayez simplement de faire le plus possible avec ce que vous savez et comment allez-vous faire pour créer du code de bonne qualité dans un langage de programmation orienté objet si vous ne le savez même pas les quatre grands principes de la programmation orientée objet, tout cas, j'espère que vous avez apprécié la vidéo comme toujours, merci de l'avoir regardée , et à bientôt dans la prochaine. 97. Chapitre 15 (cours) : fonctions et cours d'amis: Dans cette vidéo, nous allons parler des fonctions et des classes Friend dans C plus plus. abord, je vais vous expliquer ce qu'est une fonction d' ami et une classe d'amis. Je vais aller de l'avant, l'examiner et créer un exemple des deux. Une fonction amie est une fonction qui permet d'accéder aux données privées et protégées d'une classe. Et une classe d'amis peut accéder à données privées et protégées ou aux membres d'une autre classe. Quoi qu'il en soit, allons-y créons et examinons un exemple la fois d'une fonction d'ami et d'une classe d'amis. Très bien, au-dessus de notre fonction principale, allons-y et créons une classe, et nous allons simplement appeler cette classe. Nous aurons notre bloc de code comme ça. Et n'oubliez pas le point-virgule à la fin. Maintenant, foo est souvent un nom générique que vous verrez assez fréquemment dans les exemples. C'est juste une sorte de nom de lieu courant. Nous allons donc simplement nous en servir pour vous montrer un exemple de ce que vous pourriez considérer comme cela. instant, je vais vous montrer un exemple. Je dirais classe. Et à l'intérieur, avec une variable assez élevée. Nous allons donc dire privé, juste comme ça. Et puis Dumbo ça. Nous allons simplement dire int x et nous allons simplement procéder à l'initialisation. Je sais que normalement, vous voulez que cela soit séparé, mais pour garder cet exemple précis, nous n'allons pas nous inquiéter à ce sujet. Ensuite, en dehors de la classe, nous allons créer une fonction qui imprime x. Donc, disons void, print x. Et puis, entre parenthèses , nous allons avoir un paramètre qui prend un objet de classe Foo. Donc, sauvegardez, et nous appellerons simplement cela en minuscules ici. Ensuite, à l'intérieur de notre bloc de code, il sera indiqué foo got x. Maintenant, comme nous le savons, les variables privées et protégées ne sont pas accessibles en dehors de la classe. Et les fonctions d'amis, tout comme les classes d'amis, ne sont ni des membres de la classe dont ils sont amis, ni des sous-classes de celle-ci, elles sont complètement distinctes. Cependant, pour déclarer notre fonction en tant que fonction amie, nous devons la spécifier dans la classe elle-même. Donc, dans notre classe Foo, nous allons simplement avoir ce qui ressemblerait à une déclaration ou à un prototype de notre fonction print x. Nous allons donc simplement copier cette ligne entière et la coller ici. N'oubliez pas notre point-virgule à la fin. Maintenant, comme vous pouvez le voir, dans un endroit toujours inaccessible, pour résoudre ce problème, il vous suffit d'en faire une fonction amie en ajoutant le mot clé ami avant un vide ici, comme ça. Et maintenant, comme vous pouvez le voir, cela fonctionne très bien. Donc, si nous passons à notre fonction principale et simplement appel à notre fonction print x, print x et y. Je dois insérer et implémenter foo ici. Donc on va l'appeler. Ensuite, nous allons simplement l'envoyer. Juste ici. On y va. Nous avons pu accéder à ce membre privé grâce à notre fonction d'amis. Et remarquez que nous n'avons eu qu'à mettre Friend et cette ligne ici et non la déclaration de fonction proprement dite là. D'ailleurs, une fonction d'amis peut avoir plusieurs amis. Donc, pour vous le montrer, allons-y et supprimons tout. Tu ne le fais pas ? N'oubliez pas notre fonction et la déclaration de fonction de notre ami. Ensuite, changeons la classe foo en classe, copiez-la et collez-la ci-dessous. Et nous l'appellerons classe A, classe B, un entier privé. On va juste l'appeler y, juste pour le plaisir. Et nous allons le mettre à dix. Ensuite, ci-dessous, nous allons créer notre fonction, disons void, puis la classe de paiement a object et nous appellerons cette classe be object et l'appellerons b. Ensuite, nous en ferons un ami de ces deux classes. Il suffit donc de copier cette ligne supérieure ici, de la coller, mettre un point-virgule à la fin et d'ajouter le mot-clé. Ensuite, nous pouvons simplement le copier et le coller, comme ça. Et puis à l'intérieur de notre fonction ici, a x plus b y, juste comme ça. Maintenant, remarquez que celui-ci est inaccessible, et je vais vous montrer pourquoi dans un instant. Mais avant de le faire dans notre fonction principale, nous allons créer une instance des deux gloses. Et n'oubliez pas que nous pouvons lui donner le nom que vous voulez. Ça n'a pas d'importance. Les noms de nos périmètres seront séparés. Je pourrais donc dire un b et une petite fonction d'ajout de couleur. Parce que cela ne fait partie de rien. Nous n'avons pas besoin de préciser d' où il provient. Et ensuite, dites simplement : ne mettez pas de point-virgule à la fin. Et cela fonctionnerait très bien une fois que nous aurons corrigé cette erreur ici. La raison pour laquelle nous obtenons cela est que la classe a ne sait pas ce qu' est la classe B lorsqu' elle lit notre code ici. Et nous pouvons régler ce problème avec ce que on appelle une déclaration prospective. Et nous allons le mettre ici en haut juste au-dessus de notre classe A. Et tout ce juste au-dessus de notre classe A. que nous allons faire en tant que classe et mettre un point-virgule à la fin. Et ça va tout arranger. Et comme je l'ai dit, c'est ce que l' on appelle une déclaration prospective. Nous en avons vu des exemples lorsque nous avions un prototype de fonction, puis la définition ci-dessous, sauf que cela faisait la même chose avec une classe. En gros, nous disons, hé, ce sera une classe appelée code B et R et maintenant, une classe n'a pas été confondue. Comme vous pouvez le voir, l'erreur a disparu et nous pouvons exécuter notre code, afficher 15 car notre fonction d' ajout et notre accès à la variable privée x et à la variable privée y. Nous pouvons les appeler tous les deux X. Ça n'aurait vraiment pas eu d'importance. Alors, tu y vas. Voici quelques exemples de fonctions d'amis, qui sont simplement des fonctions qui ont accès à des membres privés et protégés de la classe ou des classes dont ils sont amis. Et puis nous avons des cours entre amis. Je vais te le montrer tout de suite. Et pour ce faire, passons à la classe I, et supprimons complètement notre fonction d'ami ici, comme suit. Ensuite, nous allons dire cours entre amis, juste comme ça. Et maintenant, la classe B a accès aux membres privés et protégés de la classe. Et nous allons continuer et supprimer complètement notre fonction d'ami maintenant. Et nous allons le déplacer ici dans notre fonction principale. Ensuite, dans la classe B, nous allons créer une fonction pour ajouter x et y. Donc, dites void add i. Maintenant, normalement, nous ne voudrions pas mettre la définition dans la classe ici. Mais pour que les choses restent simples, nous allons aller de l'avant et le faire. Ensuite, ici, nous allons dire une couleur. Je vais dire y plus x. Et parce que la classe B en tant qu'ami, disons, comme indiqué ici. Et encore une fois, une classe peut avoir plusieurs amis, tout comme leurs fonctions. Il aura accès à des variables privées au sein de la classe et sera protégé, même s'il ne s'agit pas du tout d'une sous-classe de la classe A ou d'une partie de la classe A. Nous avons donc créé une instance de classe, disons, dans la classe B, comme nous l'avons fait avec notre fonction amie, en gros, car nous avions encore besoin d'une instance de la classe avec laquelle travailler. Et maintenant, dans notre fonction principale, nous pouvons nous débarrasser de tout cela ici et simplement dire B et l'appeler B ou comme vous voulez. Et puis en bas, ce serait comme ça avec le point-virgule à la fin. Vous devez faire pour corriger cette erreur ici, nous sommes inaccessibles, c' est rendre notre fonction publique opinion publique, publique. Je vais juste nettoyer ça un peu et c'est parti. Notre fonction est désormais accessible par notre instance de la classe, puisqu'elle est publique et que nous pouvons y faire appel. Et vous y voilà. Ça sort 15 parce que y et cinq s' additionnent parce que ces équipes, de toute façon, voilà. Vous savez maintenant quelle fonction un ami, un ami classe et comment les utiliser. Alors, comme toujours, merci de m'avoir écouté et je vous verrai dans la prochaine. 98. Chapitre 15 (cours) : espaces de noms: Dans cette vidéo, nous allons parler des espaces de noms. Comme certains d'entre vous s'en souviennent peut-être, une partie de notre code provient de l'espace de noms standard, comme C et C out. Et si nous n'avons pas eu grand-chose à y faire c'est parce que nous avons spécifié ou explicitement dit que nous utiliserons du code provenant de l'espace de noms std. Cependant, si ce n'était pas là, je vais simplement le commenter pendant une minute et nous essaierons de dire quelque chose qui renvoie à C out. Il n'a aucune idée d'où vient le référencement. Et c'est parce qu'il fait partie de l'espace de noms standard std ici en abrégé. Si nous ne voulions pas l'avoir explicitement en haut, nous devrions dire deux-points standard, deux-points suivis de C out, ou le morceau de code que nous utilisons à partir de cet espace de noms et d'un CN transparent ici. Et certaines des autres choses que nous avons utilisées dans le passé également. Numéroter un espace de noms est essentiellement un espace nommé ou une partie de code nommée pour vous aider à spécifier de quoi vous parlez. Donc, normalement, si vous aviez deux fonctions avec le même nom exact et les mêmes paramètres, il serait difficile de distinguer celle que vous utilisez. Cependant, si chacun faisait partie de son propre espace de noms, alors notre compilateur saura de quel espace de noms nous parlons et d'où vient le code. Et un exemple que j'ai utilisé dans une vidéo précédente, car vous pouvez l'imaginer comme le nom de famille de quelqu'un. Donc, si je venais te voir et que j'entamais une conversation et que je te disais simplement, John, tu ne saurais peut-être pas de qui je parle. Mais si je disais comme John Silver ou quelque chose comme ça, alors parce que je l'ai associé à un nom de famille, vous sauriez de qui je parle à partir de maintenant. Et c'est un peu comme si nous disions que nous allons parler du code de notre espace de noms standard dans notre code ici. D'accord, donc de toute façon, si ce n'était pas là, notez simplement que nous devons spécifier où vient ce code. Lorsque vous créez vous-même des programmes plus volumineux, vous pouvez créer vos propres espaces de noms aider à différencier la provenance de votre code. Et je vais vous montrer comment nous pouvons le faire maintenant. Alors laissez-moi aller de l'avant et supprimer tout cela ici. J'ai en fait la syntaxe pour créer votre propre espace de noms ici. Vous allez donc avoir le mot clé namespace suivi du nom de votre espace de noms. Et puis, entre crochets, vous aurez le code qui n'en fait pas partie ici. Allons-y et créons deux fonctions. Et ce sera un exemple assez simple, mais je devrais comprendre comment créer et utiliser un espace nommé ou un espace de noms. Nous allons donc dire nul. Imprimez Hello. Dans le code pour ça. Je vais juste dire échelle. Bonjour. Juste pour les différencier , car nous allons créer une autre fonction avec exactement le même nom, le même espace de noms Hello. Un. Juste comme ça. Ensuite, nous allons simplement créer une ligne vide. Ensuite, nous allons copier tout cela et le coller ci-dessous. Et nous allons changer celui-ci pour dire, je veux dire qu'elle a deux ans. Et actuellement, si nous devions simplement essayer d' appeler cette fonction en envoyant un bonjour et en exécutant notre code. Vous pouvez voir que nous allons recevoir une erreur. Cela est dû au fait que la fonction qui a un type de retour nul appelé print hello et qui ne possède aucun paramètre existe déjà. Nous ne pouvons donc pas avoir deux choses identiques. Et au fur et à mesure que votre code s'étendra le plus possible, vous rencontrerez le même problème vous pourriez avoir plusieurs fonctions le même nom simplement en raison leur lisibilité ou quelque chose comme ça. Et c'est un excellent exemple de cas où vous souhaiteriez créer un espace de noms. Ici, nous allons dire espace de noms. Appelez cet espace de noms un par souci de simplicité. Ensuite, nous aurons nos crochets bouclés ouverts et fermés , comme ça. Ensuite, nous allons simplement couper cette fonction supérieure ici et la coller à l'intérieur, comme ça. Ensuite, nous allons copier tout cela et le coller ci-dessous. Et nous allons simplement nous débarrasser de cette fonction supplémentaire et ici. Nous allons simplement le remplacer par l'espace de noms Hello en. Et maintenant, comme vous pouvez le constater, il ne sait pas du tout de quoi nous parlons. Et il est dit que print hello est complètement indéfini. Et c'est parce que, tout comme nos objets CN ou C out n'avons aucune idée de quoi nous parlons et nous allons réellement changer cet espace de noms en bas. Nous devons donc lui faire savoir d'où vient cette fonction print hello. Et nous pourrions faire la même chose avec notre espace de noms std ici, où nous l'avons juste placé juste avant. Nous pouvons donc dire espace de noms, un deux-points, deux points, comme ceci, imprimer bonjour. Ensuite, si nous copions cette ligne entière et que nous la collons ci-dessous, comme ça, changeons l' espace de noms et exécutons un code. Vous pouvez voir que cela fonctionne très bien et qu'il sait exactement lequel nous voulons utiliser car nous avons spécifié d'où vient ce code. Dans cet exemple, nous avons simplement utilisé une fonction de base, mais vous devez avoir toutes sortes de code dans un espace de noms. Et n'oubliez pas qu'un espace de noms nous permet de séparer notre code et d'être plus précis sur la provenance de ce code afin d'éviter les conflits et la dénomination. Ainsi, par exemple, nous avons ici deux fonctions portant le même nom, car elles font partie d'un espace de noms différent, nous pouvons spécifier d' où cela vient et ces noms ne seront pas du tout conflictuels . Maintenant, comme avant où nous avons dit que nous utilisions namespace std. Là-haut. Nous pouvons dire quelque chose comme les utiliser. Espace de noms, espace de noms. Et n'oubliez pas le point-virgule à la fin. Et maintenant, si je le voulais, je pourrais simplement me débarrasser de l' espace de noms 1 et exécuter notre code ici. Et cela fonctionnera très bien car j'ai déjà spécifié que je vais utiliser le code de ces espaces de noms. Maintenant, vous vous demandez peut-être si nous faisions la même chose avec noms pour exécuter à nouveau notre code ? Eh bien, comme vous pouvez le constater, nous avons eu une erreur et c'est parce qu'une fois de plus, il ne sait pas de quoi nous parlons ici. Cependant, notez que nous n'avons pas reçu d'erreur ici. Et c'est parce que nous avons deux espaces de noms que nous avons dit que nous allions utiliser. Et il y a un conflit dans la dénomination de ces deux fonctions, n'est-ce pas ? Parce que nous avons deux fonctions portant le même nom dans deux espaces de noms différents que nous avons dit utiliser. Maintenant. L'autre code de ces espaces de noms qui n'avait pas de conflit dans le nom ou le nom n'était pas le même. Nous ne rencontrerions pas d'erreur. Nous serions en mesure de les utiliser tous les deux séparément sans aucun problème. Donc, par exemple, si nous copions simplement cette fonction ici et que nous la collions en dessous et que nous faisions de même ici. Nous allons juste appeler celui-ci jusqu'à celui-ci. Et celui-ci en bas , imprime bonjour à, eh bien, je peux dire imprimer bonjour un, juste comme ça. Et je vais savoir de quoi je parle car il n'y a plus qu' une seule fonction portant ce nom dans tous les espaces de noms que nous avons dit utiliser dans notre code en général. Maintenant, ça va très bien fonctionner. Je peux les pondérer pour changer cela ici. Alors allez-y et faites-le. Et si je le lance à nouveau, vous pouvez voir qu'il l'imprime dans l'espace de noms 1 parce que c'est de là que vient ce code. Donc, si vous utilisez plusieurs espaces de noms et que vous l'avez explicitement indiqué en haut de la page. Et vous avez une fonction qui porte le même nom qu'une autre fonction, soit dans votre code ou dans l' un des espaces de noms ici, vous devez spécifier d' où elle vient, comme nous l'avons fait ici. Donc, imprimez Hello to, nous pourrions utiliser normalement et imprimer Hello, celui que nous pourrions utiliser normalement. Cependant, imprimez bonjour maintenant, car nous en avons deux avec le même nom, il suffit de le spécifier. Donc, comme nous l'avons fait ici, là-haut, l'espace de noms, un, deux points, deux points comme ça, exécutez notre code. Comme vous pouvez le constater, tout fonctionne très bien. Alors, tu y vas. C'est ainsi que vous créez un espace de noms. Il suffit de dire espace de noms suivi d'un nom, puis d'un ensemble de crochets avec votre code à l'intérieur. Ensuite, si vous souhaitez utiliser le code de cet espace de noms, vous pouvez soit le faire explicitement comme ceci, soit indiquer explicitement votre code en haut, hé, je vais utiliser le code de cet espace de noms. Et cela vous aidera simplement à trier votre code afin de savoir exactement d' où il vient, ainsi qu'à éviter les conflits noms avec des fonctions, des variables, etc. Donc voilà. Quoi qu'il en soit, merci de m'avoir regardé, et je te verrai dans la prochaine. 99. Chapitre 15 (classes) : Tableaux d'objets: Dans cette vidéo, nous allons parler de la création de tableaux de classes et de la façon dont nous pouvons également travailler avec cela. Donc, d'abord, en haut, nous allons créer une nouvelle classe. Et disons quelque chose comme la classe. Article. Dans notre code, vous trouverez ici quelque chose comme ceci. On va dire chaîne, nom, puis or, comme ça. Et allons-y et rendons ces deux variables privées. Et n'oubliez pas que cela a été fait par défaut. Mais nous allons juste y aller et l'avoir. C'est explicitement parce que là-haut, avec nous, nous allons créer des méthodes publiques avec lesquelles travailler. Donc on va dire public, comme ça. Ensuite, nous allons créer deux fonctions, créer une appelée élément. Et cela n'allait pas prendre paramètres et il n'y aurait pas de type de retour non plus. Nous allons donc simplement dire article nul. Alors pour cela, nous dirons « nul ». Et nous n'aurons aucun périmètre pour cela non plus. Notre classe ressemble donc maintenant à ceci. Ensuite, nous allons créer les définitions de ces deux fonctions dans la classe inférieure. Je vais donc le copier ici, coller vers le bas, et le copier et le coller également. Ensuite, nous devons dire clairement d' où ils viennent. Donc, nom de la réplique, nous allons dire article deux-points, deux-points, juste comme ça. Et nous ferons de même ici. Ensuite, nous avons besoin des crochets pour définir chaque méthode. Ensuite, à l'intérieur de l'ensemble, nous allons procéder comme suit. Nous allons dire CL, nom de l'article, espace deux-points comme cela sur celui-ci. Et puis en dessous, ce qu'ils voient. Ensuite, nous créons une ligne blanche, comme ça. Ensuite, nous imprimerons l'espace de coût de l'article. Et nous allons également mettre un point-virgule à la fin de celui-ci. Ensuite, on dira C et on repartira comme ça. Ensuite, ci-dessous, nous allons imprimer ces deux variables. Nous allons donc dire le nom CL, suivi d'un espace. Espace. Nous ferons un suivi avec les frais de coca. Encore une fois, entre guillemets, nous dirons des pièces d'or spatiales et mettrons un point-virgule à la fin. Et en fait, il ira de l'avant et créera également une nouvelle ligne à la fin de cela. Faites-vous, d'accord, alors assurez-vous que toute votre classe correspond à la mienne ici. Et pour ce qui est de notre fonction principale, nous allons dire que la taille de const int est égale à trois. Ensuite, en bas, cela créera une boucle for. Donc disons que pour int je suis égal à 0, I inférieur à la taille I plus, plus. Alors allons-y, copiez-le et collez-le ci-dessous. Maintenant, nous avons 24 boucles. Nous allons le parcourir trois fois ici. Et puis, en dessous d'une constante, nous allons créer un tableau d'éléments types. Item, je vais appeler ça des articles. Puis entre crochets. Nous allons dire taille. Qu'est-ce qui permet de mettre un point-virgule à la fin comme ça ? Ensuite, dans notre première boucle for, nous allons dire item à l'index i. Puisque cela va passer de 0 à deux, qui est le même indice que celui de notre tableau d'éléments actuellement, car il s'agit d'une taille de trois. Et puis, après avoir fermé le crochet , nous allons simplement dire point, élément défini, parenthèses ouvertes et fermées, et un point-virgule à la fin. Ainsi, chaque fois qu'il passe par notre boucle for ici, il passe en revue les différents éléments de notre tableau d' types et exécute ce code ici à partir de notre fonction d'élément défini. Nous allons simplement demander le nom d'un article puis nous allons insérer un nom, puis je vais demander un article, coût de l' or, et nous l' insérerons également. Ensuite, dans notre deuxième boucle pour, nous allons dire articles à l'index I, article imprimé. Ensuite, ajoutons simplement un peu de texte contextuel dans chacune de ces boucles, n'est-ce pas ? Donc on va dire espace pour les objets et on imprime I plus un. Et je vais poursuivre avec l'espace. Étapes. Dit deux-points , puis créera une nouvelle ligne par la suite. Donc, nous allons simplement dire backslash n. Ok, donc maintenant ça va très bien fonctionner. Copiez-le et collez-le également dans notre autre boucle pour. Ensuite, si nous revenons à notre article, nous allons simplement supprimer ce surplus et envoyer le mien. Ça va déjà tomber une fois que nous avons inscrit le nom ici. Très bien, puis allons-y et exécutons notre code. Et comme vous pouvez le voir, c'est pour l'article sur les statistiques. Et je vais juste appeler ça pomme. Donnez-lui un objet en or pour l'appeler orange. Coût de trois. Enfin, je vais dire quelque chose comme de la noix de coco et lui donner un coût de cinq. Ensuite, vous pouvez voir que nous avons imprimé les statistiques de chaque objet. Je ne voulais donc pas de statistiques. Apple coûte à des pièces d'or, objet à des statistiques, des colonnes oranges, trois, un objet à travers des statistiques, une noix de coco cause cinq et ils partent. C'est ainsi que vous pouvez travailler avec un ensemble d'objets. Vous allez créer un tableau normal avec le type étant le nom de classe tel quel, le type avec lequel nous voulons travailler , le nom du tableau, comme d'habitude et votre taille comme d'habitude. Ensuite, il vous suffit d'utiliser votre opérateur d'accès aux membres pour travailler avec les membres disponibles de chaque classe. D'ailleurs, si vous travaillez avec une collection du type de classe de base et que vous insérez ensuite des éléments d'un type de sous-classe. Donc, par exemple, si nous avions eu un vecteur d' animaux auparavant et que nous avions ensuite inséré des objets pour chats et chiens. Vous devez travailler avec un véritable tableau de pointeurs vers ces objets et non vers les objets et les cellules. Et c'est parce que chaque sous-classe aura une taille et une mémoire variables. Alors que si vous aviez juste un pointeur vers chacun de ces objets de sous-classe dans votre conteneur, tous les pointeurs occuperont la même quantité de mémoire et vous n' aurez aucun problème. Donc, comme je l'ai dit, si vous travaillez avec le conteneur d' un type de classe de base et que nous aurons des éléments de vos types de sous-classes. Comme cela fonctionnera, assurez-vous de travailler avec un ensemble de pointeurs vers ces objets, et pas seulement vers ces objets eux-mêmes. De cette façon, ils occupent tous la même quantité de mémoire et vous n' avez aucun problème. Quoi qu'il en soit C'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 100. Chapitre 15 (cours) : séparer les fichiers: Dans cette vidéo, je vais vous montrer comment séparer vos classes en fichiers séparés. L'un étant un fichier d'en-tête et l'autre un fichier CPP, ce qui, si vous regardez en haut, est ce avec quoi nous avons travaillé pendant tout ce temps. Et cela inclut des déclarations avec lesquelles nous avons travaillé, qui nous permettent également d'accéder aux fichiers d' en-tête d'autres classes. Et je vais vous montrer comment accéder à nos propres fichiers de classe ou les inclure. Et cela va vraiment vous permettre d' organiser votre code et de l'utiliser dans plusieurs programmes, car vous pourrez simplement accéder au fichier qu'il n'est pas. Alors allons-y. abord, ici au sommet, nous allons dire classe. Et appelons-le simplement ma classe. Et puis à l'intérieur, nous allons simplement créer une fonction de base. Nous allons donc dire annuler, imprimer, ouvrir et fermer des parenthèses et un point-virgule à la fin. Ensuite, nous allons définir cette fonction en dehors de notre classe. Parce que si vous vous en souvenez, c'est la bonne façon de définir les fonctions de vos classes. Donc disons garçon dans ma classe, deux-points, deux-points ou l'opérateur de résolution de la portée, suivi de parenthèses ouvertes et fermées. Ensuite, nous aurons notre bloc de code ci-dessous. Et à l'intérieur de cela, nous allons dire que CL fonctionne exactement comme ça. Et vous y voilà. Voyons comment nous pouvons maintenant le diviser correctement en plusieurs fichiers. Maintenant, il suffit d'ajouter quelques commentaires ici. Donc, votre déclaration de classe va entrer dans ce qu'on appelle un fichier d'en-tête. Très bien, donc ça va entrer dans un fichier d'en-tête. Ensuite, vos définitions de tout ce que vous avez déclaré seront insérées dans le fichier cpp. Hein ? Alors allons-y et faisons-le. Ensuite, dans notre fonction principale, Allons-y et imprimons également. Avant de l'imprimer, créons une nouvelle ligne. Donc disons M9, fin de la partie principale, comme ça. Maintenant, je vais juste vous montrer comment faire cela dans Visual Studio. Cela étant dit, je vous recommande de suivre quoi qu'il en soit , car vous pourriez apprendre quelque chose en cours de route, et selon le programme que vous utilisez pour écrire votre code en C plus plus, vous devriez être capable de faire quelque chose similaire là-dedans également. Et il vous suffira de rechercher les quelques différences et de savoir comment créer les fichiers eux-mêmes. Maintenant, ce que nous allons faire, c'est aller ici vers notre Explorateur de solutions sur la droite. Et si vous ne le voyez pas, vous pouvez monter en haut de la page et cliquer sur Afficher, puis sur Explorateur de solutions. Donc, tout ce que nous allons faire est de cliquer avec le bouton droit de la souris ici et dans l'Explorateur de solutions, de descendre sur Ajouter, puis de cliquer sur Nouvel élément, puis de cliquer à l'endroit où il est écrit Et ici, en bas, au lieu de la source, nous allons taper le nom de la classe que nous voulons créer. Dans ce cas, nous allons dire ma classe et nous assurer qu'elle y est orthographiée de la même manière. Ensuite, allez-y et cliquez sur Ajouter. Et maintenant, vous pouvez voir que notre nouveau fichier se trouve ici, en haut de la page. Ensuite, nous allons à nouveau cliquer avec le bouton droit sur notre explorateur de solutions, descendre dans Ajouter, cliquer sur Nouvel élément et aller à l' endroit où il est indiqué « fichier d'en-tête ». Ensuite, changez le nom ici en ma classe point h. Et encore une fois, assurez-vous qu'il est correctement orthographié et avec les bonnes majuscules. Eh bien, j'ajoute encore une fois. Et nous y voilà. Ensuite, si nous revenons à notre fichier principal ici et supprimons tout ce qui se trouverait dans notre fichier d'en-tête. Ensuite, nous allons revenir à notre fichier d'en-tête, qui est indiqué par ma classe point h, et le coller là. Ensuite, nous reviendrons à notre fichier principal et supprimerons nos définitions de classes. Accédez à notre fichier CPP et collez-le également. Et vous remarquerez instantanément que notre dossier CPP ne contient aucune idée de ma classe. Et c'est parce que, tout comme dans notre fichier principal où nous avons inclus ces fichiers d'en-tête ici, nous devons faire de même et faire de même pour notre fichier CPP. Donc, ce que nous allons faire, je dis hashtag. J'espère. Ensuite, chaque fois que vous travaillez avec ou ajoutez un fichier d'en-tête créé par l'utilisateur et non un fichier intégré à C plus plus plus. Au lieu du symbole inférieur à et supérieur à, vous allez utiliser des guillemets doubles comme celui-ci. Ensuite, nous allons dire ma classe point h. Maintenant, vous remarquerez qu'elle ne comprend pas ce que signifie C out. Et c'est parce que cela fait partie d'un autre fichier d'en-tête. Et si nous passons simplement la souris dessus, vous pouvez voir que vous pouvez appuyer sur Alt Enter pour afficher les correctifs potentiels. Et tout ce que je veux faire, c'est inclure le fichier iostream. Veuillez donc cliquer dessus, cela sera ajouté en haut. Et nous devons encore inclure d' où cela vient. Donc, encore une fois, nous pouvons appuyer sur Alt, Enter sur Visual Studio et ajouter std, suivi de l'opérateur de résolution de la portée et de C out. Ou nous pouvons faire ce que nous faisions auparavant et l'ajouter en utilisant namespace, std. Nous aurions pu simplement saisir tout cela manuellement, mais je voulais juste montrer à ceux d'entre vous qui utilisent Visual Studio. Une autre façon de corriger rapidement notre code. Ensuite, si nous revenons à notre fichier principal, nous pouvons continuer et inclure notre fichier d'en-tête de ma classe. Nous dirons donc que le hashtag inclut. N'oubliez pas que nous allons le mettre entre guillemets. Et comme vous pouvez le voir dans Visual Studio nos options apparaissent déjà ici. Nous pouvons donc double-cliquer sur l' endroit où apparaît ma classe point h, et je vais l'imprimer pour nous. Ensuite, ici, nous pouvons créer un objet ou une instance de notre classe. Donc, dites mon cours. Ce cours. Et puis pour accéder à notre fonction depuis ma classe, nous devons revenir à notre fichier d'en-tête et créer cette fonction. N'oubliez pas que nous allons simplement dire public suivi de deux points, puis mettre notre déclaration de fonction en dessous. Ensuite, si nous revenons à notre fichier principal maintenant, nous pouvons enregistrer cette empreinte de points de classe en utilisant des parenthèses et un point-virgule à la fin. Et maintenant, si nous exécutons un code, tout va bien fonctionner. Comme vous pouvez le voir, j'ai imprimé comme fonctionnel et fin de main. Une autre chose que je voulais mentionner, c'est que si vous finissez par clore l'un de ces dossiers par accident. Supposons que je ferme le fichier d'en-tête dans votre explorateur de solutions. Sous les fichiers d'en-tête, vous pouvez le voir ici. Il suffit de double-cliquer dessus et cela s'ouvrira directement. Et puis votre fichier CPP se trouve ici sous les fichiers sources et notre fichier CPP principal, et il y a aussi sous les fichiers sources. Une dernière chose que je veux vous montrer est la suivante. Si nous revenons à notre fichier d'en-tête pour ma classe, vous pouvez voir que nous avons déjà eu ces hashtags pragma. Cela permet de s'assurer que notre fichier d'en-tête n'est inclus qu'une seule fois. Et pour vous montrer exactement ce que cela fait, si nous revenons à notre fichier principal ici et que nous copions notre fichier d' en-tête d'inclusion , le collons à nouveau et exécutons notre code. Comme vous pouvez le voir, cela fonctionne très bien. Et c'est parce que ce hashtag pragma disait autrefois : chaque fois que nous incluons notre fichier d'en-tête ici ou que nous disons que nous voulons l'inclure, il vérifiera s'il l'a déjà la déclaration pour ma classe, qui, si vous vous en souvenez, est tout ce qui se trouve dans votre fichier d'en-tête est essentiellement cette déclaration pour une classe. Et si c'est le cas, la déclaration d'inclusion est ignorée. Et si ce n'est pas le cas, il ajoutera la déclaration. Donc, la première fois que j'ai lu et ajouté ma déclaration de classe et la deuxième fois, elle l'a ignorée. Cependant, tous les compilateurs ne supportent cette directive pragmatique en haut de la page. Et je ne vais pas m'étendre sur ce que sont les réalisateurs à peu près chaque fois que vous verrez ce symbole de livre ou de hashtag ici, ou avec ce hashtag ou cette livre incluse, c'est une sorte de directive. Et comme je l'ai dit, je ne vais pas m'y attarder, mais en gros, tous les compilateurs ne les supportent pas. Je vais donc vous montrer une alternative, et je vais également vous montrer ce qui se passerait si nous n'avions pas cela. Donc maintenant, si nous essayons de relancer notre programme, vous pouvez voir que nous allons avoir une erreur. C'est parce que nous avons essayé de redéfinir cette classe. Donc, une autre façon de résoudre ce problème est d'utiliser ce que l' on appelle un idiome de garde. Et tout ce que nous avons à faire, c'est dans notre fichier d'en-tête, nous allons dire hashtag si N def, puis en dessous cela dira hashtag define. Et puis, à la fin de notre fichier d'en-tête, nous dirons hashtag. Et à la fin de notre f et de notre définition ici, nous allons ajouter le nom de notre fichier d'en-tête qui est ma classe en majuscules. Donc, je vais dire le trait de soulignement de ma classe, puis H. Et c'est une convention de dénomination courante lorsque l'on travaille avec un protecteur d' en-tête et/ou un idiome de garde. Ce que nous avons ici ou le pragma que vous avez vu auparavant. Donc, tout ce que vous allez faire est d'avoir le nom de votre fichier d'en-tête en majuscules. Et puis, au lieu d'un régime, vous allez avoir un trait de soulignement. Donc, là-haut, il est écrit mon point h de classe ici, nous avons le trait de soulignement de ma classe, l'âge et toutes les majus Comme je l'ai dit, il s'agit simplement d'une convention de dénomination très courante. Ensuite, nous ferons de même après avoir trouvé. Voyons donc ce que cela signifie. Maintenant, si vos compilateurs supportent le hashtag pragma autrefois , n'est-ce pas ? Tu peux juste laisser ça en haut. Toutefois, si ce n'est pas le cas, il s'agit d'un autre protecteur d'en-tête, le format que vous pouvez utiliser et qui devrait être pris en charge. Voyons donc ce que tout cela signifie. Nous avons donc d'abord les hashtags F et F. Cela signifie que s'ils ne sont pas définis, et que vérifions-nous ? S'il n'est pas défini, c'est ce fichier d' en-tête ici, et c'est le nom que nous donnons à notre fichier d'en-tête ici. En gros, vous pouvez consulter ici tout ce qui a été adopté par cette directive en tant que corps de notre déclaration if. Donc, si mon fichier d'en-tête de classe n'est pas défini, alors nous voulons le définir. Et ici, nous devons terminer notre déclaration IF. Mais au lieu de le terminer par un crochet bouclé fermé, nous allons dire hashtag et non ? Et n'oubliez pas que c'est ce qu'on appelle un protecteur d'en-tête si vous voulez y jeter un œil plus approfondi. Et comme je l'ai déjà dit , ils vont faire exactement la même chose que le pragma une fois. Donc, si votre site de support de compilateur, génial. Il ne suffit pas d'ajouter ce qui suit à votre fichier d'en-tête. Pound si N def est suivi de votre nom d'en-tête, alors vous allez dire hashtag défini avec le même nom juste en dessous. Et puis à la toute fin, vous allez dire hashtag. Et puis n'oubliez pas que votre fichier d'en-tête inclut toutes vos déclarations de classe, c'est pourquoi j'ai dit dans le passé que nous voulions séparer nos déclarations de nos définitions. Et puis, dans notre fichier CPP, nous avons toutes nos directives d' inclusion. Et je sais que j'ai fait ces déclarations tout au long du cours, mais ce sont techniquement des directives. Vous aurez donc toutes vos directives d'inclusion, toutes les directives utilisant les espaces de noms que vous pourriez vouloir utiliser, puis vos définitions de classe. Ensuite, dans votre fichier principal, vous devez inclure votre fichier d'en-tête de classe si vous souhaitez utiliser cette classe. Et nous pouvons ajouter autant de fichiers d'en-tête et fichiers CPP que nécessaire pour diviser notre code ici. Et n'oubliez pas que tout ce que nous avions à faire pour cela cliquer sur le nom de notre programme juste en dessous de la solution, de cliquer avec le bouton droit de la souris, de descendre sur Ajouter, puis sur Nouvel élément. Ensuite, nous avons ajouté chaque fichier individuellement. Et maintenant, même si nous avons deux déclarations pour notre fichier d'en-tête, comme lorsque nous avions notre directive Pragma Once, notre nouveau protecteur d'en-tête que nous venons de créer fonctionnera. Donc, si nous l'exécutons, vous pouvez voir que cela fonctionne très bien. Maintenant, dans un petit programme, vous n' ajouterez probablement pas deux fois accidentellement votre fichier d'en-tête ou n'essaierez de redéfinir la classe deux fois comme ceci. Mais lorsque vous commencez à travailler avec des programmes beaucoup plus importants, ils peuvent certainement devenir un problème. Vous devez donc vous assurer de pouvoir éviter cela en utilisant des protections d'en-tête, soit en utilisant le hashtag pragma une fois si votre compilateur prend en charge le kit, soit vous pouvez simplement utiliser le hashtag if and death hashtag define et hashtag et F, comme nous l'avons fait ici. Alors, tu y vas. C' est ainsi que vous pouvez diviser vos cours en fichiers individuels. Et puis cela vous permettra également d'utiliser vos classes dans d'autres programmes. Et j'espère que cela explique pourquoi nous avons séparé nos déclarations de classe de nos définitions de classe, car cela permet de les couper et de les coller très facilement dans les fichiers séparés selon les besoins. Et rappelez-vous que tout ce que notre protection de tête a fait nous permettre de redéclarer accidentellement est nous permettre de redéclarer accidentellement notre classe sans aucun problème. Je vais donc procéder et supprimer ceci. Maintenant, il y a des cas spécifiques où vous ne voulez pas vraiment leur garde, mais la plupart du temps vous le ferez. Et si vous voulez savoir quand vous ne le voudriez pas, n'hésitez pas à le faire. Mais je ne vais pas aborder cela dans ce cours de toute façon, c'est tout pour cette vidéo. Merci de m'avoir écouté , et à bientôt. 101. Félicitations ! : Félicitations pour avoir terminé ce cours. Vous avez fait un grand pas en avant dans votre parcours de programmation, et vous devriez être très fier de tout ce que vous avez accompli ici. Si vous avez apprécié le cours ou si vous l'avez trouvé utile de quelque manière que ce soit, nous vous en serions très reconnaissants. Si vous pouviez nous laisser un commentaire positif. Vos commentaires nous aident non seulement à nous améliorer, mais ils encouragent également les autres à commencer leur parcours ici. Maintenant, essayez de vous remémorer quand vous avez commencé. L'idée de coder est probablement devenue irrésistible. Maintenant, regarde le chemin que tu as parcouru. Vous avez maîtrisé les fondamentaux, exploré des sujets avancés et acquis les compétences nécessaires pour commencer à créer vos propres projets Maintenant que vous avez terminé ce cours, étape suivante consiste à mettre ces compétences en pratique. Un excellent moyen de consolider ce que vous avez appris est de vous attaquer à un petit projet gérable, que vous pouvez terminer en deux à quatre semaines Et je recommande vivement de commencer par cloner une application simple existante des fins non commerciales, bien sûr Et en créant quelque chose qui existe déjà, vous pouvez vous concentrer sur le fonctionnement de chaque fonctionnalité et sur la manière de les implémenter vous-même plutôt que de la concevoir à partir de zéro. Une fois que c'est fait, essayez d'ajouter votre touche personnelle ou développer le concept dans le cadre d'un deuxième projet. C'est un moyen fantastique de mettre en pratique et libre cours à votre créativité tout renforçant votre confiance en vos compétences. À partir de là, vous pouvez commencer à vous lancer dans vos propres projets plus grands, meilleurs et plus uniques Et n'oubliez pas qu'il est parfaitement normal de revenir et de revoir le matériel de cours pendant que vous travaillez sur vos propres projets La programmation consiste à apprendre au fur et à mesure. Même les développeurs saisonniers font constamment des recherches, qu'il s'agisse de se rafraîchir la mémoire ou de résoudre un nouveau problème. L'utilisation de ressources telles que ce cours ou Internet n'est pas une faiblesse. Cela fait partie du fait d'être un bon programmeur. Maintenant, ce n'est que le début. Que vous travailliez sur votre premier projet, reveniez pour rafraîchir vos connaissances ou plongiez dans un autre de nos cours, les connaissances que vous avez acquises ici seront votre tremplin vers des réalisations encore plus importantes. En parlant de cela, n'oubliez pas de consulter nos autres contenus pour plus d'opportunités d'apprentissage. Et si ce n'est pas déjà fait, pensez à nous laisser votre avis pour partager votre expérience. Cela fait vraiment une différence, et nous aimerions avoir de vos nouvelles. De la part de tous les membres de Primoris Arts, félicitations encore une fois pour cette étape importante Nous sommes impatients de voir ce que vous allez créer ensuite, continuer à apprendre, de rester curieux et de nous rappeler que le ciel est la limite. Bravo et bonne chance pour ta prochaine aventure.