Tutoriels de programmation - page 3
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Constructeurs OOP - Types de constructeurs que vous devez connaître (de base à la maîtrise)
Constructeurs OOP - Types de constructeurs que vous devez connaître (de base à la maîtrise)
Dans cette vidéo, nous discuterons des différents types de constructeurs, de leur objectif et de la raison pour laquelle ils sont essentiels à la programmation. Je vais fournir des exemples et expliquer le fonctionnement en arrière-plan des constructeurs. Mais avant de plonger, je veux recommander un outil que j'utilise depuis des années appelé PBS Studio. C'est un puissant analyseur de code statique qui aide à détecter les bogues et à améliorer la qualité du code. Il s'intègre facilement à divers IDE et prend en charge des langages tels que C, C++, C# et Java. Vous pouvez trouver le lien de téléchargement et même découvrir des moyens de l'obtenir gratuitement si vous êtes étudiant. Maintenant, revenons à la vidéo.
Pour commencer, créons une classe appelée "User" avec des membres publics : "firstName", "lastName", "age" et "email". Actuellement, nous attribuons manuellement des valeurs à ces propriétés pour chaque utilisateur que nous créons. Cependant, cette approche devient impraticable à mesure que le nombre d'utilisateurs augmente.
Au lieu de cela, nous explorerons une meilleure solution en utilisant les constructeurs. Les constructeurs sont utilisés pour construire des objets et ils automatisent le processus d'initialisation des propriétés des objets. Nous commencerons par expliquer le fonctionnement en arrière-plan des constructeurs à l'aide d'exemples.
À des fins de démonstration, supprimons le deuxième utilisateur et imprimons les informations du premier utilisateur. En exécutant le programme, vous remarquerez que la sortie affiche des valeurs vides pour firstName, lastName et email, et un nombre grand ou petit pour l'âge. Nous allons explorer pourquoi cela se produit et l'absence d'erreurs.
La raison de ce comportement est le constructeur par défaut fourni par C++. Il initialise les propriétés avec des valeurs par défaut, telles que le grand nombre que nous voyons pour l'âge. Cependant, lorsque nous créons une variable simple, comme "test", sans l'initialiser, nous rencontrons une erreur car les types simples n'ont pas de constructeurs par défaut.
Examinons maintenant les caractéristiques des constructeurs. Premièrement, les constructeurs ont le même nom que la classe et aucun type de retour. Deuxièmement, ils doivent être placés dans la section publique de la classe. Troisièmement, les constructeurs par défaut n'ont pas de paramètres. Quatrièmement, C++ génère automatiquement un constructeur par défaut si vous n'en créez pas. Cinquièmement, les constructeurs paramétrés reçoivent des paramètres pour initialiser les propriétés de l'objet. Enfin, un constructeur par défaut est appelé automatiquement lorsqu'un objet de cette classe est créé.
Implémentons notre propre constructeur par défaut en attribuant des valeurs par défaut aux propriétés. Avec ce changement, chaque fois que nous créons un utilisateur, notre constructeur par défaut sera invoqué. Maintenant, lorsque nous imprimons les informations de l'utilisateur, nous verrons les valeurs par défaut que nous avons attribuées.
Passons à autre chose, explorons le deuxième type de constructeur, le constructeur paramétré. Contrairement au constructeur par défaut, le constructeur paramétré accepte des valeurs spécifiques comme paramètres et les utilise pour instancier des propriétés d'objet. Je vais donner un exemple de constructeur paramétré qui prend des paramètres pour firstName, lastName et age.
Avec ces paramètres, nous pouvons attribuer les valeurs fournies aux propriétés correspondantes. Cela nous permet de créer des utilisateurs avec des informations spécifiques directement lors de la création de l'objet.
Cela couvre les bases des constructeurs et leur utilisation. Restez à l'écoute pour plus d'exemples et d'informations dans les prochaines vidéos.
Fonctions amies et cours en C++ (Programmation pour débutants)
Fonctions amies et cours en C++ (Programmation pour débutants)
Dans cette vidéo, je suis ravi de vous parler des fonctions d'amis et des classes d'amis en C++. Ce concept d'amitié dans la programmation est similaire à l'amitié dans la vraie vie. Tout comme vos amis ont accès à des zones privées de votre vie que d'autres n'ont pas, les fonctions d'amis et les classes d'amis dans la programmation orientée objet ont accès aux membres privés et protégés d'une classe.
Dans cette vidéo, vous apprendrez comment et quand utiliser les fonctions d'amis et les classes d'amis. Pour démontrer, nous utiliserons Visual Studio Community, et je vous présenterai également une excellente extension appelée Visual Assist. Vous trouverez le lien de téléchargement dans la description ci-dessous. Visual Assist est un assistant de codage intelligent que de nombreux développeurs professionnels utilisent, en particulier pour les grands projets ou le développement de jeux avec des moteurs comme Unreal Engine. Il améliore la complétion du code, propose des suggestions intelligentes pour la refactorisation, fournit des extraits de code et améliore la navigation et la recherche dans votre projet.
Maintenant, plongeons dans le sujet des fonctions d'amis. Pour expliquer ce concept, créons un problème et résolvons-le en utilisant des fonctions amies. Nous allons créer une classe appelée "EquilateralTriangle" pour représenter un triangle dont les trois côtés ont la même longueur. La classe aura des variables privées pour la longueur du côté, la circonférence et la surface. Nous ajouterons également une méthode de setter publique pour définir la longueur du côté et calculer la circonférence et la surface dans cette méthode.
Cependant, si nous essayons d'accéder aux membres privés en dehors de la classe, nous rencontrerons des erreurs. Une solution consiste à rendre publics les membres privés ou à créer des getters publics, mais cela les expose à tout le monde. Au lieu de cela, nous pouvons utiliser des fonctions d'amis pour accorder l'accès de manière sélective. Nous allons créer une fonction globale appelée "PrintResults" qui imprimera la circonférence et l'aire du triangle. En déclarant cette fonction comme amie de la classe EquilateralTriangle, elle accède aux membres privés.
Mais rappelez-vous, choisissez soigneusement vos fonctions amies et évitez une utilisation excessive pour maintenir l'encapsulation. De plus, en C++, vous pouvez également avoir des classes d'amis. Si nous déplaçons la fonction "PrintResults" dans une classe appelée "Homework" et en faisons une fonction membre publique, nous pouvons déclarer "Homework" comme une classe amie de "EquilateralTriangle". De cette façon, la classe "Homework" peut accéder aux membres privés et protégés de "EquilateralTriangle".
Il est important de noter que l'amitié en programmation n'est ni réciproque ni héritée. Utilisez judicieusement les fonctions amies et les classes amies, et rappelez-vous que l'héritage et la surcharge des opérateurs impliquent également des cas d'utilisation courants pour les fonctions amies. Regardez ma vidéo sur la surcharge des opérateurs (liée dans la description) pour plus d'informations et un devoir connexe.
J'espère que vous trouverez cette vidéo utile pour comprendre et utiliser les fonctions d'amis et les classes d'amis dans vos projets de programmation. Restez à l'écoute pour plus de contenu passionnant et n'oubliez pas de consulter l'extension Visual Assist pour Visual Studio !
Destructeurs en programmation : démonstration pratique
Destructeurs en programmation : démonstration pratique
Dans cette vidéo, je vais vous parler des destructeurs en programmation. Vous apprendrez ce que sont les destructeurs, comment les utiliser et quand les utiliser. Assurez-vous de regarder l'intégralité de la vidéo car j'ai une surprise spéciale pour vous à la fin. Avant de plonger dans les destructeurs, il est important de comprendre les constructeurs. Si vous n'êtes pas familier avec les constructeurs, regardez ma vidéo précédente liée ici et dans la description.
Les destructeurs sont des fonctions spéciales appelées lorsqu'un objet est détruit. Ils effectuent les tâches de nettoyage nécessaires, telles que la libération de ressources telles que la mémoire ou les fichiers détenus par l'objet. Ne pas libérer ces ressources peut dégrader les performances, la stabilité et entraîner des fuites de mémoire.
Avant de commencer à discuter des destructeurs, je veux vous présenter un outil que j'aime utiliser appelé PBS Studio. C'est un analyseur de code statique qui m'aide à écrire un meilleur code sans bogues. Il analyse votre code à la recherche de problèmes et de bogues potentiels, vous faisant gagner du temps et de l'argent en détectant les erreurs avant qu'elles ne soient mises en production. Il est facile à intégrer aux IDE populaires et prend en charge plusieurs langages de programmation. Vous pouvez le télécharger à partir du lien dans la description et l'essayer gratuitement. Si vous êtes étudiant, consultez leur site Web pour des options gratuites.
Passons maintenant aux destructeurs. Un destructeur est une fonction spéciale avec un nom identique au nom de la classe, précédé d'un tilde (~). Il n'a pas de type de retour, ne reçoit aucun paramètre et doit être placé dans la section publique de votre classe. Il ne peut y avoir qu'un seul destructeur par classe.
Pour illustrer les destructeurs, créons une classe appelée "Book" avec deux propriétés : "title" et "author". Nous allons également créer un constructeur et un destructeur. N'oubliez pas que le destructeur doit désallouer toutes les ressources détenues par l'objet.
Dans le constructeur, nous assignerons les paramètres passés aux propriétés correspondantes. À l'intérieur du destructeur, nous afficherons un message indiquant que le destructeur a été invoqué pour un livre spécifique.
Maintenant, créons des objets de livre pour voir quand le constructeur et le destructeur sont invoqués. Nous allons déboguer le programme et observer l'ordre d'invocation.
Si votre classe n'implique pas de pointeurs, le compilateur gérera automatiquement la désallocation de mémoire. Cependant, si vous travaillez avec des pointeurs, vous devez libérer manuellement de la mémoire dans le destructeur pour éviter les fuites de mémoire. N'oubliez pas d'utiliser "delete[] arrayName" pour les tableaux et définissez les pointeurs sur nullptr après la désallocation.
J'espère que cette vidéo vous a aidé à comprendre les destructeurs et leur importance dans la gestion des ressources. Dans ma prochaine vidéo, nous explorerons les constructeurs de copie, alors restez à l'écoute.
Constructeurs de copie C++ (tutoriel convivial pour les débutants + exemples pratiques)
Constructeurs de copie C++ (tutoriel convivial pour les débutants + exemples pratiques)
Salut tout le monde, bienvenue sur ma chaîne. Dans cette vidéo, je vais vous parler des constructeurs de copie, qui est un sujet important mais déroutant pour les débutants. Avant de regarder cette vidéo, assurez-vous de regarder ma vidéo précédente sur différents types de constructeurs, y compris les constructeurs par défaut et paramétrés (lien dans la description). Consultez également ma vidéo sur les pointeurs et les tableaux dynamiques (lien dans la description) car elle vous aidera à mieux comprendre ce sujet.
Dans cette vidéo, je vais vous expliquer tout ce que vous devez savoir sur les constructeurs de copie. Les débutants comprennent souvent le concept derrière les constructeurs de copie, mais ont du mal à comprendre quand et comment les utiliser, ainsi que les bogues et erreurs potentiels qui peuvent survenir. Je couvrirai tous ces aspects étape par étape.
Commençons par examiner le code de ma vidéo précédente. J'ai créé une classe appelée "Livre" avec des propriétés telles que le titre, l'auteur et un pointeur appelé "tarifs". Le pointeur "tarifs" représente un tableau dynamique dans lequel les utilisateurs peuvent saisir des notes pour le livre. Il existe également un "compteur de taux" pour suivre la taille du tableau. Si vous n'êtes pas familier avec les pointeurs et les tableaux dynamiques, je vous recommande de regarder ma vidéo sur ce sujet (lien dans la description).
J'ai implémenté un constructeur paramétré pour la classe Book, qui prend le titre et l'auteur comme paramètres et crée un objet livre basé sur ces valeurs. J'ai également inclus un destructeur, qui est important pour libérer la mémoire allouée par le constructeur. Il est crucial d'utiliser un analyseur de code comme PVS-Studio pour détecter les erreurs cachées et les faiblesses de votre code. Je recommande personnellement d'utiliser PVS-Studio car il est efficace pour trouver les erreurs et fournir des suggestions pour les corriger. Vous pouvez le télécharger gratuitement en utilisant le lien dans la description.
Maintenant, concentrons-nous sur le sujet des constructeurs de copie. Le but d'un constructeur de copie est de créer un nouvel objet basé sur un objet existant. Il vous permet de faire une copie d'un objet et de l'utiliser pour en créer un nouveau. Par défaut, C++ fournit un constructeur de copie par défaut. Cependant, lorsque vous travaillez avec des pointeurs, il est nécessaire de créer un constructeur de copie personnalisé pour éviter les erreurs.
Sans constructeur de copie personnalisé, l'utilisation de pointeurs peut entraîner des exceptions et des erreurs. Considérons le scénario suivant : Je veux créer « Book3 » basé sur les données de « Book1 ». Je souhaite copier toutes les propriétés de "Book1" pour créer "Book3". C'est là que le constructeur de copie entre en jeu.
Pour créer un constructeur de copie, suivez ces règles :
Créons le constructeur de copie. Dans le constructeur de copie, nous recevrons l'objet d'origine en tant que référence constante (const Book& original). Cela empêche toute modification de l'objet d'origine à l'intérieur du constructeur de copie.
Maintenant, abordons une erreur courante commise par les débutants lors de la création d'un constructeur de copie. L'erreur consiste à copier directement le pointeur au lieu d'allouer de la nouvelle mémoire et de copier le contenu. Si nous copions le pointeur, l'original et la copie pointeront vers le même emplacement mémoire. Par conséquent, lorsque le destructeur est invoqué, il tentera de libérer la mémoire deux fois, ce qui entraînera des erreurs.
Pour résoudre ce problème, nous devons allouer une nouvelle mémoire pour la copie et copier le contenu du pointeur d'origine. Au lieu d'assigner directement le pointeur, nous allons créer un nouveau tableau dynamique et copier les éléments. Cela garantit que l'original et la copie disposent d'emplacements de mémoire distincts.
En suivant ces directives, nous pouvons créer un constructeur de copie correct qui évite les erreurs liées à la mémoire.
J'espère que cette explication clarifie le concept de constructeurs de copie et leur importance.
Codez-le vous-même ! Tetris - Programmation à partir de zéro (C++ rapide et simple)
Codez-le vous-même ! Tetris - Programmation à partir de zéro (C++ rapide et simple)
Bonjour! Aujourd'hui, nous allons nous lancer dans l'aventure passionnante de la création de notre propre version de Tetris. Avant de plonger dans le codage, permettez-moi de vous donner un aperçu de ce que nous allons construire.
Comme vous pouvez le voir, nous avons une forme classique de Tetris à l'écran. Nous pourrons faire pivoter ces formes, grâce à la puissance du codage. Le jeu inclut la détection de collision, qui garantit que les pièces interagissent correctement les unes avec les autres. Si nous parvenons à compléter une ligne en plaçant stratégiquement les pièces aléatoires, elle disparaîtra et notre score augmentera en conséquence. Cependant, si nous ne faisons pas attention et que la pile de pièces atteint le sommet, la partie est terminée.
Maintenant, vous vous demandez peut-être pourquoi nous nous concentrons sur le moteur de jeu plutôt que sur les graphismes. Bien que l'esthétique soit importante et puisse attirer les joueurs, la véritable essence d'un jeu réside dans son moteur - la partie responsable de la mise en œuvre du gameplay, de la logique, des règles, des défis, etc. Des moteurs graphiques peuvent toujours être ajoutés plus tard, et vous pouvez même faire appel à un artiste pour embellir votre jeu. Mais pour vraiment comprendre le développement de jeux, vous devez comprendre les principes fondamentaux de la construction d'un moteur de jeu.
Pour commencer, nous avons besoin de certains éléments du jeu. Dans Tetris, ces actifs sont les différentes formes appelées "blocs tetromino". Nous allons stocker ces formes sous forme de chaînes, ce qui nous permettra de les visualiser plus facilement. Il existe sept formes courantes utilisées dans Tetris, et nous les représenterons en utilisant des caractères tels que des points (.) pour les espaces vides et un X majuscule pour la forme elle-même. En arrangeant ces caractères, nous créons des chaînes qui représentent visuellement les formes.
Maintenant, au lieu d'utiliser des tableaux multidimensionnels pour représenter les formes 2D, nous allons utiliser un tableau unidimensionnel et manipuler les indices à l'aide de calculs mathématiques simples. Cette approche nous permet de gérer plus efficacement les rotations et les réflexions des formes. Nous utiliserons des formules pour déterminer les indices appropriés pour chaque rotation. Par exemple, en multipliant la coordonnée X par 4, on peut obtenir l'indice souhaité pour une rotation de 90 degrés. Cette technique nous évitera de créer des actifs séparés pour chaque variation de forme possible.
Outre les blocs de tetromino, nous avons également besoin d'un terrain de jeu. Nous allons définir les dimensions du champ en utilisant des variables pour la largeur et la hauteur. Dans ce cas, nous utiliserons une taille de champ de 12 cellules de large et 18 cellules de haut. Pour représenter les éléments du terrain de jeu, nous allons utiliser un tableau de caractères non signés. Chaque cellule se verra attribuer une valeur pour indiquer son contenu, comme un espace vide, une partie d'une forme ou les murs de délimitation.
Pour visualiser notre jeu, nous utiliserons l'invite de commande comme tampon d'écran. En créant un tableau aux dimensions de la fenêtre d'invite de commande, nous pouvons y dessiner nos éléments de jeu. Nous utiliserons des personnages spécifiques pour représenter différents éléments du jeu, comme les formes, les espaces vides et les murs d'enceinte. Ensuite, nous afficherons le contenu du tableau sur l'écran d'invite de commande.
Parlons maintenant de la boucle de jeu. Les boucles de jeu sont des composants essentiels de tout moteur de jeu car elles contrôlent le séquencement des éléments du jeu. Dans le cas de Tetris, notre boucle de jeu gérera le timing, l'entrée de l'utilisateur, la logique du jeu et le rendu de sortie.
Le timing est crucial pour assurer un gameplay cohérent sur différents systèmes. Nous voulons que le jeu tourne au même rythme, quelle que soit la vitesse de l'ordinateur. Nous utiliserons des mécanismes de synchronisation pour contrôler la vitesse à laquelle les formes tombent et les mises à jour du jeu.
Ensuite, nous aborderons la saisie de l'utilisateur. Puisque nous créons une version simple de Tetris en ligne de commande, nous ne nous baserons pas sur des entrées basées sur des événements. Au lieu de cela, nous gérerons les entrées utilisateur de base, telles que les touches fléchées ou d'autres touches désignées.
Dans ce code, nous allons implémenter la gestion des entrées au clavier pour un jeu, en nous concentrant spécifiquement sur quatre touches : la flèche gauche, la flèche droite, la flèche vers le bas et la touche "Z" pour faire pivoter la pièce de jeu.
Pour obtenir l'état actuel des touches pressées par l'utilisateur, nous utiliserons la fonction "get async key state". En parcourant un tableau représentant l'état des touches, nous pouvons déterminer si chaque touche est actuellement enfoncée ou non. Cette fonction retourne une valeur booléenne : true si la touche est enfoncée et false sinon. Pour vérifier l'état d'une clé spécifique, nous utilisons une expression de chaîne constante représentant les codes de clé virtuelle pour chaque clé.
En vérifiant l'état de ces quatre touches, nous pouvons créer un tableau contenant des valeurs vraies ou fausses indiquant si chaque touche est enfoncée ou non. Cela simplifie le processus et nous donne un tableau représentant l'état actuel des clés.
Considérons la touche gauche comme exemple. Lorsque l'utilisateur appuie sur la touche gauche, nous devons vérifier si la pièce de jeu peut tenir à gauche de sa position actuelle. Pour ce faire, nous utilisons une fonction appelée "est-ce que la pièce s'adapte", qui considère la pièce actuelle, sa rotation et la position X actuelle. En soustrayant 1 de la position X actuelle, nous pouvons déterminer si la pièce tient à gauche. Si cela convient, nous mettons à jour la position X actuelle en conséquence.
De même, pour la clé de droite, nous effectuons une vérification similaire pour voir si la pièce peut tenir à droite de sa position actuelle. Si c'est possible, nous mettons à jour la position X actuelle en conséquence.
Lorsque l'utilisateur appuie sur la touche bas, nous devons gérer le mouvement vertical de la pièce. Comme la position en haut à gauche du terrain de jeu est toujours (0, 0), nous pouvons simplement incrémenter la position Y pour déplacer la pièce vers le bas. Nous effectuons des vérifications pour nous assurer que le déplacement de la pièce vers la gauche, la droite ou le bas la maintient dans les limites du terrain de jeu.
Pour optimiser le code, nous pouvons remplacer les instructions if imbriquées par des opérateurs ET logiques. Cela simplifie le code et améliore sa concision. De plus, nous utilisons des instructions conditionnelles pour ajouter ou soustraire 1 à la position X actuelle en fonction du résultat de la condition, ce qui simplifie davantage le code. La même optimisation est appliquée lors de la gestion de la rotation de la pièce lorsque l'utilisateur appuie sur la touche "Z".
Dans Tetris, le jeu force périodiquement la pièce à descendre tous les quelques dixièmes de seconde, simulant la gravité. Nous y parvenons en utilisant le compteur de ticks de jeu. Au départ, la pièce tombe lentement, mais au fur et à mesure que le jeu progresse, nous diminuons le temps entre chaque chute de pièce, ce qui rend le jeu plus rapide et plus difficile. En accumulant les ticks de jeu et en les comparant à la vitesse actuelle, nous déterminons quand forcer la pièce. Il en résulte que la pièce tombe à intervalles réguliers, créant un effet de gravité dans le jeu.
Pour verrouiller la pièce actuelle dans le terrain de jeu, nous mettons à jour le tableau de champs avec les valeurs du tableau tetromino. Cela se fait en parcourant chaque élément du tableau tetromino et en mettant à jour la position correspondante dans le tableau de champs. Si un élément du tableau tetromino est un "X", nous incrémentons la valeur correspondante dans le tableau de champs de 1. Cela marque cette position comme occupée par la pièce actuelle.
Lorsqu'une ligne se forme sur le terrain de jeu, nous voulons l'indiquer visuellement au joueur. Nous remplaçons la ligne par un marqueur spécial ou effectuons tout autre effet visuel pour indiquer l'achèvement de la ligne.
Après avoir indiqué visuellement la ligne terminée, nous devons gérer la suppression de la ligne et la mise à jour du terrain de jeu en conséquence. Nous parcourons chaque ligne du terrain de jeu en commençant par le bas et vérifions si la ligne est remplie. Si une ligne est remplie, nous l'effaçons en mettant tous ses éléments à 0. Nous déplaçons ensuite toutes les lignes au-dessus d'une position vers le bas pour remplir la ligne effacée. Ce processus est répété jusqu'à ce que toutes les lignes remplies aient été effacées.
Pour garder une trace du score du joueur, nous l'incrémentons à chaque fois qu'une ligne est effacée. Le score peut être basé sur le nombre de lignes effacées ou peut avoir un système de notation plus complexe en fonction de la conception du jeu.
Pour gérer les conditions de jeu, nous devons vérifier si la pièce actuelle peut tenir dans sa position initiale en haut du terrain de jeu. S'il ne rentre pas, le jeu est terminé et nous arrêtons la boucle de jeu ou déclenchons toute action de fin de jeu nécessaire.
Enfin, pour gérer la boucle de jeu, nous utilisons une minuterie ou un mécanisme similaire qui déclenche une fonction de mise à jour à intervalle régulier. Cette fonction gère la mise à jour de l'état du jeu, y compris la vérification des entrées de l'utilisateur, le déplacement de la pièce vers le bas et l'exécution des actions nécessaires en fonction de l'état actuel du jeu.
En résumé, ce code implémente la gestion des entrées au clavier pour un jeu, en se concentrant spécifiquement sur des touches telles que les touches fléchées et la touche "Z". Il vérifie l'état de ces touches, gère le mouvement de la pièce de jeu en conséquence, implémente la gravité et le verrouillage des pièces, efface les lignes terminées, met à jour le terrain de jeu, suit le score du joueur et vérifie les conditions de jeu. La boucle de jeu garantit que l'état du jeu est mis à jour à intervalles réguliers, créant une expérience de jeu dynamique et interactive.
COURS COMPLET C++ pour débutants (Apprendre C++ en 10 heures)
COURS COMPLET C++ pour débutants (Apprendre C++ en 10 heures)
Il s'agit d'un cours complet de programmation C++. Il se compose de nombreuses conférences dont le but est de vous faire passer du niveau de programmation débutant au niveau avancé. Je recommande de regarder l'intégralité de la vidéo car les conférences ultérieures nécessitent des connaissances des précédentes.
Contenu:00:00:00 – Objectifs du cours
00: 01: 31 - Faites-le avant de commencer le cours
00:02:41 - Introduction à C++ (Qu'est-ce que C++ ? Quel type d'applications pouvez-vous créer avec C++ ? Pourquoi C++ a été créé ?)
00:06:39 - Qu'est-ce que le code source, le code objet, le compilateur, l'algorithme ?
00:08:42 - Visual Studio 2019 – Création d'un premier projet (installation)
00: 11: 32 - Explication des bases de Visual Studio 2019 et premier programme "Hello World"
00:29:51 - Introduction aux variables
00:44:36 - Règles de nommage des variables
00: 52: 15 - Types de données en C++ et comment utiliser l'opérateur sizeof
01:01:58 - Débordement de type de données
01:05:00 - Qu'est-ce qu'un tableau ASCII
01:09:50 - Programme simple et amusant pour chiffrer des mots en ASCII
01:18:12 - Instruction If/else (Construire un programme qui vérifie les nombres impairs/pairs + explication de l'organigramme)
01:35:52 - Instruction if/else imbriquée (Construire un programme qui détermine le type d'un triangle + organigramme)
01:55:50 - Opérateurs en C++ (opérateurs arithmétiques, relationnels, logiques, d'affectation)
02:21:02 - Permutation des valeurs de deux variables avec ou sans troisième variable
02:29:20 - Construire l'application BMI Calculator + organigramme
02:49:55 - Opérateur ternaire (conditionnel) (Construire une application de jeu de devinettes)
03:01:00 - Instruction Switch/case partie 1 (application Build Calculator)
03:26:36 - Switch/case statement partie 2 (Build programme qui vérifie le nombre de jours dans un mois)
03:39:35 - Boucle While partie 1 + exemple de boucle infinie
03:53:39 - While loop part 2 (Construire un programme pour compter les chiffres d'un nombre)
04:12:39 - While loop part 3 (Construire un programme pour inverser les chiffres d'un nombre)
04:25:25 - Boucle Do while (Programme de validation du code PIN)
04:39:09 - Quelle est la différence entre la boucle While et la boucle Do While
04:40:34 - Boucle For (Construire un programme pour calculer la factorielle d'un nombre)
04:58:12 - Boucles imbriquées (Imbrication do while loop et for loop)
05:11:08 - Boucle for imbriquée (application Build Multiplication table)
05:21:45 – Programme pour dessiner la forme d'un rectangle
05:33:05 – Programme pour dessiner des triangles et des triangles inversés/inversés
05:44:30 – Introduction aux fonctions
05:56:02 – Fonctions avec paramètres/arguments (multiple et par défaut)
06:11:42 - Instruction de retour de fonction (programme de construction pour vérifier les nombres premiers)
06:37:39 - Surcharge de fonction
06:48:06 - Créer une application ATM
07:03:03 - Fonctions génériques et modèles
07:14:30 – Récursivité et fonctions récursives
07:30:01 - Introduction à la POO, que sont les classes et les objets
07:42:06 - Constructeurs OOP et méthodes de classe
07:57:10 - Encapsulation POO, GIT : https://github.com/TrueCodeBeauty/EncapsulationCpp
08:08:31 - Héritage OOP, GIT : https://github.com/TrueCodeBeauty/InheritanceCpp
08:24:59 - Polymorphisme POO, GIT : https://github.com/TrueCodeBeauty/PolymorphismCpp
08:40:04 - Introduction aux pointeurs
08: 51: 14 - Pointeurs vides
09:06:27 - Pointeurs et tableaux
09:19:18 - Renvoie plusieurs valeurs d'une fonction à l'aide de pointeurs
09:34:50 - Tableaux dynamiques, créer/changer des tableaux lors de l'exécution
09:48:35 - Tableaux dynamiques multidimensionnels, tableau bidimensionnel
10:07:00 - Détection d'erreurs dans le code à l'aide de PVS Studio
10:17:19 - Explication des fuites de mémoire
10:26:25 - Bêtisier
FONCTIONS C++ (2020) - Que sont les fonctions ?
FONCTIONS C++ (2020) - Que sont les fonctions ? TUTORIEL DE PROGRAMMATION
Bienvenue sur la première vidéo de ma chaîne ! Si vous êtes débutant en C++, assurez-vous de consulter ma liste de lecture sur C++ pour débutants, où vous pouvez trouver des concepts importants que vous devez comprendre et connaître pour travailler avec C++. Dans cette vidéo, nous aborderons les fonctions C++, qui sont essentielles pour devenir un bon programmeur non seulement en C++ mais dans la plupart des langages de programmation.
Avant de commencer, abonnez-vous à ma chaîne et cliquez sur l'icône en forme de cloche pour recevoir des notifications lorsque je publierai ma prochaine vidéo. Si vous souhaitez voir le contenu des coulisses et à quoi ressemble vraiment la vie des développeurs, suivez-moi sur Instagram et Twitter via mes comptes "CodeBeauty".
Maintenant, plongeons dans le sujet des fonctions. Une fonction est un bloc de code qui est regroupé pour résoudre un problème spécifique ou effectuer une tâche spécifique. Le code d'une fonction est exécuté uniquement lorsque la fonction est appelée ou invoquée. Chaque programme C++ contient au moins une fonction, qui est la fonction principale. L'exécution de votre programme commence à la première ligne de la fonction principale et se termine soit à la dernière ligne, soit lorsqu'une instruction de retour est rencontrée (nous aborderons les instructions de retour plus tard dans ce cours).
Pour créer votre propre fonction, il y a quelques choses que vous devez savoir. Tout d'abord, vous devez spécifier le type de retour de la fonction. Pour l'instant, nous utiliserons le type de retour "void", ce qui signifie que la fonction ne renvoie rien. Ensuite, vous donnez un nom à votre fonction. À l'intérieur des parenthèses, vous pouvez définir tous les arguments ou paramètres que votre fonction reçoit. Dans ce cas, nous n'aurons aucun argument, donc les parenthèses sont vides. Enfin, vous définissez le corps de la fonction entre accolades.
Dans notre exemple, nous avons créé une fonction appelée "fonction" avec un type de retour vide et aucun argument. Dans le corps de la fonction, nous utilisons l'instruction "cout" pour afficher "Bonjour de la fonction" et ajouter une ligne de fin. Cependant, la simple création de la fonction n'exécute pas son code. Pour exécuter la fonction, vous devez l'invoquer ou l'appeler. Dans notre cas, nous appelons la fonction après l'instruction "cout" dans la fonction principale en tapant son nom suivi de parenthèses.
Après avoir compilé et exécuté le programme, vous verrez la sortie "Hello from main" suivie de "Hello from function". En effet, la fonction principale est exécutée en premier, puis la fonction que nous avons créée est exécutée lorsqu'elle est invoquée.
Pour rendre votre code plus lisible, il est recommandé de déclarer et de définir vos fonctions séparément. La déclaration inclut le type de retour, le nom de la fonction et tous les paramètres, et elle doit être placée avant la fonction principale. La définition, qui contient le corps de la fonction, est placée après la fonction principale. De cette façon, si quelqu'un d'autre lit votre code, il peut facilement accéder à la fonction spécifique qu'il doit comprendre.
N'oubliez pas que les fonctions rendent votre code réutilisable. Au lieu d'écrire le même code plusieurs fois, vous pouvez l'écrire une fois dans une fonction et invoquer cette fonction chaque fois que vous en avez besoin. Cette pratique permet de réduire la redondance et facilite la gestion de votre code.
Dans les prochaines vidéos, nous explorerons les fonctions plus en détail. N'oubliez pas de vous abonner à ma chaîne et d'activer les notifications pour rester à jour avec le contenu à venir. Merci d'avoir regardé, et je vous verrai dans la prochaine vidéo !
FONCTIONS C++ (2020) - Qu'est-ce qu'un paramètre/argument de fonction (multiple, par défaut) TUTORIEL DE PROGRAMMATION
FONCTIONS C++ (2020) - Qu'est-ce qu'un paramètre/argument de fonction (multiple, par défaut) TUTORIEL DE PROGRAMMATION
Bonjour à tous! Bienvenue sur ma chaîne. Si vous êtes un débutant en C++, je suis content que vous soyez ici. Avant de plonger dans le sujet d'aujourd'hui, je tiens à vous rappeler de consulter ma liste de lecture C++ pour débutants. Il couvre les concepts essentiels et comprend de nombreux exercices pour vous aider à vous entraîner. N'oubliez pas non plus de vous abonner à ma chaîne et de cliquer sur l'icône en forme de cloche pour recevoir des notifications chaque fois que je publie une nouvelle vidéo. Vous pouvez également me suivre sur mes profils de réseaux sociaux, CodeBeauty Instagram et Twitter, pour avoir un aperçu de la vie d'un développeur. Très bien, sans plus tarder, passons à la leçon d'aujourd'hui.
Dans cette vidéo, je veux discuter des paramètres ou des arguments de la fonction C++. Alors, que sont exactement les paramètres et les arguments ? Si vous n'avez pas regardé ma vidéo précédente sur les fonctions C++, je vous recommande de la consulter (lien fourni). Parfois, une fonction doit recevoir une valeur ou une variable spécifique pour effectuer une tâche particulière. Ces valeurs ou variables sont appelées paramètres.
Maintenant, apprenons à créer une fonction qui accepte des paramètres en C++. Pour ce faire, nous définissons une fonction avec un type de retour de void. Appelons la fonction "introduceMe". À l'intérieur des parenthèses, nous spécifions les paramètres que la fonction recevra. Le corps de notre fonction sera entouré d'accolades.
Pour définir un paramètre, nous commençons par indiquer le type du paramètre, suivi de son nom. Dans notre cas, nous voulons passer le nom de notre utilisateur à la fonction, donc le paramètre sera de type string. Nous nommerons le paramètre "nom". La fonction présentera alors notre utilisateur en imprimant "Mon nom est" suivi du nom fourni.
Pour invoquer ou appeler notre fonction, nous utilisons simplement son nom, "introduceMe". Étant donné que notre fonction nécessite un argument (le paramètre name), nous devons transmettre une valeur lors de l'appel de la fonction. Dans ce cas, passons le nom "Selena" comme argument.
Lorsque nous exécutons le programme, la fonction introduira avec succès l'utilisateur avec le nom fourni. Il imprimera "Mon nom est Selena" comme prévu.
Si nous voulons introduire plusieurs utilisateurs, nous pouvons rappeler la fonction avec des arguments différents. Par exemple, nous pouvons copier la ligne d'invocation et passer un nom différent, tel que "Anna". La fonction présentera alors les deux utilisateurs en conséquence.
Maintenant, explorons le passage de plusieurs arguments à une fonction. Pour ce faire, nous séparons les paramètres par des virgules. En plus du paramètre name, ajoutons deux autres paramètres : city (de type string) et age (de type int). Nous modifierons la fonction pour inclure également des informations sur la ville et l'âge de l'utilisateur.
Dans la fonction, nous utiliserons le "cout" de C++ pour imprimer la ville et l'âge de l'utilisateur avec son nom. Nous allons structurer la sortie comme suit : "Je viens de [ville] et j'ai [âge] ans."
Lorsque nous invoquons la fonction, nous transmettons les valeurs des trois paramètres : nom, ville et âge. Par exemple, nous pouvons appeler la fonction et passer "Selena" comme nom, "Moscou" comme ville et 25 ans comme âge. La fonction présentera à l'utilisateur toutes les informations fournies.
Nous pouvons répéter le processus pour un deuxième utilisateur. Passons "Anna" comme nom, "New York" comme ville, et 27 comme âge. Lorsque nous exécuterons le programme, nous verrons que les deux utilisateurs ont été présentés avec leurs détails respectifs.
Ensuite, explorons les paramètres par défaut. Parfois, vous souhaiterez peut-être définir une valeur par défaut pour un paramètre. Cette valeur sera utilisée si aucun argument n'est fourni pour ce paramètre lors de l'appel de la fonction.
Pour spécifier une valeur par défaut, nous l'attribuons lors de la déclaration des paramètres. Par exemple, définissons la valeur par défaut du paramètre "age" sur 18. Maintenant, si nous appelons la fonction sans fournir d'âge, elle prendra la valeur par défaut.
Invoquons la fonction pour un troisième utilisateur, en transmettant uniquement le nom et la ville, mais en omettant l'âge. Comme prévu, la fonction introduira l'utilisateur avec la valeur d'âge par défaut de 18 ans.
Cela conclut notre discussion sur les paramètres et les arguments des fonctions C++. J'espère que vous avez trouvé cette vidéo utile et que vous comprenez parfaitement comment utiliser les paramètres de fonction en C++. Si vous avez des questions ou avez besoin de plus de précisions, veuillez laisser un commentaire ci-dessous, et je serai heureux de vous aider. Restez à l'écoute pour plus de tutoriels C++, et n'oubliez pas d'aimer et de partager cette vidéo si vous l'avez trouvée utile. Merci d'avoir regardé et bon codage !
FONCTIONS C++ (2020) - Instruction de retour des fonctions, Comment vérifier le nombre premier
FONCTIONS C++ (2020) - Instruction de retour des fonctions, Comment vérifier le nombre premier TUTORIEL DE PROGRAMMATION
Salut tout le monde, bienvenue sur ma chaîne. Dans cette vidéo, je souhaite discuter des instructions de retour et des types de fonctions de retour en C++. Si vous êtes débutant, assurez-vous de consulter mon cours C++ pour débutants, qui fournit des exemples utiles pour vous aider à démarrer avec l'apprentissage du C++. N'oubliez pas de vous abonner à ma chaîne et de cliquer sur la cloche de notification pour rester informé des nouvelles vidéos. De plus, si vous souhaitez devenir développeur et avoir un aperçu de la vie du développeur, suivez-moi sur Instagram et Twitter à @truecodebeauty (liens dans la description de la vidéo). Sans plus tarder, plongeons dans le sujet d'aujourd'hui.
Un type de retour d'une fonction peut être n'importe quel type de données, y compris les types de données int, float, bool, char, double ou même définis par l'utilisateur. Il peut également être vide, indiquant que la fonction ne renvoie rien. Dans les vidéos précédentes, j'ai expliqué qu'une fonction est un bloc de code conçu pour effectuer une tâche spécifique. Les fonctions peuvent être classées en deux types : celles qui renvoient une valeur et celles qui ne le font pas.
Les fonctions qui ne renvoient pas de valeur effectuent généralement une action spécifique, telle que l'affichage d'un menu à l'utilisateur. D'autre part, les fonctions qui renvoient une valeur sont utilisées pour effectuer des calculs ou des opérations et fournir un résultat. Il est important de noter qu'une fonction ne peut renvoyer qu'une seule valeur et qu'une fois l'instruction de retour rencontrée, l'exécution de la fonction s'arrête.
Pour illustrer l'importance des fonctions, considérons un exemple sans utiliser de fonctions. Nous allons créer un programme pour déterminer si un nombre est premier ou non. Un nombre premier n'est divisible que par un et lui-même. Tout d'abord, nous demanderons à l'utilisateur d'entrer un numéro. Ensuite, nous parcourrons tous les nombres entre 2 et le nombre saisi par l'utilisateur moins 1. Si le nombre est divisible par l'une de ces valeurs, il n'est pas premier. Sinon, c'est le premier. Enfin, nous afficherons le résultat.
Maintenant, refactorisons le programme en utilisant des fonctions pour rendre le code plus lisible et réutilisable. Nous allons créer une fonction appelée "isPrimeNumber" qui prend un argument entier et renvoie une valeur booléenne indiquant si le nombre est premier ou non. À l'intérieur de la fonction, nous allons implémenter la même logique qu'auparavant, en vérifiant la divisibilité et en définissant un indicateur en conséquence. Enfin, nous renverrons la valeur du drapeau.
En utilisant des fonctions, nous pouvons encapsuler la logique de détermination des nombres premiers, ce qui rend le code plus facile à comprendre et à réutiliser.
FONCTIONS C++ (2020) - Qu'est-ce que la surcharge de fonctions ? TUTORIEL DE PROGRAMMATION
FONCTIONS C++ (2020) - Qu'est-ce que la surcharge de fonctions ? TUTORIEL DE PROGRAMMATION
Bonjour à tous! Bienvenue sur ma chaîne. Dans la vidéo d'aujourd'hui, nous allons nous plonger dans le concept de surcharge de fonctions en C++. La surcharge de fonctions nous permet de créer plusieurs fonctions avec le même nom mais des paramètres différents. Alors, explorons ce qu'est la surcharge de fonctions et comment cela fonctionne.
Pour commencer, ouvrons notre Visual Studio et créons une fonction appelée "sum". Nous allons commencer par définir le type de retour de notre fonction, qui sera un entier. Si vous n'êtes pas familier avec les types de retour, je vous recommande de regarder ma vidéo sur le sujet (lien fourni). Ensuite, nous allons spécifier le nom de notre fonction comme "somme" et déclarer deux paramètres. Les deux paramètres seront de type entier, et nous les nommerons respectivement "a" et "b".
Maintenant, créons une autre fonction avec le même nom, "sum", mais cette fois avec un type de retour double. Nous allons déclarer deux paramètres de type double, nommés "a" et "b".
De plus, créons une troisième fonction nommée "sum" avec un type de retour float. Cette fois, nous allons passer trois paramètres, qui seront tous de type float. Nous les nommerons respectivement "a", "b" et "c".
Après avoir déclaré nos fonctions, nous remarquons qu'elles sont soulignées, indiquant qu'il leur manque leurs définitions. Continuons en fournissant les définitions pour chaque fonction. Nous allons commencer par la première fonction qui renvoie un entier.
À l'intérieur des accolades, nous définirons une variable appelée "résultat" de type int. Nous lui attribuerons la valeur de "a + b", qui représente la somme des deux paramètres. Enfin, nous utiliserons le mot-clé "return" pour renvoyer la valeur de "result" de la fonction.
Alternativement, au lieu de créer une variable séparée, nous pouvons renvoyer directement la somme de "a" et "b" sans l'affecter à une variable. Cela peut rendre le code plus court et plus lisible.
Ensuite, définissons la deuxième fonction qui renvoie un double. Nous allons copier la déclaration, ajouter les accolades, et à l'intérieur, nous allons utiliser le mot-clé "return" suivi de "a + b". Les paramètres étant de type double, la somme sera effectuée en double précision.
Définissons maintenant la troisième fonction qui renvoie un flottant. Nous allons copier la déclaration, ajouter les accolades, et à l'intérieur, nous allons utiliser le mot-clé "return" suivi de "a + b + c". Encore une fois, puisque tous les paramètres sont de type float, la somme sera effectuée en conséquence.
Pour tester nos fonctions, nous allons les invoquer dans la fonction "main". Nous utiliserons l'instruction "cout" pour afficher les résultats. Commençons par appeler la première fonction, "sum", et en passant deux valeurs entières, telles que 4 et 3. Nous afficherons le résultat en utilisant "cout" et terminerons la ligne.
Lorsque nous exécutons le programme, nous pouvons nous attendre à voir le résultat de la somme de 4 et 3, qui devrait être 7. Si le programme s'exécute avec succès, nous avons testé notre première fonction.
Ensuite, testons la deuxième fonction en appelant "sum" et en passant deux valeurs doubles, telles que 4,4 et 3,3. Encore une fois, nous afficherons le résultat en utilisant "cout" et terminerons la ligne.
Lorsque nous exécutons le programme, nous devrions voir le résultat de la somme de 4,4 et 3,3, qui devrait être 7,7. Si la sortie est correcte, nous avons testé avec succès notre deuxième fonction.
Enfin, testons la troisième fonction en appelant "sum" et en transmettant trois valeurs flottantes, telles que 4.4, 3.3 et 2.2. Nous afficherons le résultat en utilisant "cout" et terminerons la ligne.
L'exécution du programme doit afficher le résultat de la somme de 4,4, 3,3 et 2,2, qui doit être la somme correcte. Vérifiez la sortie à l'aide d'une calculatrice si nécessaire.
En résumé, ce que nous avons démontré ici est la surcharge de fonctions. Nous avons créé trois fonctions portant le même nom, "sum", mais avec des paramètres et des types de retour différents. La première fonction prend deux entiers, la seconde prend deux doubles et la troisième prend trois flottants. Lorsque nous invoquons ces fonctions, le compilateur détermine la fonction appropriée à appeler en fonction des arguments fournis.
La surcharge de fonctions nous permet d'écrire un code plus concis et lisible en utilisant le même nom pour des fonctions qui effectuent des tâches similaires. Nous n'avons pas besoin de créer des fonctions séparées avec des noms différents pour chaque variante.
J'espère que vous comprenez maintenant le concept de surcharge de fonctions et comment cela peut être utile en C++. Si vous avez aimé cette vidéo, abonnez-vous à ma chaîne et cliquez sur l'icône en forme de cloche pour recevoir des notifications pour les prochaines vidéos. Vous pouvez également me suivre sur mes autres plateformes de médias sociaux (liens fournis dans la description).
Merci d'avoir regardé, et je vous verrai dans ma prochaine vidéo. Au revoir!