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.