Tutoriels de programmation

[MetaQuotes]

Dans notre monde technologiquement avancé, la programmation et l'informatique sont devenues des disciplines transformatrices qui stimulent l'innovation et façonnent la société.

La programmation, en tant que forme d'art, combine créativité, logique et résolution de problèmes pour créer des solutions élégantes et efficaces.

• Fusion de la science et de la créativité
  L'informatique sert de base scientifique à la programmation, couvrant les théories, les algorithmes et les méthodologies pour le développement et la mise en œuvre de programmes informatiques. Cependant, la programmation elle-même demande de l'imagination et de l'ingéniosité. Comme un artiste de toile vierge, un programmeur tisse des lignes de code dans des algorithmes complexes, créant des chefs-d'œuvre numériques qui révolutionnent les industries, simplifient les tâches et améliorent l'expérience utilisateur. La programmation orientée objet (POO) est un paradigme clé en informatique qui permet aux programmeurs de gérer la complexité en organisant le code en objets réutilisables et modulaires. En encapsulant les données et le comportement dans des objets, les programmeurs peuvent concevoir de manière créative des solutions plus faciles à comprendre, à maintenir et à étendre.
  
  
• Créativité dans la conception et l'expérience utilisateur
  La programmation va au-delà de la résolution de problèmes et comprend la conception d'interfaces conviviales et d'expériences utilisateur attrayantes. Cet aspect allie sensibilité artistique et connaissances techniques. Les programmeurs conçoivent l'interface utilisateur (UI) et l'expérience utilisateur (UX) en utilisant l'esthétique, la navigation intuitive et des visuels accrocheurs pour créer des logiciels qui ravissent et captivent les utilisateurs. L'art réside dans la fusion harmonieuse de la fonctionnalité et de l'attrait esthétique, en traduisant des fonctionnalités complexes en conceptions intuitives et visuellement agréables. Avec la POO, les programmeurs peuvent séparer les tâches et créer des objets distincts responsables de différents aspects du logiciel. Cette approche modulaire favorise la créativité dans la conception en permettant aux programmeurs de se concentrer sur des objets individuels, leurs interactions et le comportement global du système. En utilisant les principes de la POO tels que l'héritage et le polymorphisme, les programmeurs peuvent développer des logiciels avec une interface intuitive, une interface conviviale et une esthétique visuellement attrayante.
  
  
• Le génie logiciel comme un art
  Le génie logiciel, une discipline de l'informatique, met l'accent sur l'aspect artistique de la programmation. Il couvre l'ensemble du cycle de vie du développement logiciel, de la collecte des exigences au déploiement et à la maintenance. Les ingénieurs logiciels abordent la programmation comme des architectes, concevant des systèmes et des plates-formes fiables, évolutifs et maintenables. Ils prennent en compte des facteurs tels que la modularité du code, la réutilisabilité et les modèles architecturaux pour créer des solutions logicielles qui allient fonctionnalité et élégance. L'art du développement logiciel consiste à équilibrer les contraintes techniques, les besoins des utilisateurs et les objectifs de conception pour créer un logiciel à la fois fonctionnel et esthétique. La POO joue un rôle clé dans le développement de logiciels en fournissant une approche structurée de la gestion de la complexité. La séparation du code en classes et en objets permet aux développeurs de logiciels de concevoir des systèmes modulaires, réutilisables et maintenables. Avec la bonne abstraction et encapsulation, les développeurs de logiciels peuvent trouver un équilibre qui se traduit par un logiciel à la fois fonctionnel et élégant.
  
  
• Innovation et impact social
  L'art de la programmation et de l'informatique va au-delà du secteur technologique, affectant les industries et la société dans son ensemble. De la santé à la finance, de l'éducation au divertissement, la programmation et l'informatique révolutionnent notre façon de travailler, de communiquer et de vivre. Des innovations telles que l'intelligence artificielle, la réalité virtuelle et la technologie blockchain modifient les industries et ouvrent de nouveaux horizons. Les programmeurs et les informaticiens jouent un rôle clé dans ces avancées transformatrices, repoussant les limites du possible et transformant les idées en réalité. La POO permet aux programmeurs de créer des solutions innovantes qui révolutionnent divers domaines. En gérant la complexité avec la nature modulaire et extensible de la POO, les programmeurs peuvent développer des systèmes complexes tels que des algorithmes d'intelligence artificielle, des expériences de réalité virtuelle immersives et des applications de blockchain sécurisées. Ces progrès transforment les industries, augmentent la productivité et améliorent la qualité de vie des gens partout dans le monde.

La gestion de la complexité est un aspect clé du développement logiciel. À mesure que les systèmes deviennent plus complexes, il devient nécessaire d'utiliser des approches efficaces pour gérer la complexité et assurer la maintenabilité et l'évolutivité.

Le paradigme orienté objet est une approche puissante qui offre des avantages significatifs dans la gestion de la complexité. En encapsulant les données et le comportement dans des objets et en utilisant des concepts tels que l'encapsulation, l'héritage et le polymorphisme, le paradigme orienté objet fournit une base solide pour gérer la complexité.

1. Encapsulation.
   L'encapsulation est un principe fondamental du paradigme orienté objet qui favorise l'association de données et de méthodes au sein d'objets. Cette encapsulation cache les complexités internes d'un objet, n'exposant que les interfaces nécessaires pour interagir avec lui. En masquant les détails d'implémentation, l'encapsulation réduit la complexité des autres parties du système, permettant aux développeurs de se concentrer sur des abstractions de niveau supérieur. Cela favorise la modularité et améliore la lisibilité du code, ce qui facilite la compréhension et la maintenance des systèmes complexes.
   
   
2. Abstraction.
   L'abstraction est un autre concept clé du paradigme orienté objet pour aider à gérer la complexité. Cela permet aux développeurs de représenter des objets complexes du monde réel sous forme de classes, en supprimant les détails inutiles. En créant des classes et des interfaces abstraites, les développeurs peuvent définir des comportements et des attributs communs qui peuvent être hérités et implémentés par plusieurs sous-classes. Cette organisation hiérarchique des classes permet aux développeurs de gérer la complexité en décomposant les systèmes complexes en composants plus petits et plus faciles à gérer. Chaque classe se concentre sur ses responsabilités spécifiques, ce qui donne une base de code plus modulaire et compréhensible.
   
   
3. Héritage.
   L'héritage est un mécanisme puissant fourni par le paradigme orienté objet qui favorise la réutilisation du code et réduit la redondance. Cela permet aux nouvelles classes d'hériter des propriétés et du comportement des classes existantes en établissant une relation "est" entre elles. L'héritage aide à gérer la complexité en permettant aux développeurs de définir une classe de base avec des attributs et des comportements communs, puis de créer des classes spécialisées qui en héritent. Cette organisation hiérarchique des classes élimine la duplication de code, réduit la complexité et améliore la maintenabilité.
   
   
4. Polymorphisme.
   Le polymorphisme est une caractéristique clé du paradigme orienté objet qui permet à des objets de différents types d'être traités de manière interchangeable en fonction de leurs interfaces communes. Le polymorphisme simplifie la gestion de la complexité en permettant aux développeurs d'écrire du code qui fonctionne avec une abstraction de niveau supérieur sans avoir à gérer les détails d'implémentation spécifiques de chaque objet. En utilisant le polymorphisme, les développeurs peuvent créer des systèmes plus flexibles et extensibles car de nouvelles classes peuvent être ajoutées sans affecter le code existant. Cela favorise un développement modulaire et évolutif, réduisant la complexité à long terme.

La gestion de la complexité est un aspect critique du développement logiciel, et le paradigme orienté objet fournit un cadre puissant pour cette tâche.

Grâce à des principes tels que l'encapsulation, l'abstraction, l'héritage et le polymorphisme, le paradigme orienté objet permet aux développeurs de gérer efficacement la complexité et de créer des systèmes maintenables, évolutifs et modulaires. En encapsulant les données et le comportement dans des objets, en éliminant les détails inutiles, en réutilisant le code par héritage et en utilisant le polymorphisme, le paradigme orienté objet offre une approche complète de la gestion de la complexité. L'utilisation du paradigme orienté objet améliore considérablement le processus de développement logiciel et contribue à la création de systèmes logiciels fiables et gérables.

L'art de la programmation combine les principes scientifiques avec la créativité, la résolution de problèmes et l'innovation. C'est une discipline qui demande à la fois des prouesses techniques et une vision artistique. La gestion de la complexité avec une approche orientée objet est essentielle en programmation, permettant aux programmeurs de développer des solutions élégantes et efficaces et d'améliorer l'expérience utilisateur.

À mesure que la technologie progresse, les logiciels continueront de façonner notre monde numérique et de stimuler l'innovation future.

[MetaQuotes]

L'art de la programmation

L'art de la programmation

L'art de la programmation va au-delà de l'écriture de code. Cela implique notre processus de réflexion, notre approche de résolution de problèmes et l'impact que nous avons sur le monde. La programmation est un langage créatif qui donne vie aux idées et nous permet de nous exprimer à travers la technologie. Cela nous met au défi de penser de manière innovante, de trouver des solutions non conventionnelles et d'élargir notre compréhension du monde et de nous-mêmes. Cette vidéo explore les concepts de programmation fondamentaux, de la syntaxe de base et des structures de données aux algorithmes avancés et aux paradigmes de programmation. Commençons.

En ce qui concerne l'édition de code, il existe deux principaux types d'outils : les éditeurs de texte et les IDE. Alors que les éditeurs de texte se concentrent sur l'édition de texte brut, les IDE fournissent des fonctionnalités supplémentaires. Cependant, dans la plupart des cas, la distinction entre les deux n'a pas beaucoup d'importance et les termes peuvent être utilisés de manière interchangeable. Les options populaires pour les éditeurs de texte et les IDE incluent Vim, Atom, Sublime Text, Eclipse, IntelliJ, PyCharm et Visual Studio Code. Visual Studio Code, en particulier, est hautement personnalisable et largement recommandé.

Pour exécuter du code, nous devons le compiler en code machine, que les ordinateurs comprennent. Cela nécessite l'installation d'un compilateur de langage ou d'un runtime. Différents langages ont leurs propres compilateurs ou runtimes, tels que GCC, Java SDK, Python interpreter, Node.js runtime et .NET SDK. Il n'est pas nécessaire de comprendre les détails de ces outils ; tout ce que vous devez savoir est d'installer un langage pour exécuter votre code.

L'exécution du code implique l'utilisation du terminal, qui donne accès à l'interface de ligne de commande. Les terminaux couramment utilisés incluent Powershell et Bash. Le terminal nous permet d'exécuter des commandes telles que la création de répertoires, la liste des fichiers et l'exécution de programmes. Les gestionnaires de packages, tels que npm pour Node.js et pip pour Python, peuvent être utilisés pour installer des logiciels à partir de référentiels via la ligne de commande. Git, un système de contrôle de version, est essentiel pour gérer les changements de code et collaborer avec les autres.

Pour commencer à coder, vous avez besoin d'un éditeur de texte ou d'un IDE approprié, d'un compilateur de langage et d'une connaissance de base des commandes du terminal. Visual Studio Code est un choix recommandé pour un éditeur de texte ou un IDE. L'installation d'un langage de programmation et la familiarisation avec les commandes du terminal vous permettront d'écrire et d'exécuter du code. Apprendre les langages de programmation implique de comprendre leur syntaxe, leur environnement et leurs conventions. Différentes langues ont différents niveaux de complexité, mais elles partagent toutes des similitudes dans la structure et les concepts.

L'impression d'une sortie dans différents langages de programmation peut être effectuée à l'aide de fonctions ou de méthodes spécifiques à chaque langage. Par exemple, Python a la fonction d'impression intégrée, JavaScript a la méthode console.log, et Java et C++ ont leur propre syntaxe pour l'impression sur la sortie standard.

Les variables sont utilisées pour stocker des valeurs de différents types de données. Les variables sont déclarées, définies et initialisées avec des valeurs. Les langages de programmation peuvent être typés statiquement ou dynamiquement, et ils ont une syntaxe différente pour les variables. Le typage statique nécessite une déclaration explicite du type de variable, contrairement au typage dynamique. Les variables ont une portée, qui détermine où elles peuvent être consultées et utilisées dans un programme. La portée peut être globale ou locale, et elle permet une meilleure organisation et prévention des erreurs.

Les types de données représentent différents types de données, tels que des chaînes, des booléens, des entiers, des nombres à virgule flottante, des caractères et des tableaux. Les structures de données permettent d'organiser et de manipuler les données. Les structures de données populaires incluent les tableaux, les piles, les tas, les arbres, les listes chaînées, les tables de hachage, les cartes de hachage et les graphiques. Les tableaux et les cartes sont deux structures de données couramment utilisées avec diverses applications.

En résumé, la programmation est un art qui englobe la réflexion, la résolution de problèmes et la création du monde à travers le code. Cela implique l'utilisation d'éditeurs de texte ou d'IDE, l'exécution de code via des compilateurs ou des runtimes, et la compréhension des commandes de terminal et du contrôle de version. L'apprentissage des langages de programmation nécessite de saisir la syntaxe, les variables, les types de données et les structures de données. La vidéo fournit un aperçu de haut niveau de ces concepts pour vous aider à démarrer votre parcours de programmation.

[MetaQuotes]

L'art d'écrire des logiciels

L'art d'écrire des logiciels

Les ordinateurs, comme les instruments de musique, sont des machines méticuleusement conçues pour effectuer des tâches spécifiques en fonction des instructions qu'ils reçoivent. Ces instructions, écrites en code, sont le logiciel qui guide leurs opérations. Tout comme la notation musicale est le code utilisé par les compositeurs, les programmeurs informatiques utilisent le code logiciel pour créer des programmes.

La programmation peut être une source de joie et de satisfaction, à l'instar des sentiments ressentis par les poètes ou les musiciens. Les premiers ordinateurs étaient fascinants et stimulants pour ceux qui aimaient la résolution de problèmes et la complexité. Ils fonctionnaient à des vitesses étonnantes, capables de résoudre un large éventail de problèmes tant qu'ils étaient exprimés à l'aide des commandes natives de l'ordinateur. Cependant, les ordinateurs sont par nature stupides et nécessitent des instructions précises pour comprendre ce qu'il faut faire. Les premiers programmeurs devaient écrire en langage machine en utilisant des nombres qui représentaient des commandes binaires. Ce processus était fastidieux et sujet aux erreurs, conduisant au développement de langages de programmation plus conviviaux.

L'introduction de langages de niveau supérieur, tels que Fortran et COBOL, a rendu la programmation plus accessible. Les programmeurs pouvaient exprimer leurs instructions à l'aide de formules scientifiques familières ou d'énoncés logiques qui avaient du sens pour eux. Des compilateurs ont ensuite été utilisés pour traduire ces instructions dans le langage binaire de l'ordinateur. Cette percée a débloqué la révolution logicielle, car les programmeurs n'avaient plus besoin d'apprendre le langage machine spécifique de chaque ordinateur.

Au fil des ans, des centaines de langages de programmation ont été développés pour répondre à différents besoins. L'écart entre ces langages et le langage machine s'est creusé, permettant aux programmeurs de se concentrer sur ce qu'ils veulent réaliser plutôt que sur les détails de bas niveau. À mesure que l'informatique devenait plus personnelle, les langages de programmation devenaient plus diversifiés et conviviaux. Les gens communiquent désormais régulièrement avec les ordinateurs en leur disant quoi faire, comme calculer des moyennes ou organiser des données. La programmation est devenue un outil d'autonomisation des individus, leur permettant de personnaliser et d'adapter les systèmes informatiques à leurs besoins.

L'écriture d'un logiciel implique non seulement le codage, mais également la définition de la manière dont les données sont représentées et organisées. Les données peuvent être organisées en chaînes, listes, tableaux, arborescences, etc., selon les besoins. Le choix du langage et de la structure des données est crucial pour résoudre efficacement les problèmes de programmation. Les programmeurs créent des procédures étape par étape appelées algorithmes pour résoudre des problèmes. Ces algorithmes spécifient les opérations nécessaires pour atteindre les résultats souhaités. Cependant, trouver l'algorithme le plus efficace pour un problème donné peut être une tâche complexe. Cela nécessite une réflexion approfondie, de la concentration et parfois des connaissances approfondies dans des domaines spécialisés.

Le développement de logiciels est une entreprise stimulante et créative qui nécessite de garder simultanément à l'esprit de nombreux aspects. Les programmeurs s'adaptent constamment aux avancées technologiques, repoussant les limites de ce que les ordinateurs peuvent réaliser. Ils recherchent l'élégance et la cohérence dans leur code, créant des logiciels à la fois fonctionnels et esthétiques. Grâce à leurs efforts, les programmeurs de logiciels ont élargi nos capacités, nous permettant d'exploiter les vastes quantités d'informations et d'interagir avec le monde d'une manière qui était autrefois considérée comme magique. La programmation est la force motrice qui permet de faire fonctionner les ordinateurs et de façonner le monde de la haute technologie dans lequel nous vivons aujourd'hui.

[MetaQuotes]

Tutoriel C++ pour débutants - Cours complet

Tutoriel C++ pour débutants - Cours complet

00:00:00 - 01:00:00 Cette vidéo est un tutoriel pour les débutants qui veulent apprendre à coder en C++. Il couvre les bases du travail avec des chaînes, des nombres et des variables. Il introduit également le concept d'importation de code à partir d'autres fichiers.

01:00:00 - 02:00:00 Ce didacticiel C++ pour débutants explique comment créer une calculatrice à quatre fonctions. Le didacticiel explique comment saisir des données, vérifier l'égalité des opérateurs et exécuter du code en fonction de cette condition.

02:00:00 - 03:00:00 Cette vidéo fournit une introduction de base à la programmation C++, en mettant l'accent sur l'utilisation des boucles for pour calculer un résultat spécifique. La fonction en cours de démonstration calcule le résultat d'un nombre élevé à une puissance spécifique.

03:00:00 - 04:00:00 Dans ce didacticiel C++ pour débutants, l'instructeur montre comment utiliser l'héritage pour étendre les fonctionnalités dans une hiérarchie de classes. L'héritage permet à une classe d'avoir les mêmes fonctionnalités qu'une autre classe, tout en étendant cette fonctionnalité avec des fonctionnalités supplémentaires. L'instructeur montre également comment remplacer les fonctions héritées afin de modifier le comportement d'une classe.

Partie 1

• 00:00:00 Ce didacticiel vidéo enseigne aux débutants comment écrire du code C++ de base. La première étape consiste à installer un éditeur de texte et un compilateur C++, qui sont tous deux inclus dans le package codeblocks. Ensuite, le tutoriel montre comment configurer un projet simple dans des codeblocks.
  
  
• 00:05:00 Ce didacticiel fournit une brève introduction au langage de programmation C++ et aux outils nécessaires pour écrire et exécuter des programmes C++. La première partie du didacticiel montre comment installer les outils nécessaires sur un Mac, et la deuxième partie explique comment créer un nouveau projet C++ dans des blocs de code.
  
  
• 00:10:00 Dans ce didacticiel vidéo, le présentateur passe en revue les bases de l'écriture d'un programme C++. Il couvre le besoin d'un projet et d'un fichier c++, explique les fonctions et montre comment construire et exécuter un programme.
  
  
• 00:15:00 Ce didacticiel explique comment écrire du code de base en C++ et comment utiliser des instructions d'impression pour envoyer des informations à la console.
  
  
• 00:20:00 Dans cette vidéo, le présentateur montre comment les variables sont utiles en programmation, en donnant un exemple de programme qui imprime une histoire. Le présentateur montre ensuite comment créer et attribuer une valeur à une variable nommée "nom du personnage" qui stocke le nom du personnage. Ensuite, le présentateur montre comment créer et attribuer une valeur à une variable nommée "âge" qui stocke l'âge du personnage. Enfin, le présentateur montre comment utiliser une variable pour stocker plusieurs éléments de données.
  
  
• 00:25:00 Dans cette vidéo, le présentateur présente le concept de variables et montre comment les utiliser pour stocker des données dans un programme. Ils montrent comment accéder et manipuler les données stockées dans des variables à l'aide d'instructions d'impression. Enfin, ils montrent comment inclure une variable dans une instruction d'impression afin que les données soient imprimées dans une chaîne distincte.
  
  
• 00:30:00 Cette vidéo présente le concept de variables et de types de données en C++. Une variable est un conteneur qui stocke des données et vous pouvez l'utiliser pour stocker tout type d'informations. Les chaînes sont un type courant de variable, et elles sont une séquence de caractères. Vous pouvez également utiliser des nombres entiers pour stocker des nombres entiers ou des nombres entiers négatifs pour stocker des nombres négatifs. Vous pouvez également stocker des nombres décimaux dans des nombres entiers.
  
  
• 00:35:00 Ce didacticiel couvre les bases de la programmation avec C++, en commençant par du texte et des nombres simples, et en passant à des types de données plus complexes comme les chaînes et les booléens.
  
  
• 00:40:00 Cette vidéo explique comment utiliser les fonctions de chaîne C++ longueur et indexation de chaîne pour imprimer des chaînes et déterminer l'emplacement de caractères spécifiques dans une chaîne, et comment modifier des caractères spécifiques dans une chaîne.
  
  
• 00:45:00 La vidéo couvre les bases du travail avec des chaînes en C++, y compris comment passer des arguments aux fonctions et comment utiliser différentes fonctions mathématiques pour manipuler des chaînes.
  
  
• 00:50:00 Dans ce didacticiel C++, les bases des nombres, de l'addition, de la soustraction, de la multiplication et de la division sont couvertes. L'opérateur de module est également introduit, ce qui est utile pour diviser deux nombres et calculer le reste. Enfin, le stockage des nombres dans des variables est démontré.
  
  
• 00:55:00 Ce didacticiel C++ pour débutants explique comment utiliser les fonctions mathématiques pour résoudre des problèmes. Les fonctions incluent racine carrée, pow et round. L'importation de code à partir d'autres fichiers est également expliquée.

Partie 2

• 01:00:00 Dans ce didacticiel C++ pour débutants, l'utilisateur est invité à entrer son âge et son nom. Le programme stocke ensuite les informations dans une variable appelée âge et imprime le nom et l'âge de l'utilisateur.
  
  
• 01:05:00 Ce didacticiel vidéo montre comment créer une calculatrice de base en c++ et comment créer un jeu Mad Libs.
  
  
• 01:10:00 Cette vidéo explique comment créer et utiliser des tableaux en C++. Les tableaux sont similaires aux variables, mais peuvent contenir plusieurs valeurs.
  
  
• 01:15:00 Ce didacticiel vidéo explique les bases des tableaux en C++. Un tableau est un conteneur qui peut stocker plusieurs éléments de données, et vous pouvez accéder à des éléments individuels par index ou en attribuant une valeur à la propriété "taille" du tableau.
  
  
• 01:20:00 Dans ce didacticiel, l'auteur montre comment créer une fonction en C++. Une fonction est un bloc de code qui exécute une tâche spécifique et peut être réutilisé tout au long d'un programme. Le type de retour de la fonction peut être vide ou un entier. L'auteur montre également comment appeler une fonction.
  
  
• 01:25:00 Dans cette vidéo, l'auteur explique comment fonctionnent les fonctions et comment elles peuvent être réutilisées. Il montre également comment créer une signature de fonction et comment appeler une fonction à l'aide de sa signature. Enfin, il discute des retours en c++, c'est-à-dire lorsqu'une fonction renvoie des informations à l'appelant.
  
  
• 01:30:00 La vidéo explique comment créer des fonctions en C++ et comment utiliser le mot-clé return pour indiquer que la fonction a fini de s'exécuter. La vidéo montre également comment utiliser la fonction cube pour renvoyer le résultat de la mise au cube d'un nombre.
  
  
• 01:35:00 Dans ce didacticiel, l'auteur enseigne aux débutants l'instruction if en C++. Une instruction if est une structure de programmation qui permet à un programme de répondre à différentes situations. L'auteur montre comment utiliser une instruction if pour vérifier les conditions et comment créer des instructions if plus complexes.
  
  
• 01:40:00 Ce didacticiel vidéo explique comment utiliser les opérateurs et et ou en C++ pour vérifier deux conditions. Si l'une ou l'autre des conditions est fausse, l'ensemble du bloc if sera faux et le code ne sera pas exécuté.
  
  
• 01:45:00 Dans ce didacticiel, l'auteur enseigne aux débutants les instructions if, expliquant comment utiliser des comparaisons pour créer des valeurs vraies ou fausses. La fonction prendra deux nombres en entrée et renverra le plus grand.
  
  
• 01:50:00 Cette vidéo explique comment fonctionnent les comparaisons en C++ et comment utiliser supérieur à, inférieur à et égal à pour vérifier si deux nombres sont égaux ou supérieurs ou égaux.
  
  
• 01:55:00 Ce didacticiel C++ pour débutants enseigne comment créer une calculatrice à quatre fonctions, y compris comment saisir des données, vérifier l'égalité des opérateurs et exécuter du code basé sur cette condition.

Partie 3

• 02:00:00 Dans ce didacticiel vidéo, une fonction permettant de convertir un nombre entier en un jour de la semaine est démontrée. La fonction est créée et une instruction if est utilisée pour déterminer si le numéro de jour donné est supérieur ou égal à un. Si c'est un, la fonction renvoie "dimanche" ; s'il n'en est pas un, la fonction retourne "lundi".
  
  
• 02:05:00 Cette vidéo explique comment une instruction switch peut être utilisée pour rendre le code dans une instruction if plus efficace. La vidéo explique ensuite comment créer une instruction switch pour chaque jour de la semaine et illustre la fonction en imprimant le jour de la semaine pour un nombre transmis en entrée.
  
  
• 02:10:00 Cette vidéo donne un aperçu de la vidéo "Tutoriel C++ pour débutants - Cours complet". La vidéo montre comment utiliser une boucle while pour parcourir un bloc de code, lorsqu'une condition est remplie.
  
  
• 02:15:00 Ce didacticiel C++ pour débutants couvre les bases des boucles, notamment comment créer une boucle while et une boucle do while. La vidéo traite également d'une boucle infinie et comment les éviter. Enfin, une boucle for est démontrée.
  
  
• 02:20:00 Ce didacticiel montre comment créer un jeu de devinettes à l'aide d'une boucle while et d'une boucle do while. Le jeu est initialement injuste dans le sens où l'utilisateur obtient des suppositions illimitées, mais le didacticiel montre comment rendre le jeu plus équitable en imposant une limite de supposition.
  
  
• 02:25:00 Dans cette vidéo, l'auteur explique comment fonctionnent les boucles for et comment elles peuvent être utilisées en C++. Il montre également un exemple de la façon dont les boucles for peuvent être utilisées pour résoudre un problème.
  
  
• 02:30:00 Dans cette vidéo, l'auteur explique la boucle while, une construction en boucle dans laquelle une variable change à chaque exécution. La boucle for est une construction similaire, mais elle inclut une déclaration de variable, une initialisation et une condition de bouclage.
  
  
• 02:35:00 Ce didacticiel vidéo montre comment utiliser des boucles for pour parcourir le contenu de tableaux, ainsi que comment créer une fonction qui amène un nombre à une puissance spécifique.
  
  
• 02:40:00 Ce didacticiel vidéo fournit une introduction de base à la programmation C++, en mettant l'accent sur l'utilisation de boucles for pour calculer un résultat spécifique. La fonction en cours de démonstration calcule le résultat d'un nombre élevé à une puissance spécifique.
  
  
• 02:45:00 Dans ce didacticiel, l'auteur montre comment créer et utiliser un tableau à deux dimensions et explique comment accéder aux éléments qu'il contient.
  
  
• 02:50:00 Ce didacticiel vidéo présente le langage C++ et montre comment utiliser les itérateurs for et int pour parcourir des tableaux de données. Les boucles for imbriquées permettent une itération facile des données dans les tableaux.
  
  
• 02:55:00 Cette vidéo explique ce qu'est un pointeur, son utilité et comment le créer en C++.

Partie 4

• 03:00:00 Cette vidéo fournit une introduction conviviale pour les débutants à la programmation C++, avec des exemples d'utilisation de variables et de constantes pour stocker des informations. La vidéo montre également comment accéder aux adresses mémoire pour récupérer les informations qui y sont stockées.
  
  
• 03:05:00 Cette vidéo donne un aperçu de la vidéo "C++ Tutorial for Beginners - Full Course". Dans la vidéo, le présentateur montre comment accéder aux adresses mémoire des variables à l'aide de pointeurs. Un pointeur est juste une adresse mémoire qui n'est qu'un type de données, et vous pouvez l'utiliser pour stocker un pointeur vers une variable différente.
  
  
• 03:10:00 Ce didacticiel explique comment utiliser les pointeurs en programmation et montre comment les déréférencer pour accéder à la valeur stockée à une adresse mémoire particulière. En outre, le didacticiel traite des classes et des objets en c++ et montre comment créer et utiliser une classe.
  
  
• 03:15:00 Dans cette vidéo, un tutoriel C++ pour débutants, l'auteur crée une classe pour représenter des livres. La classe a deux attributs, le titre et l'auteur. L'auteur crée ensuite un objet livre et définit le titre et l'auteur.
  
  
• 03:20:00 Cette vidéo enseigne aux débutants comment créer et travailler avec des objets en C++. Un objet est une instance réelle d'une classe et une classe est le modèle d'un type de données. Les objets peuvent être imprimés et leurs valeurs modifiées.
  
  
• 03:25:00 Cette vidéo explique comment les constructeurs fonctionnent en C++ et comment ils peuvent être utilisés pour initialiser des objets avec des valeurs par défaut.
  
  
• 03:30:00 Ce didacticiel vidéo explique comment créer un constructeur C++ qui accepte le titre, l'auteur et les pages comme valeurs d'entrée. Une fois initialisé, le constructeur peut être utilisé pour créer un nouvel objet sans avoir à passer les valeurs à chaque fois.
  
  
• 03:35:00 Cette vidéo explique comment utiliser les fonctions en C++ pour déterminer si un étudiant a obtenu la mention bien ou non. Les fonctions sont des modèles que chaque objet peut utiliser pour renvoyer vrai ou faux en fonction du propre GPA de l'objet.
  
  
• 03:40:00 Cette vidéo apprendra aux débutants comment utiliser les getters et les setters dans les cours de c++. Les getters et les setters vous permettent de contrôler l'accès aux attributs et aux éléments de vos classes. Cet exemple montre comment appliquer une classification valide pour un film à l'aide de getters et de setters.
  
  
• 03:45:00 Dans ce didacticiel C++ pour débutants, l'auteur montre comment utiliser les getters et les setters pour restreindre les classements pouvant être attribués à un objet vidéo. Si la note transmise ne fait pas partie des notes valides, une erreur est émise ou la note n'est pas définie.
  
  
• 03:50:00 Dans cette vidéo, l'auteur explique comment définir des classements pour des vidéos à l'aide de C++. Tout d'abord, ils expliquent comment les évaluations sont représentées en C++, une évaluation étant égale à une valeur positive telle que 13 ou à une valeur négative telle que -3. Ensuite, ils montrent comment définir une note pour une vidéo à l'aide d'une fonction nommée set rating. Cette fonction prend un paramètre, qui est une chaîne qui représente la note. Si la note saisie n'est pas valide, la fonction renverra une chaîne représentant la note non notée. Enfin, l'auteur montre comment imprimer le classement d'une vidéo à l'aide d'une fonction nommée get rating. Cette fonction ne prend aucun paramètre et renvoie simplement la note de la vidéo.
  
  
• 03:55:00 Dans ce didacticiel C++ pour débutants, l'instructeur montre comment hériter des fonctions et comment les remplacer dans une hiérarchie de classes. Cela permet à une classe d'avoir les mêmes fonctionnalités qu'une autre classe, tout en étendant cette fonctionnalité avec des fonctionnalités supplémentaires.

[MetaQuotes]

Introduction à la programmation et à l'informatique - Cours complet

Introduction à la programmation et à l'informatique - Cours complet

Cette vidéo est un guide du débutant en programmation et en informatique pour ceux qui ont peu ou pas d'expérience en codage. Il couvre les concepts et techniques fondamentaux qui s'appliquent à n'importe quel langage de programmation. La vidéo explique les bases de l'écriture de code dans un environnement de développement intégré (IDE) et souligne l'importance de la grammaire de programmation.

Les sujets abordés dans la vidéo incluent :

1. Introduction à la programmation et à l'informatique, y compris la syntaxe et les règles de programmation.
2. Utilisation de la console pour afficher du texte à partir d'un programme.
3. Opérations mathématiques de base et opérateur de module en programmation.
4. Impression de chaînes sur la console.
5. Comprendre les variables, les types de données et les conventions de dénomination.
6. Comment les variables sont définies, référencées et manipulées dans les programmes.
7. Exploration des instructions if, elsif et else pour une exécution conditionnelle.
8. Présentation des tableaux comme moyen de stocker des variables liées.
9. Bases des boucles, y compris les boucles for, while et do-while.
10. Comprendre les différents types d'erreurs de programmation : les erreurs de syntaxe, les erreurs d'exécution et les erreurs de logique.
11. Techniques de débogage, telles que l'utilisation d'instructions d'impression, de points d'arrêt et de commentaires.
12. Stratégies pour éviter les erreurs de programmation.
13. Travailler avec des fonctions pour organiser le code et réduire les répétitions.
14. Importation de fonctions à partir de bibliothèques et conventions de dénomination des fonctions.
15. Différents types de fonctions et leurs objectifs.
16. Introduction aux dictionnaires en tant qu'option flexible de stockage de données.
17. Présentation des algorithmes de recherche, y compris la recherche linéaire et la recherche binaire.
18. Programmation récursive et ses cas d'utilisation, y compris le concept de cas de base.
19. Compétences non techniques pour l'informatique, telles que la résolution de problèmes et la planification.
20. Utiliser le pseudocode comme outil de planification pour écrire du code.
21. Différentes méthodes de planification et d'écriture de code, y compris les organigrammes et la planification chronologique.
22. Vue d'ensemble des langages de programmation et des ressources disponibles pour l'apprentissage.

La vidéo fournit une introduction complète à la programmation et à l'informatique, offrant aux téléspectateurs les bases nécessaires pour commencer leur voyage de codage. Il suggère également des ressources et des sites Web supplémentaires pour approfondir le sujet.

• 00:00:00 Cette vidéo couvre les principaux points de la vidéo, destinée à ceux qui s'intéressent à l'informatique et à la programmation mais qui ne savent pas par où commencer et qui ont peu ou pas d'informations de base sur le codage. La vidéo couvre les bases de la programmation informatique, qui peuvent être appliquées à tous les langages de programmation que vous souhaitez apprendre.
  
  
• 00:05:00 Cette vidéo explique les bases de la programmation, comment écrire du code dans un environnement de développement intégré (IDE) et l'importance de la grammaire de programmation.
  
  
• 00:10:00 Cette vidéo présente la programmation et l'informatique, et couvre les bases de la syntaxe et des règles de programmation. L'utilisation principale de la console est de sortir du texte du programme.
  
  
• 00:15:00 Cette vidéo couvre les mathématiques de base, y compris l'arithmétique, l'addition, la soustraction, la multiplication et la division, ainsi que le module, un opérateur de base dans de nombreux langages de programmation. Il couvre également l'impression de chaînes sur la console.
  
  
• 00:20:00 Cette vidéo présente les concepts de programmation et d'informatique, y compris les variables, les types et les noms. Les variables primitives incluent les entiers, les booléens, les flottants et les doubles. Les variables de chaîne stockent des chaînes de caractères. Les variables char contiennent un caractère. Les variables sont essentielles pour stocker des informations dans un format facilement référencé.
  
  
• 00:25:00 Cette vidéo explique ce qui se passe lorsque nous définissons ou créons des variables, comment les référencer et comment les manipuler pour nos programmes. Les principaux points à retenir sont que les variables sont simplement des espaces en mémoire qui stockent une certaine valeur, et que nous pouvons mettre à jour les nombres et leur place restera constante dans tout le code.
  
  
• 00:30:00 Une variable est un endroit où vous pouvez stocker des informations lors de la programmation. Les conventions de dénomination des variables sont importantes pour la lisibilité. Si une condition dans une instruction if est vraie, le code entre les accolades s'exécutera. Il existe deux instructions supplémentaires, elsif et eltons, qui fonctionnent de la même manière que les instructions if. Si la condition dans elsif est vraie, le code suivant elsif s'exécutera. Sinon, le code suivant elsif
  sera ignoré. Si la condition dans elsif n'est pas vraie, le code suivant elsif sera ignoré et le code suivant l'instruction if sera exécuté.
  
  
• 00:35:00 Un tableau est une liste de variables liées les unes aux autres. Ils sont utiles lorsqu'un programmeur veut stocker un grand nombre de variables contenant des informations qui sont toutes liées les unes aux autres.
  
  
• 00:40:00 Un cours d'introduction à la programmation et à l'informatique couvre les tableaux, les index, la taille et les tableaux à l'intérieur des tableaux. Les boucles sont également couvertes.
  
  
• 00:45:00 Cette vidéo couvre les différents types de boucles, boucles for, while et do while. Il explique comment configurer une condition pour une boucle et comment éviter une boucle infinie.
  
  
• 00: 50: 00 Cette vidéo couvre les trois types d'erreurs pouvant survenir lors de la programmation : les erreurs de syntaxe, les erreurs d'exécution et les erreurs de logique. Les erreurs de syntaxe sont les plus faciles à corriger, car elles peuvent généralement être corrigées en quelques secondes. Les erreurs d'exécution sont causées par des instructions dans votre code qui semblent logiquement correctes, mais l'ordinateur n'a physiquement aucun moyen de terminer la tâche dans un délai raisonnable. Les erreurs de logique sont les plus furieuses et les plus difficiles à déboguer, car elles peuvent souvent conduire à des programmes qui ne fonctionnent pas comme prévu. Pour déboguer votre code, vous devez le tester de manière incrémentielle et rechercher les erreurs de syntaxe et d'exécution.
  
  
• 00: 55: 00 Si vous rencontrez une erreur dans votre code, vous pouvez utiliser des instructions d'impression et la console pour déterminer où le code ne va pas, utiliser des points d'arrêt pour rechercher la cause de l'erreur et utiliser des commentaires pour marquer code qui vous est destiné et non à l'ordinateur. Enfin, des stratégies pour éviter les erreurs sont discutées.
  
  
• 01:00:00 Dans cette vidéo, l'instructeur couvre les bases de la programmation et de l'informatique, y compris les erreurs et les fonctions. Il poursuit en expliquant comment les arguments fonctionnent dans une fonction et comment utiliser les fonctions pour réduire la répétition dans le code.
  
  
• 01:05:00 Cette vidéo d'introduction à la programmation et à l'informatique traite des quatre différents types de fonctions, de leurs objectifs et de la manière de les utiliser dans votre code. Les fonctions peuvent être utiles pour organiser le code, gagner du temps et apporter des modifications importantes au code sans avoir à parcourir tout le programme.
  
  
• 01:10:00 Dans cette vidéo, les bases de la programmation et de l'informatique sont introduites. L'importation de fonctions à partir de bibliothèques est expliquée et les règles de dénomination des fonctions sont discutées. Des règles de création de fonctions basées sur le type et le nombre d'arguments sont également introduites.
  
  
• 01:15:00 Dans cette vidéo, l'instructeur explique les bases de la programmation et de l'informatique, y compris les fonctions, la portée et le passage d'arguments. Il explique également comment créer des fonctions qui ne renvoient aucune valeur.
  
  
• 01:20:00 Dans cette vidéo, le présentateur passe en revue les tableaux, les fonctions et les dictionnaires. Les tableaux sont comme des listes de valeurs stockées ensemble et les fonctions renvoient une variable en fonction du chemin emprunté. Un petit détail à noter est que vous ne pouvez pas renvoyer un type de variable si vous avez déjà défini la fonction pour renvoyer un autre type. Les listes de tableaux se développent lorsque la taille de la liste dépasse 10 éléments et les dictionnaires stockent plusieurs valeurs.
  
  
• 01:25:00 Un ordinateur stocke les données de différentes manières, ce qui peut être difficile à comprendre. Un dictionnaire est un type de stockage de données, plus fluide et plus facile à organiser que les tableaux traditionnels. Les algorithmes de recherche sont utilisés pour trouver rapidement une donnée spécifique dans une liste de valeurs.
  
  
• 01:30:00 Cette vidéo présente le concept des algorithmes de recherche et leur efficacité. La recherche linéaire est un bon algorithme de base pour les listes non triées, mais elle est inefficace dans le pire des cas. La recherche binaire est un algorithme de recherche efficace pour les listes triées, tirant parti du fait que la liste est triée.
  
  
• 01:35:00 L'algorithme de recherche binaire est plus rapide et plus efficace qu'une recherche linéaire pour trouver un élément dans une liste triée. La fonction récursive est un exemple d'instruction de programmation récursive. Le cas de base d'une instruction récursive est une valeur définie que toutes les instructions récursives doivent respecter. Si n n'est pas inférieur ou égal à un, l'instruction récursive renverra la somme de n, puis la valeur de retour de la méthode de somme récursive moins un.
  
  
• 01:40:00 Cette vidéo présente la programmation et l'informatique et explique pourquoi la récursivité est une technique utile. Les compétences non techniques nécessaires à l'informatique comprennent la résolution de problèmes et la planification. Le pseudocode est une forme simplifiée de programmation qui peut aider à cette planification.
  
  
• 01:45:00 Le pseudocode est une manière visuelle de planifier le code informatique, similaire à la construction d'un plan pour un article. Les organigrammes et l'écriture chronologique de ce que vous voulez que le programme fasse sont deux méthodes courantes.
  
  
• 01:50:00 Cette vidéo présente les concepts de programmation et d'informatique, y compris les différentes méthodes de planification et d'écriture de code, et l'importance du pseudocode. Il couvre également les différents langages de programmation et leurs utilisations.
  
  
• 01:55:00 Dans cette série, l'auteur couvre les bases de la programmation, qui incluent la syntaxe et les règles, et enseigne comment apprendre un langage spécifique. Il fournit également des sites Web et des ressources pour vous aider à démarrer.

[MetaQuotes]

Cours de programmation C++ - Débutant à avancé

Cours de programmation C++ - Débutant à avancé

Le cours couvre différents aspects de la programmation C++.

Les sujets abordés :

1. Configuration d'un environnement de développement C++ : les vidéos expliquent comment configurer un environnement de développement C++ sur différentes plates-formes. Cela inclut l'installation de différents compilateurs et la configuration de Visual Studio Code pour utiliser les compilateurs et la bibliothèque standard C++. Les instructions couvrent des plates-formes telles que Windows, Mac et Linux.

2. Principes de base de la programmation en C++ : les vidéos couvrent des concepts fondamentaux tels que les variables, les types de données, les fonctions et les instructions de contrôle de flux. Ils expliquent comment déclarer des variables, définir des fonctions et utiliser des structures de contrôle telles que des boucles et des instructions conditionnelles. Les vidéos présentent également des concepts tels que les commentaires et la fonction principale en C++.

3. Manipulation de chaînes : des vidéos spécifiques se concentrent sur l'utilisation de chaînes en C++. Ils expliquent comment comparer et concaténer des chaînes à l'aide de fonctions telles que strcmp et strcat. Les vidéos montrent également comment copier des chaînes à l'aide de la fonction strcpy.

4. Tableaux : les vidéos présentent le concept de tableaux en C++. Ils couvrent des sujets tels que la déclaration et l'initialisation de tableaux, l'accès aux éléments à l'aide de pointeurs et l'impression de tableaux de caractères.

5. Allocation de mémoire dynamique et pointeurs : ces vidéos expliquent comment la mémoire est gérée en C++ et comment utiliser les techniques d'allocation de mémoire dynamique pour allouer de la mémoire supplémentaire à un programme. Ils couvrent les concepts de pointeurs, de cartes mémoire et d'unités de gestion de mémoire. Les vidéos expliquent également comment utiliser les pointeurs en toute sécurité, éviter les plantages et gérer plusieurs pointeurs pointant vers le même emplacement mémoire.

6. Modèles de fonctions et fonctions lambda : les vidéos expliquent comment créer des fonctions génériques à l'aide de modèles de fonctions en C++. Ils montrent comment le compilateur peut générer des définitions de fonctions basées sur les types de paramètres transmis. De plus, les vidéos couvrent les fonctions lambda, qui sont des fonctions anonymes qui peuvent être appelées sans leur donner de nom. Ils expliquent la syntaxe et la spécification du type de retour pour les fonctions lambda.

7. Classes et héritage : ces vidéos présentent le concept de classes en C++ et expliquent comment définir des variables membres et des fonctions au sein d'une classe. Ils couvrent des sujets tels que les constructeurs, les destructeurs, les spécificateurs d'accès (protégés et privés) et l'utilisation de liaisons statiques et dynamiques pour réaliser le polymorphisme. Les vidéos montrent également comment créer et utiliser des classes dérivées basées sur des classes préexistantes en utilisant l'héritage.

8. Débogage et gestion des erreurs : les vidéos fournissent des conseils sur le débogage des programmes C++. Ils expliquent comment définir des points d'arrêt, examiner les variables dans la portée locale et gérer les erreurs liées aux pointeurs non initialisés et aux fuites de mémoire. Les vidéos couvrent également des concepts tels que le découpage d'objets et le remplacement des constructeurs de classe de base.

9. Interfaces et polymorphisme : certaines vidéos se concentrent sur les interfaces et le polymorphisme en C++. Ils expliquent comment utiliser la liaison dynamique, les références et le mot-clé override pour obtenir un comportement polymorphe dans les programmes. Les vidéos traitent également du spécificateur final, qui peut être utilisé pour marquer une méthode virtuelle comme finale et l'empêcher d'être remplacée dans les classes dérivées.

10. Autres rubriques : les rubriques supplémentaires couvertes incluent les paramètres par défaut, l'interface d'insertion de flux pour l'impression automatique du flux de sortie et l'utilisation d'interfaces pour créer un code plus lisible.

La vidéo fournit des instructions, des démonstrations et des explications étape par étape pour aider les débutants à apprendre la programmation C++, de l'installation et de la configuration à des concepts plus avancés tels que la programmation orientée objet, la gestion de la mémoire et le polymorphisme. Le contenu convient à la fois aux débutants qui souhaitent apprendre les bases de la programmation C++ et aux programmeurs expérimentés qui souhaitent rafraîchir leurs compétences ou explorer en profondeur des sujets spécifiques.

Code : https://github.com/rutura/The-C-20-Masterclass-Source-Code

Chapitre 1 : Paramétrage des outils

• 00:04:32 Outils de développement C++
• 00:11:06 Installation des compilateurs C++ sous Windows
• 00: 24: 27 Installation du code VS sous Windows
• 00:28:00 Configuration du code Visual Studio pour C++ sous Windows
• 00:57:27 Installation des compilateurs C++ sous Linux
• 01:04:02 Installation du code Visual Studio sur Linux
• 01:07:40 Configuration du code Visual Studio pour C++ sous Linux
• 01:22:45 Installation des compilateurs C++ sur MacOS
• 01:28:07 Installation du code Visual Studio sur MacOS
• 01:30:16 Configuration du code Visual Studio pour C++ sur MacOS
• 01:35:37 Compilateurs en ligne

Chapitre 2 : Plonger

• 01:43:01 Votre premier programme C++
• 01:55:56 Commentaires
• 02:01:56 Erreurs et avertissements
• 02:13:12 Déclarations et fonctions
• 02:31:34 Entrée Sortie
• 02:49:57 Modèle d'exécution de programme C++ et modèle de mémoire
• 02:56:42 Langage de base C++ VS bibliothèque standard VS STL

Chapitre 3 : Variables et types de données

• 03:00:47 Introduction aux variables et aux types de données
• 03:05:05 Systèmes de nombres
• 03:21:52 Entiers
• 03:40:44 Modificateurs entiers
• 03:54:00 Nombres fractionnaires
• 04:16:39 Booléens
• 04:24:49 Caractères et texte
• 04:32:05 Automatique
• 04:38:06 Devoirs
• 04:45:42 Résumé des variables et des types de données

Chapitre 4 : Opérations sur les données

• 04:46:45 Opérations sur l'introduction des données
• 04:47:31 Opérations de base
• 04:58:01 Priorité et associativité
• 05:12:06 Préfixe et suffixe + & -
• 05:23:22 Opérateurs composés
• 05:31:43 Opérateurs relationnels : comparer des éléments
• 05:40:51 Opérateurs logiques
• 05:56:09 Formatage de sortie
• 06:33:26 Limites numériques
• 06:41:10 Fonctions mathématiques
• 06:54:23 Types intégraux étranges
• 06:59:41 Opérations sur le résumé des données

Chapitre 5 : Contrôle de flux

• 07:01:58 Contrôle de flux : introduction à la programmation conditionnelle
• 07:03:30 Si Déclaration
• 07:20:49 Sinon si
• 07:28:46 Commutateur
• 07:42:44 Opérateur ternaire
• 07:52:20 Flow Control : Résumé de la programmation conditionnelle Chapitre 6 : Boucles
• 07:53:49 Introduction aux boucles
• 07:55:20 Pour la boucle
• 08:25:20 Boucle tant que
• 08:36:54 Faire pendant que la boucle

Chapitre 7 : Tableaux

• 08:47:08 Présentation des baies
• 08:48:45 Déclarer et utiliser des tableaux
• 09:15:53 Taille d'un tableau
• 09:26:44 Tableaux de personnages
• 09:46:46 Limites d'un tableau

Chapitre 8 : Pointeurs

• 09:53:23 Présentation des pointeurs
• 09:56:03 Déclarer et utiliser des pointeurs
• 10:14:48 Pointeur vers caractère
• 10:27:26 Carte mémoire programme
• 10:36:30 Allocation de mémoire dynamique
• 11:05:45 Pointeurs suspendus
• 11:24:15 Quand le nouveau échoue
• 11:38:00 Sécurité du pointeur nul
• 11:45:18 Fuites de mémoire
• 11:55:44 Tableaux dynamiques

Chapitre 9 : Références

• 12:11:04 Références Introduction
• 12:11:58 Déclarer et utiliser des références
• 12:22:28 Comparaison des références aux pointeurs
• 12:37:25 Références Et Const

Chapitre 10 : Manipulation de caractères et chaînes

• 12:44:29 Introduction à la manipulation de caractères et aux chaînes
• 12:46:24 Manipulation des personnages
• 13:09:28 Manipulation des cordes en C
• 13:41:42 Concaténation et copie de chaînes C
• 14:01:19 Présentation de std ::string
• 14:03:38 Déclarer et utiliser std ::string

Chapitre 11 : Fonctions

• 14:12:47 Une règle de définition
• 14:28:25 Fonctions de première main
• 15:00:50 Déclaration et définition de fonction
• 15:15:30 Fonctions sur plusieurs fichiers - Modèle de compilation revisité
• 15:42:30 Passer par valeur
• 15:50:30 Passer par le pointeur
• 15:57:46 Passer par référence

Chapitre 12 : Sortir les éléments des fonctions

• 16:03:20 Tirer les choses des fonctions Introduction
• 16:03:58 Paramètres d'entrée et de sortie
• 16:17:54 Retour des fonctions

Chapitre 13 : Surcharge de fonctions

• 16:32:35 Introduction à la surcharge de fonctions
• 16:34:17 Surcharge avec différents paramètres

Chapitre 14 : Fonctions Lambda

• 16:49:00 Présentation des fonctions Lambda
• 16:49:38 Déclaration et utilisation des fonctions Lambda
• 17:20:25 Listes de capture
• 17:34:24 Capturez tout en contexte

Chapitre 15 : Modèles de fonctions

• 17:40:08 Présentation des modèles de fonction
• 17:41:45 Essayer des modèles de fonction
• 18: 19: 52 Déduction de type de modèle et arguments explicites
• 18:35:47 Paramètres de type de modèle par référence
• 18:48:55 Spécialisation des modèles

Chapitre 16 : Concepts

• 19:04:31 Présentation des concepts
• 19:06:47 Concepts
• 19:25:32 Concepts : Construire le vôtre
• 19:42:45 Clause requise : zoom avant
• 19:59:53 Combinaisons logiques de concepts
• 20:09:39 Concepts Et Auto

Chapitre 17 : Cours

• 20:15:40 Présentation des cours
• 20:16:33 Votre premier cours C++
• 20:38:03 Constructeurs
• 20:53:35 Constructeurs par défaut
• 20: 59: 42 Setters et Getters
• 21:10:06 Classe sur plusieurs fichiers
• 21:30:49 Gestion des objets de classe via des pointeurs
• 21:42:48 Destructeurs
• 22:05:44 Ordre d'appel constructeur et destructeur
• 22:11:03 Le pointeur ce
• 22:33:33 Structure
• 22:42:37 Taille des objets de classe

Chapitre 18 : Héritage

• 22:52:43 Présentation de l'héritage
• 22:55:59 Votre premier essai sur l'héritage
• 23:21:10 Membres protégés
• 23:32:06 Spécificateurs d'accès à la classe de base : zoom avant
• 23:36:49 Spécificateurs d'accès à la classe de base : une démo
• 24:07:42 Fermeture sur l'héritage privé
• 24:26:36 Ressusciter les membres de nouveau dans la portée
• 24:46:59 Constructeurs Arg par défaut avec héritage
• 24:57:37 Constructeurs personnalisés avec héritage
• 25:26:56 Copier les constructeurs avec héritage
• 25:51:53 Héritage des constructeurs de base
• 26:06:00 Héritage avec les destructeurs
• 26:12:20 Symboles réutilisés dans l'héritage

Chapitre 19 : Polymorphisme

• 26:21:03 Présentation du polymorphisme
• 26:26:54 Liaison statique avec héritage
• 26:55:24 Polymorphisme (liaison dynamique) avec fonctions virtuelles
• 27:14:31 Taille des objets polymorphes et découpage
• 27:26:37 Objets polymorphes stockés dans des collections
• 27:45:42 Annulation
• 27:52:45 Surcharge, écrasement et masquage
• 28:07:35 Héritage et polymorphisme à différents niveaux
• 28:33:03 Héritage et polymorphisme avec des membres statiques
• 28:49:13 Finale
• 29:07:42 Fonctions virtuelles avec arguments par défaut
• 29:23:18 Destructeurs virtuels
• 29:35:38 Dynamic_cast<>()
• 30:08:17 N'appelez pas de fonctions virtuelles (polymorphes) à partir de constructeurs et de destructeurs
• 30:24:45 Fonctions virtuelles pures et classes abstraites
• 30:43:37 Classes abstraites en tant qu'interfaces

[MetaQuotes]

Cours sur les structures de données de niveau facile à avancé – Tutoriel complet d'un ingénieur Google (parties 1 à 4)

Cours sur les structures de données facile à avancé - Tutoriel complet d'un ingénieur Google

Bref résumé:

00:00:00 - 01:00:00 L'instructeur explique les structures de données et leur importance dans la création d'algorithmes plus rapides et plus puissants. Le tutoriel couvre la notation Big O et comment elle est utilisée pour normaliser le temps et l'espace requis par un algorithme, et des exemples concrets sont fournis pour différentes complexités temporelles. Le didacticiel couvre également la mise en œuvre de tableaux statiques et dynamiques, y compris leurs avantages et leurs inconvénients, et se penche sur la création et l'insertion de nœuds dans des listes à liaison simple et double. Enfin, le didacticiel fournit une introduction à la structure de données de la pile et explique brièvement ses opérations principales.

01:00:00 - 02:00:00 Cette section du didacticiel « Structures de données faciles à avancées » fournit une couverture complète des différentes structures de données et de leurs fonctionnalités. Le didacticiel guide le public sur les principes de fonctionnement des piles et des files d'attente, leurs implémentations à l'aide de tableaux et de listes chaînées, et leur importance dans différentes applications, y compris la traversée de graphes et la gestion des demandes de serveur. Le didacticiel explore également les files d'attente prioritaires et leur implémentation à l'aide de tas, en clarifiant la différence entre les files d'attente prioritaires et les tas ainsi que les types de tas. Le didacticiel se termine par une démonstration étape par étape de la façon d'ajouter et de supprimer des éléments d'un tas binaire.

02:00:00 - 03:00:00 L'ingénieur Google présente un didacticiel complet sur les structures de données, expliquant comment supprimer des nœuds d'une structure de données de tas binaire, comment maintenir l'invariant de tas dans une file d'attente prioritaire et comment nager et nœuds récepteurs dans une structure de données de tas binaire. La vidéo couvre également la structure de données de recherche d'union, qui est utilisée pour suivre les éléments divisés en ensembles disjoints et pour fusionner deux groupes ensemble, avec un exemple sur les aimants pour illustrer le fonctionnement de la structure de données. De plus, l'algorithme de Kruskal pour trouver un arbre couvrant minimum dans un graphe est expliqué, et le concept de compression de chemin est introduit pour rendre la structure de données de recherche d'union plus efficace.

03:00:00 - 04:00:00 Ce didacticiel couvre diverses structures de données, en commençant par la structure de données union-find et ses méthodes, notamment find, connected, parent, size et unify. Le didacticiel passe ensuite aux arbres, y compris les définitions des arbres, des arbres enracinés, des arbres binaires et des arbres de recherche binaires. La vidéo fournit des exemples d'insertion et de suppression de nœuds dans des arbres de recherche binaires, ainsi que différents algorithmes de parcours, y compris le pré-ordre, l'ordre, le post-ordre et l'ordre de niveau, et explique comment implémenter ces constructions en Python et Java. De plus, la vidéo présente les tables de hachage et discute de l'importance des fonctions de hachage et des méthodes populaires de résolution des collisions.

04:00:00 - 05:00:00 La section couvre divers aspects des tables de hachage et leur implémentation. Il traite de l'importance des fonctions de hachage, qui mappent les clés aux valeurs, et de la manière de gérer les collisions de hachage à l'aide de techniques telles que le chaînage séparé et l'adressage ouvert. Le didacticiel couvre également les méthodes d'insertion, de suppression et de recherche d'entrées dans les tables de hachage, ainsi que le redimensionnement et la gestion des facteurs de charge. L'orateur souligne l'importance de choisir une fonction de sondage et une taille de table appropriées pour éviter les boucles infinies et les problèmes de performances. Des exemples pratiques sont utilisés tout au long du didacticiel pour illustrer les concepts.

05:00:00 - 06:00:00 Cette section fournit un aperçu complet des tables de hachage, du double hachage et du sondage quadratique dans la résolution des collisions. La vidéo couvre les concepts de redimensionnement et de croissance d'une table de hachage, de gestion des collisions et de suppression, et de mise en œuvre de tables de hachage à l'aide d'un sondage quadratique. La vidéo présente également l'arbre de Fenwick, une structure de données qui prend en charge les requêtes de plage et les mises à jour de points en temps logarithmique avec un temps de construction linéaire. La vidéo fournit une explication étape par étape de la façon d'effectuer des sommes de préfixe et des requêtes de plage à l'aide de l'arbre de Fenwick.

06:00:00 - 07:00:00 Le didacticiel vidéo couvre divers sujets, y compris le concept d'arbre Fenwick pour les requêtes de plage rapides et les mises à jour de points, l'utilisation de tableaux de suffixes et de tableaux LCP pour trouver des sous-chaînes uniques et les plus longues sous-chaînes communes, et résoudre le plus long problème de sous-chaîne commun utilisant une technique de fenêtre glissante. Le didacticiel explique également comment trouver efficacement la sous-chaîne répétée la plus longue à l'aide du tableau LCP et explore les propriétés et l'importance des arbres de recherche binaires équilibrés, en particulier les arbres AVL, et comment ils peuvent être maintenus équilibrés en utilisant des rotations d'arbres. La vidéo fournit des explications détaillées, des exemples et le code source en Java disponible sur GitHub.

07:00:00 - 08:00:00 La section couvre une gamme de structures de données et leurs implémentations en détail. La vidéo traite des arbres AVL, expliquant les méthodes d'insertion et de suppression, ainsi que la façon d'augmenter la méthode de suppression de l'arbre de recherche binaire pour les arbres AVL. L'instructeur fournit également le code source pour une implémentation d'arborescence AVL récursive en Java, expliquant la méthode d'insertion privée et les méthodes de mise à jour et d'équilibrage. Plus tard, la vidéo couvre en détail les files d'attente prioritaires indexées, expliquant comment attribuer des valeurs d'index aux clés et fournissant un pseudocode pour des opérations utiles telles que l'insertion, la mise à jour et la suppression. La vidéo explique également comment améliorer la suppression des nœuds de la complexité temporelle linéaire à la complexité temporelle logarithmique à l'aide de recherches de position de nœud.

Partie 1

• 00:00:00 Le conférencier présente le concept de structures de données comme moyen d'organiser efficacement les données et comment elles sont essentielles pour créer des algorithmes plus rapides et plus puissants. L'orateur parle de l'importance de comprendre comment et quand utiliser la structure de données appropriée pour la tâche à accomplir et comment les structures de données peuvent rendre le code plus propre et plus facile à comprendre. Le concept de type de données abstrait est également expliqué avec des exemples de la façon dont un type de données abstrait fournit uniquement l'interface et non les détails spécifiques sur la façon dont la structure de données doit être implémentée. De plus, la vidéo aborde brièvement la complexité de calcul afin de comprendre les performances des structures de données.
  
  
• 00: 05: 00 Le concept de notation Big O est introduit comme moyen de standardiser le temps et l'espace nécessaires pour qu'un algorithme s'exécute sur la base de la pire disposition possible des entrées. Big O ne se soucie que de ce qui se passe lorsque les entrées deviennent très grandes et supprime les valeurs constantes ajoutées à la notation Big O. Le concept d'une fonction f est également introduit, et il est indiqué que Big O de f de n est juste n au cube, qui est le terme le plus grand et le plus dominant dans cette fonction.
  
  
• 00:10:00 L'ingénieur Google fournit des exemples concrets d'utilisation de la notation Big O. Les exemples sont classés en fonction de leur complexité temporelle : temps constant, temps linéaire, temps quadratique, temps logarithmique. Il fournit également une ventilation étape par étape de la façon dont une complexité temporelle logarithmique est obtenue en utilisant l'exemple de la recherche binaire. De plus, il montre comment calculer la complexité temporelle d'un algorithme plus compliqué et explique la règle pour déterminer la complexité d'un algorithme.
  
  
• 00:15:00 L'orateur discute de l'analyse de la complexité d'une boucle imbriquée avec une boucle externe et une boucle interne. La boucle interne a une quantité de travail constante et la boucle externe a une quantité de travail variable. Le grand O de la fonction est O(n^4) car n^3 est le terme dominant. Le locuteur introduit ensuite des tableaux statiques, qui sont un conteneur de longueur fixe contenant des éléments indexables qui sont des blocs de mémoire contigus. Les tableaux statiques sont utilisés partout, du stockage temporaire d'objets au stockage d'informations à partir d'un flux d'entrée ou de sortie. L'orateur décrit la structure de base d'un tableau, les opérations courantes qui peuvent être effectuées sur eux et leur analyse de complexité.
  
  
• 00:20:00 L'instructeur discute de l'utilisation des tableaux dans la programmation, y compris comme solution de contournement pour les langages qui n'autorisent qu'une seule valeur de retour et dans la programmation dynamique. Il explique que les tableaux ont un temps d'accès constant en raison de leur propriété indexable, mais que la recherche peut prendre jusqu'à un temps linéaire dans le pire des cas. L'insertion, l'ajout et la suppression d'un tableau statique ne sont pas possibles, mais avec un tableau dynamique, le redimensionnement du tableau interne pour l'ajout des résultats dans une opération rare mais constante. Enfin, il note que les éléments peuvent être itérés à l'aide d'une boucle for-each et que l'indexation des tableaux en informatique commence à zéro, ce qui peut être déroutant pour certains débutants.
  
  
• 00: 25: 00 La vidéo traite du concept d'indexation dans les tableaux, où un crochet indique l'indexation, et de la façon dont les tableaux dynamiques peuvent croître et rétrécir selon les besoins, permettant des opérations de définition similaires à celles des tableaux statiques. Pour implémenter un tableau dynamique, un tableau statique est utilisé, et lorsque la capacité est dépassée, la taille du tableau est doublée et tous les éléments sont copiés dans le nouveau tableau statique. La vidéo montre également le code source de la classe de tableau, qui prend en charge les génériques de type T et possède des variables d'instance pour le tableau statique interne, la longueur et la capacité.
  
  
• 00:30:00 L'instructeur passe par la mise en œuvre de plusieurs méthodes pour un tableau dynamique, notamment size, inset, clear, add, remove, index of, contains et toString. La méthode add implique de redimensionner le tableau en doublant sa taille lorsque la capacité est atteinte, et la méthode remove utilise deux index pour copier tous les éléments du tableau à l'exception de l'index de suppression. L'instructeur montre également comment créer un itérateur pour le tableau dynamique et parle des avantages de l'utilisation d'un itérateur pour itérer sur les éléments d'un tableau. Dans l'ensemble, le didacticiel fournit une introduction simple mais complète à la mise en œuvre de tableaux dynamiques.
  
  
• 00: 35: 00 L'instructeur fournit une introduction aux listes à liaison simple et double, expliquant qu'il s'agit d'une liste séquentielle de nœuds contenant des données et pointant vers d'autres nœuds contenant des données. Les listes chaînées sont utilisées dans la mise en œuvre de listes, de piles et de files d'attente, ainsi que de listes circulaires, de chaînage séparé de table de hachage et pour les listes et les graphiques de contiguïté. L'instructeur couvre également une terminologie utile pour créer des listes liées. De plus, les avantages et les inconvénients des listes à liaison simple et double sont discutés, les listes à liaison simple étant plus efficaces en mémoire mais n'ayant pas la capacité d'accéder aux éléments précédents, tandis que les listes à liaison double peuvent être parcourues en arrière et permettre une suppression facile d'un nœud.
  
  
• 00:40:00 L'instructeur explique les détails de mise en œuvre de la création et de l'insertion de nœuds dans une liste à liaison simple et une liste à double liaison. Pour insérer un nœud dans une liste liée individuellement, un nouveau pointeur est créé, et le pointeur de traverse est avancé jusqu'à la position souhaitée, après quoi le nouveau nœud est créé et lié aux autres nœuds. D'autre part, une liste doublement liée a à la fois des pointeurs suivant et précédent, et lors de l'insertion d'un nouveau nœud, les pointeurs des nœuds adjacents et du nouveau nœud doivent être mis à jour. La suppression d'un nœud d'une liste liée individuellement implique l'utilisation de deux pointeurs pour avancer et supprimer le nœud souhaité, puis désallouer sa mémoire ultérieurement.
  
  
• 00: 45: 00 L'orateur explique comment supprimer des nœuds d'une liste à double lien, ce qui est plus facile que de supprimer des nœuds d'une liste à simple lien car nous n'avons pas à maintenir manuellement les références au dernier nœud. L'orateur montre une implémentation en Java et discute de la complexité de diverses opérations dans les listes chaînées, telles que la recherche et la suppression d'éléments de la tête ou de la queue. Alors que la recherche dans une liste chaînée est linéaire dans le pire des cas, l'insertion dans la tête ou la suppression de la tête est un temps constant. La suppression de la queue prend un temps linéaire dans une liste à liaison simple, mais pas dans une liste à double liaison car elle a une référence au nœud précédent.
  
  
• 00: 50: 00 Dans cette section de la vidéo, le présentateur explique la mise en œuvre d'une liste à double lien avec des méthodes pour effacer la liste, obtenir la taille et vérifier si elle est vide, et ajouter des nœuds au début et à la fin de la liste. Il explique également comment jeter un coup d'œil au premier ou au dernier élément de la liste, supprimer le premier ou le dernier élément et supprimer un nœud arbitraire au milieu de la liste. Le présentateur insiste sur l'importance de désallouer correctement la mémoire et définit la classe de nœud comme privée pour empêcher les utilisateurs d'y accéder directement.
  
  
• 00:55:00 Dans cette section de la vidéo, le tuteur explique comment supprimer un nœud d'un index particulier d'une liste chaînée, même si les nœuds ne sont pas explicitement indexés. La méthode Remove prend en charge la suppression d'une valeur arbitraire de la liste liée et la recherche de valeurs NULL. Le tuteur explique également la méthode index pour obtenir l'index d'un objet dans une liste chaînée et la méthode iterator. Enfin, le tuteur présente la structure de données de la pile et donne brièvement un aperçu de ses opérations principales, push et pop. Le tuteur souligne également que les prochaines vidéos de la série couvriront la mise en œuvre de la pile, les problèmes résolus à l'aide de piles et la complexité temporelle associée aux opérations de pile.

Partie 2

• 01:00:00 La vidéo explique le fonctionnement d'une structure de données en pile et ses diverses utilisations en programmation. La vidéo fournit un exemple détaillé de la façon dont les opérations sont ajoutées et supprimées d'une pile et explique comment les piles sont utilisées dans les éditeurs de texte, les compilateurs et la prise en charge de la récursivité. De plus, la vidéo montre comment une pile peut être utilisée pour effectuer une recherche en profondeur d'abord sur un graphique et présente un exemple intéressant de problème sur la façon de déterminer si une séquence de parenthèses est valide ou non à l'aide d'une pile. Enfin, la vidéo comprend une analyse de la complexité des piles et de leur fonctionnement en tant que liste chaînée.
  
  
• 01:05:00 L'ingénieur Google montre comment vérifier si une séquence de parenthèses est valide à l'aide d'une structure de données en pile. Il parcourt l'algorithme étape par étape, en poussant les crochets gauches sur la pile et en les enlevant lorsqu'il rencontre des crochets droits, et vérifie s'ils correspondent. Il explique également comment le jeu de la tour de Hanoï peut être lié aux piles, car chaque piquet représente une pile et les disques représentent des éléments qui ne peuvent être déplacés que sous certaines conditions. Enfin, il explique comment les piles peuvent être implémentées à l'aide de tableaux ou de listes chaînées.
  
  
• 01:10:00 Nous apprenons à créer une pile à l'aide d'une liste à liens simples et à retirer des éléments de la pile dans une implémentation simple d'une structure de données de pile dans le langage de programmation Java. La pile est créée en pointant la tête vers un nœud nul, ce qui signifie que la pile est vide. Les nouveaux éléments sont insérés avant la tête, et les éléments popping se font en déplaçant le pointeur de tête vers le nœud suivant et en désallouant le dernier nœud. Les fuites de mémoire dans les structures de données peuvent causer des problèmes, il est donc important d'y faire attention dans toutes les structures de données et de les corriger si nécessaire.
  
  
• 01:15:00 L'instructeur discute des files d'attente, une structure de données linéaire utilisée pour modéliser une file d'attente réelle avec deux opérations principales : la mise en file d'attente et la sortie de la file d'attente. L'avant et l'arrière de la file d'attente sont utilisés pour insérer et supprimer des éléments, respectivement. L'instructeur explique également les diverses terminologies entourant les files d'attente, la mise en file d'attente étant parfois appelée ajout et la sortie de file d'attente en tant que sondage ou suppression du début de la file d'attente. Un exemple classique de file d'attente est une file d'attente dans une salle de cinéma ou un restaurant, et les files d'attente peuvent être utiles pour garder une trace des x éléments les plus récents dans une séquence.
  
  
• 01:20:00 La vidéo explique comment les files d'attente sont utilisées pour gérer les requêtes du serveur et pour effectuer une première recherche étendue sur un graphique. Le concept de mise en file d'attente des demandes est introduit, où un serveur inactif ne peut gérer qu'un certain nombre de demandes à la fois et toutes les demandes en excès sont placées dans une file d'attente. La vidéo couvre également les bases de la première recherche en largeur, dans laquelle les nœuds d'un graphe sont visités dans l'ordre de leur distance par rapport à un nœud de départ. La vidéo se termine en expliquant la mise en œuvre des éléments de n-queuing et de dequeuing à l'aide d'une structure de données de file d'attente.
  
  
• 01:25:00 Le didacticiel se penche sur les files d'attente et explique comment le type de données abstrait de file d'attente peut être implémenté à l'aide de tableaux ou de différents types de listes chaînées - listes chaînées simples et listes chaînées doubles. Le didacticiel fournit un exemple de la façon dont la mise en œuvre d'une file d'attente peut fonctionner avec une liste chaînée unique et traite également de la mise en œuvre de diverses méthodes de file d'attente telles que le pic, l'interrogation et l'offre à l'aide du langage de programmation Java. Le didacticiel partage également un lien vers le code source de l'implémentation de la file d'attente sur github.com.
  
  
• 01:30:00 Dans cette section du didacticiel, l'ingénieur Google explique le concept et la mise en œuvre des structures de données, en particulier les files d'attente et les files d'attente prioritaires. Il explique comment une file d'attente prioritaire fonctionne de manière similaire à une file d'attente normale, la seule différence étant que chaque élément a une certaine priorité et que les éléments avec une priorité plus élevée sortent de la file d'attente en premier. Il souligne également que les files d'attente prioritaires ne prennent en charge que des éléments comparables, ce qui signifie que les données que nous insérons dans la file d'attente prioritaire doivent être ordonnées. De plus, il fournit un exemple pour expliquer les opérations d'interrogation et d'ajout d'éléments dans une file d'attente prioritaire. Dans les prochaines sections du didacticiel, il détaillera les opérations courantes effectuées sur les files d'attente prioritaires, la transformation des files d'attente de priorité minimale en files d'attente de priorité maximale, l'analyse de la complexité et les moyens d'implémenter les files d'attente prioritaires.
  
  
• 01:35:00 L'ingénieur Google explique comment les files d'attente prioritaires sont mises en œuvre à l'aide de tas. Un tas est une structure de données arborescente qui satisfait l'invariant de tas, ce qui signifie que la valeur du nœud parent est toujours supérieure ou égale à la valeur du nœud enfant pour tous les nœuds, ce qui donne deux types de tas : Tas max. et tas min. Les tas sont importants car ils forment la structure de données sous-jacente canonique pour les files d'attente prioritaires. L'ingénieur Google montre ensuite des exemples de structures et demande au public s'il s'agit de tas ou non, démontrant que tous les tas doivent être des arbres et satisfaire l'invariant de tas.
  
  
• 01:40:00 L'importance des files d'attente prioritaires dans des algorithmes tels que l'algorithme de chemin le plus court de Dijkstra et le codage de Huffman est discutée. Les files d'attente prioritaires sont utiles dans les situations où il est nécessaire d'extraire dynamiquement le meilleur ou le pire élément suivant. L'accent est mis sur les files d'attente prioritaires implémentées sous forme de tas binaires et sur les opérations, y compris l'ajout d'un élément, la suppression d'un élément, la vérification du confinement et la modification des files d'attente de priorité minimale en files d'attente de priorité maximale. Les tables de hachage peuvent être utilisées pour améliorer la complexité temporelle de suppression afin qu'elle soit logarithmique, tandis qu'un balayage linéaire est effectué pour tous les éléments pour la méthode naïve. La section se termine par un hack pour convertir les files d'attente de priorité minimale en files d'attente de priorité maximale.
  
  
• 01:45:00 L'ingénieur Google explique comment utiliser la négation comme moyen simple d'implémenter des tas inversés dans les files d'attente prioritaires. Il fournit des exemples de manipulation numérique et de chaîne en utilisant une file d'attente de priorité min avec le comparateur lexicographique standard ainsi qu'un comparateur inversé. L'ingénieur introduit également le concept de tas binaires et comment y ajouter des éléments.
  
  
• 01:50:00 L'instructeur explique la terminologie et les concepts importants nécessaires pour comprendre comment ajouter efficacement des éléments à une file d'attente prioritaire à l'aide d'un tas binaire. Il précise qu'une file d'attente prioritaire n'est pas un tas mais un type de données abstrait qui définit le comportement qu'une file d'attente prioritaire devrait avoir, et que les tas ne sont que la structure de données qui nous permet réellement d'implémenter ce comportement. Il aborde également les types de tas, y compris les tas binaires, et explique la propriété complète de l'arbre binaire et comment représenter un tas binaire à l'aide d'une construction de tableau.
  
  
• 01:55:00 L'ingénieur Google explique comment ajouter des nœuds à un tas binaire et maintenir l'invariant du tas en utilisant une technique pour accéder facilement aux nœuds enfants et parents d'un nœud. Ils illustrent avec l'exemple de l'insertion de valeurs dans un tas min et montrent comment faire remonter les nœuds pour satisfaire l'invariant de tas. Dans la section suivante, l'ingénieur couvre la suppression d'éléments d'un tas binaire et souligne l'importance de supprimer la valeur racine, qui est le nœud d'intérêt avec la priorité la plus élevée.

Partie 3

• 02:00:00 L'ingénieur Google explique le processus de suppression des nœuds d'une structure de données de tas binaire à l'aide de la méthode pull. L'extraction se fait dans deux cas, lors de la suppression du nœud racine et lors de la suppression d'un nœud spécifique. Lors de la suppression du nœud racine, le nœud est permuté avec le dernier nœud du tableau et l'invariant de tas est assuré par le bouillonnement. Lors de la suppression d'un nœud spécifique, le nœud est recherché de manière linéaire, permuté avec le dernier nœud du tas, puis l'invariant du tas est assuré par bouillonnement vers le haut ou vers le bas en fonction de la valeur du nœud permuté. L'ingénieur conclut que l'extraction prend un temps logarithmique pour le nœud racine et un temps linéaire pour un nœud spécifique.
  
  
• 02:05:00 Dans cette section du didacticiel, l'ingénieur Google explique comment supprimer des nœuds dans un tas avec une complexité temporelle améliorée en utilisant une table de hachage. Au lieu de faire un balayage linéaire pour trouver l'index du nœud à supprimer, chaque nœud est mappé à l'index auquel il se trouve. Lorsque nous voulons supprimer un nœud particulier, nous recherchons simplement son index pour commencer à le faire. La vidéo explique également comment traiter le problème des valeurs multiples dans le tas et comment suivre les positions des valeurs dans l'arborescence. L'ingénieur explique que tant que nous satisfaisons l'invariant de tas, peu importe le nœud que nous supprimons. Le didacticiel comprend des exemples d'ajout, d'extraction et de suppression d'éléments avec le nouveau schéma proposé.
  
  
• 02:10:00 L'orateur explique comment insérer, supprimer et maintenir l'invariant de tas dans une file d'attente prioritaire à l'aide d'une structure de données de tas. Ensuite, il plonge dans le code source et met en évidence certaines variables d'instance importantes et les constructeurs nécessaires à l'implémentation de la file d'attente prioritaire. Il explique que les éléments autorisés dans la file d'attente prioritaire doivent implémenter l'interface comparable et que la journalisation et les suppressions peuvent être suivies à l'aide d'une carte qui mappe un élément sur un ensemble d'entiers représentant les positions de l'élément dans le tas.
  
  
• 02:15:00 Dans cette section du didacticiel, l'ingénieur Google présente différentes manières de créer une file d'attente prioritaire, y compris la création d'une file d'attente initialement vide avec une capacité définie, la création d'une file d'attente avec une capacité initiale définie et la construction d'une file d'attente en linéaire. temps en utilisant l'opération heapify. L'ingénieur passe également en revue certaines méthodes simples d'une file d'attente prioritaire, notamment vide, clair, taille, aperçu, sondage et contient. La méthode d'ajout est également abordée, avec des détails sur la façon d'ajouter des éléments à la file d'attente et l'importance de garder une trace des éléments dans une carte. La fonction de nage est également mise en évidence comme une étape nécessaire après l'ajout d'un élément à la fin de la liste.
  
  
• 02:20:00 Dans cette section de la vidéo, l'ingénieur de Google explique les méthodes pour nager et couler des nœuds dans une structure de données en tas binaire. La méthode de natation consiste à échanger des nœuds avec son parent et à se déplacer vers le haut jusqu'à ce que le nœud soit dans la position correcte en fonction de sa valeur. La méthode d'enfoncement est similaire mais implique de comparer le nœud avec ses nœuds enfants et de l'échanger avec le plus petit jusqu'à ce qu'il atteigne la position correcte. L'ingénieur explique également les méthodes swap, remove et remove add implémentées dans le tas binaire. La méthode d'ajout de suppression consiste à échanger le nœud supprimé avec le dernier élément du tas et à couler ou à nager le nouveau nœud vers la position appropriée.
  
  
• 02:25:00 Dans cette section du didacticiel, l'instructeur explique comment supprimer un nœud d'une structure de données de tas et s'assurer que l'intégrité minimale du tas est maintenue à l'aide d'une méthode pour couler ou nager les nœuds selon que l'échange affecte la structure du tas. commande. La section présente également la structure de données union find et ses deux opérations principales, find et union, qui sont utilisées pour suivre les éléments divisés en ensembles disjoints et pour fusionner deux groupes, respectivement.
  
  
• 02:30:00 L'orateur utilise l'exemple des aimants pour expliquer le fonctionnement de la structure de données union find. La recherche d'union fusionne efficacement des éléments ou des groupes d'éléments, en leur attribuant une couleur arbitraire. La structure de données de recherche d'union est utilisée dans divers algorithmes, tels que l'algorithme d'arbre couvrant minimum et la percolation de grille. La découverte d'union a une excellente complexité et sa construction est en temps linéaire, tandis que sa fonction de comptage de composants peut déterminer le nombre de composants en temps constant, ce qui en fait une excellente structure de données à avoir autour.
  
  
• 02:35:00 Dans cette section du didacticiel, l'ingénieur Google explique l'algorithme de Kruskal pour trouver un arbre couvrant minimum dans un graphe. L'algorithme consiste à trier les arêtes par poids d'arête ascendant, puis à unifier les nœuds qui n'appartiennent pas au même groupe, jusqu'à ce que tous les sommets soient unifiés en un seul groupe. La structure de données de recherche d'union est utilisée pour fusionner efficacement des groupes et éviter les cycles. L'ingénieur fournit un exemple de graphique et parcourt les étapes de l'algorithme pour illustrer son fonctionnement.
  
  
• 02:40:00 Le didacticiel explique la structure de données de recherche d'union et son fonctionnement interne. La première étape consiste à créer un mappage entre les objets et les entiers dans la plage de zéro à N non inclus, où N est le nombre d'éléments. Ensuite, un tableau est construit et chaque index a un objet associé, ce qui se fait via le mappage. La valeur dans la position du tableau est initialement l'index auquel il se trouve, et chaque nœud est un nœud racine mappé sur lui-même. Au fur et à mesure que les instructions sont exécutées pour unifier les objets en groupes, les valeurs du tableau ont changé pour correspondre à d'autres objets. Les composants plus petits sont fusionnés en composants plus grands et les nœuds racine sont utilisés pour unifier les groupes.
  
  
• 02:45:00 L'orateur explique comment fusionner des éléments dans différents groupes à l'aide de la structure de données union find. En trouvant et en suivant les nœuds parents du nœud racine de chaque composant, nous pouvons déterminer à quel composant appartient un élément. Pour unifier deux composants, nous faisons pointer l'un des nœuds racine vers le parent de l'autre racine. Le nombre de composants est égal au nombre de nœuds racine restants, et le nombre de nœuds racine ne fait que diminuer à mesure que nous unifions les composants. L'orateur note également que la mise en œuvre de cette structure n'a actuellement pas de complexité temporelle amortie sans l'utilisation de la compression de chemin, une optimisation qui sera discutée dans la prochaine vidéo.
  
  
• 02:50:00 Le concept de compression de chemin est introduit pour montrer comment il rend la structure de données de recherche d'union plus efficace. La compression de chemin implique la compression de tous les nœuds le long du chemin vers le nœud racine, permettant ainsi une recherche en temps constant du nœud racine pour un composant donné. L'exemple d'unification des groupes avec et sans compression de chemin est donné pour comparer et opposer les deux méthodes, démontrant l'efficacité obtenue grâce à la compression de chemin.
  
  
• 02:55:00 L'instructeur explique comment la compression de chemin et la recherche d'union fonctionnent ensemble pour créer une structure de données efficace. Il montre comment la compression de chemin comprime dynamiquement les chemins en cours de route jusqu'à atteindre un état final. Le code de recherche d'union est présenté dans la vidéo, avec des explications sur l'utilisation des tableaux pour l'indexation et le suivi des relations parent-enfant. De plus, le code inclut des méthodes pour vérifier le nœud racine et compresser le chemin d'accès à celui-ci. L'instructeur insiste sur l'importance de regarder d'autres vidéos sur la trouvaille syndicale pour bien comprendre le sujet.

Partie 4

• 03:00:00 L'instructeur présente une structure de données union-find et ses méthodes, notamment find, connected, parent, size et unify. Il montre comment les nœuds racines de la structure contiennent la taille de chaque composant connecté, et la méthode unify fusionne des groupes plus petits en groupes plus grands. Passant aux arbres, l'instructeur donne un bref aperçu des arbres sous forme de graphes non orientés et présente les arbres binaires et les arbres de recherche binaires. Il promet d'expliquer comment insérer et supprimer des nœuds dans les arbres de recherche binaires, les traversées d'arbres et comment ils peuvent être appliqués aux arbres généraux dans des didacticiels ultérieurs.
  
  
• 03:05:00 Le concept d'arbres est introduit, avec de multiples définitions fournies. Un arbre peut être défini comme un graphe non orienté connexe et acyclique, comme un graphe à n nœuds et n-1 arêtes, ou comme un graphe où il n'y a qu'un seul chemin entre deux sommets. Un arbre enraciné est également introduit, où n'importe quel nœud peut devenir la racine et les nœuds enfants et parents sont définis. Le parent du nœud racine est lui-même et les nœuds feuilles sont définis comme des nœuds sans enfant. Le concept de sous-arbre est également introduit, désigné par des triangles dans un arbre. De plus, la définition d'un arbre binaire est expliquée comme un arbre dans lequel chaque nœud a au plus deux enfants.
  
  
• 03:10:00 La vidéo couvre les arbres de recherche binaires, qui sont des arbres binaires qui satisfont l'invariant de l'arbre de recherche binaire. Cela signifie que le sous-arbre de gauche a toujours des valeurs plus petites que le nœud actuel et que le sous-arbre de droite a des valeurs plus grandes. La vidéo présente divers exemples d'arbres de recherche binaires et invite les spectateurs à déterminer s'ils satisfont l'invariant. Les arbres de recherche binaires sont utiles dans de nombreuses implémentations de types de données abstraits et sont utilisés dans les arbres de recherche binaires équilibrés et les arbres de syntaxe. Ils ont également une complexité temporelle logarithmique dans le cas moyen pour des opérations comme l'insertion et la recherche sur des données aléatoires.
  
  
• 03:15:00 Dans cette section du didacticiel, l'ingénieur Google explique les arbres de recherche binaires et comment y insérer des éléments. Les arbres de recherche binaires ont en moyenne un comportement logarithmique, ce qui les rend faciles à mettre en œuvre et efficaces dans la plupart des cas. Cependant, dans le pire des cas, un arbre binaire peut devenir une structure de données linéaire, ce qui n'est pas idéal. Pour insérer un élément dans un arbre de recherche binaire, l'élément doit être comparable et l'un des quatre cas suivants peut se produire : récursivité vers le bas du sous-arbre gauche, récursivité vers le bas du sous-arbre droit, gestion des valeurs en double ou insertion d'un nouveau nœud. Enfin, l'ingénieur montre comment insérer des valeurs dans un arbre de recherche binaire à l'aide d'animations.
  
  
• 03:20:00 L'ingénieur Google explique le pire scénario lors de l'insertion de valeurs dans un arbre de recherche binaire, ce qui le transforme en une structure linéaire. Ce comportement n'est pas souhaitable car il ralentit les opérations telles que la recherche de nœuds ou la suppression de valeurs. L'ingénieur explique ensuite comment supprimer des éléments d'un arbre de recherche binaire en deux étapes : d'abord trouver le nœud à supprimer, puis le remplacer par son successeur pour maintenir l'arbre de recherche binaire invariant. La vidéo fournit un exemple de recherche de valeurs dans un arbre de recherche binaire pour aider à comprendre le processus.
  
  
• 03:25:00 L'ingénieur Google explique les quatre cas de la phase Remove lorsqu'il s'agit d'un arbre de recherche binaire. Le premier cas est lorsque le nœud à supprimer est un nœud feuille, les deuxième et troisième cas se produisent lorsqu'il n'y a qu'un seul sous-arbre à gauche ou à droite. Le quatrième cas se produit lorsque le nœud a à la fois un sous-arbre gauche et droit, et la question est dans quel sous-arbre sera le successeur du nœud ? La réponse est que le successeur peut être soit la plus grande valeur du sous-arbre de gauche, soit la plus petite valeur du sous-arbre de droite, et il peut y avoir deux successeurs possibles.
  
  
• 03:30:00 Dans cette section du cours, l'instructeur explique comment supprimer des nœuds des arbres de recherche binaires en utilisant le concept de nœud successeur. Le successeur est soit le plus petit nœud du sous-arbre de droite, soit le plus grand nœud du sous-arbre de gauche. L'instructeur démontre la suppression des nœuds à travers plusieurs exemples, en insistant sur l'importance de rééquilibrer l'arborescence après la suppression. La section se termine par un aperçu des différentes traversées d'arbres, y compris la pré-commande, la commande, la post-commande et l'ordre de niveau.
  
  
• 03:35:00 L'instructeur explique les concepts de parcours pré-ordre, dans l'ordre et post-ordre dans les arbres binaires. Il explique que la précommande imprime la valeur du nœud actuel suivie de ses sous-arbres gauche et droit, puis fournit un exemple du fonctionnement de la traversée de précommande dans un arbre binaire, en maintenant une pile d'appels pour garder une trace des nœuds visités. De même, il explique comment fonctionne la traversée dans l'ordre, ce qui implique de traverser le sous-arbre gauche, d'imprimer la valeur, puis de traverser le sous-arbre droit. L'instructeur utilise un arbre de recherche binaire comme exemple et met en évidence l'ordre dans lequel les nœuds sont visités et imprimés pendant le parcours.
  
  
• 03:40:00 Le didacticiel traite de différents algorithmes de parcours pour les arbres binaires. Tout d'abord, le parcours dans l'ordre, qui imprime les valeurs des nœuds dans l'ordre croissant. Ensuite, le parcours post-ordre, qui traverse le sous-arbre gauche, puis le sous-arbre droit, et seulement après que les deux aient été parcourus, imprime la valeur du nœud. Le didacticiel poursuit en expliquant la première recherche étendue et comment elle peut être utilisée pour la traversée d'ordre de niveau, qui imprime les nœuds une couche à la fois. Une file d'attente est utilisée pour garder une trace des nœuds à explorer, et les nœuds sont ajoutés à la file d'attente au fur et à mesure que leurs nœuds parents sont visités.
  
  
• 03:45:00 Dans cette section de la vidéo, l'instructeur explique comment effectuer une recherche en profondeur à l'aide d'une structure de données de file d'attente. Il montre le processus d'exploration des nœuds et d'ajout de leurs enfants à la file d'attente en fonction de leur ordre. Il souligne l'importance d'utiliser une file d'attente au lieu d'une pile lors de l'exécution d'une traversée d'ordre de niveau. La vidéo se concentre ensuite sur la mise en œuvre d'un arbre de recherche binaire en Java, l'instructeur expliquant la structure de classe, les variables d'instance et les méthodes utilisées pour ajouter des éléments à l'arbre. Il souligne également l'importance de choisir un type comparable lorsque l'on travaille avec des arbres de recherche binaires.
  
  
• 03:50:00 L'instructeur explique le processus de suppression des nœuds d'un arbre de recherche binaire. Ils commencent par discuter de la méthode publique de suppression des nœuds et expliquent qu'ils ne supprimeront le nœud que s'il existe dans l'arborescence, qui est vérifiée en premier. Ensuite, ils se penchent sur la méthode récursive utilisée pour supprimer le nœud, qui consiste à rechercher le nœud à supprimer, puis à le supprimer en fonction du fait qu'il a des sous-arbres gauche et/ou droit. L'instructeur explique trois cas différents de suppression, qui impliquent soit une sous-arborescence gauche ou droite, soit à la fois une sous-arborescence gauche et droite. Ils fournissent également des méthodes d'assistance pour parcourir l'arborescence afin de trouver le nœud successeur.
  
  
• 03:55:00 L'ingénieur Google explique comment implémenter un arbre de recherche binaire en Python, y compris l'insertion d'un nouveau nœud, la recherche d'un élément spécifique et le calcul de la hauteur de l'arbre. Il montre également comment implémenter des parcours d'arbres binaires de manière itérative à l'aide d'une méthode personnalisée appelée "traverse", qui prend un ordre de parcours d'arbre en entrée et renvoie un itérateur pour cet ordre. Ensuite, il présente les tables de hachage et discute de l'importance des fonctions de hachage, ainsi que des méthodes de résolution de collision populaires comme le chaînage séparé et l'adressage ouvert.

[MetaQuotes]

Cours facile à avancé sur les structures de données - Tutoriel complet d'un ingénieur Google (parties 5 à 8)

Cours sur les structures de données facile à avancé - Tutoriel complet d'un ingénieur Google

Partie 5

• 04:00:00 L'instructeur présente le concept de tables de hachage et sa mise en œuvre à l'aide de techniques de hachage. Les tables de hachage sont utilisées pour construire un mappage des clés aux valeurs, où chaque clé est unique et est associée à une valeur. Pour mapper les clés aux valeurs, une fonction de hachage est utilisée, qui mappe les clés à un nombre entier dans une plage fixe. L'instructeur montre comment définir des fonctions de hachage pour des objets arbitraires, tels que des chaînes, à l'aide des valeurs ASCII des caractères de la chaîne. Les tables de hachage sont souvent utilisées pour suivre les fréquences des valeurs et construire des mappages entre les paires clé-valeur, à condition que les clés soient hachables. La section se termine par un mini défi pour définir une fonction de hachage pour une base de données de personnes avec trois champs.
  
  
• 04:05:00 L'instructeur discute des fonctions de hachage et de leurs propriétés. La fonction de hachage est définie arbitrairement et peut avoir un nombre infini de possibilités. L'instructeur insiste sur le fait que les fonctions de hachage doivent être déterministes pour éviter de bousiller la table de hachage. L'uniformité des fonctions de hachage est également importante pour minimiser les collisions de hachage qui se produisent lorsque deux objets hachent la même valeur. L'instructeur illustre également comment les valeurs de hachage peuvent accélérer les comparaisons d'objets et poursuit en expliquant que des fonctions de hachage sophistiquées telles que les fonctions de hachage cryptographiques et les sommes de contrôle sont utilisées pour les fichiers au lieu des fonctions de hachage utilisées pour les tables de hachage.
  
  
• 04:10:00 Le didacticiel explique ce qui rend une clé de type 't' hachable et comment fonctionne une table de hachage en utilisant une fonction de hachage uniforme pour l'indexer. Il mentionne que les fonctions de hachage doivent être déterministes et appliquer des clés immuables qui sont fixes et constantes, telles que des chaînes immuables et des entiers. En utilisant la fonction de hachage comme moyen d'indexer dans une table de hachage, nous pouvons obtenir des temps d'insertion, de recherche et de suppression rapides en temps constant. Le didacticiel fournit également un exemple d'insertion de paires clé-valeur dans une table qui conduit finalement à une collision de hachage et explique comment gérer les collisions.
  
  
• 04:15:00 L'orateur discute des techniques de résolution des collisions de hachage, en particulier du chaînage séparé. Le chaînage séparé est un moyen de gérer les collisions de hachage en conservant une structure de données auxiliaire, généralement une liste chaînée, pour contenir toutes les différentes paires clé-valeur qui hachent en une valeur spécifique. La complexité temporelle d'une table de hachage peut atteindre en moyenne une insertion, une suppression et une recherche à temps constant, mais avec une fonction de hachage terrible qui n'est pas uniforme, il peut s'agir d'un temps linéaire. L'orateur fournit également un exemple du fonctionnement du chaînage séparé et de la manière dont nous pouvons l'utiliser pour gérer les collisions dans notre table de hachage en maintenant une structure de données de liste chaînée pour chaque index du tableau.
  
  
• 04:20:00 L'orateur explique comment fonctionnent les recherches dans une table de hachage avec chaînage séparé, qui utilise des listes chaînées pour gérer les collisions. Avec une clé donnée, l'orateur montre comment trouver la valeur correspondante en hachant la clé et en recherchant la liste chaînée dans le seau correspondant de la table de hachage. L'orateur aborde également certaines questions courantes sur le maintien d'une complexité temporelle constante, la suppression des paires clé-valeur et l'utilisation de différentes structures de données pour gérer les compartiments dans la table de hachage. Enfin, l'orateur partage du code source pour une implémentation de table de hachage utilisant un chaînage séparé.
  
  
• 04:25:00 La vidéo présente les tables de hachage et leur implémentation en Java. La classe d'entrée est d'abord abordée, en mettant l'accent sur les génériques, les codes de hachage et la méthode equals. La table de hachage elle-même est ensuite expliquée, y compris les variables d'instance telles que le facteur de charge maximal, la capacité, le seuil et la table elle-même, qui est un tableau de listes liées. Diverses méthodes telles que la taille, vide, clair, contient la clé et le hachage sont également discutées avec leurs détails de mise en œuvre. Enfin, la méthode d'index normalisé est expliquée, qui est utilisée pour convertir une valeur de hachage en un index à rechercher dans la table de hachage.
  
  
• 04:30:00 Dans cette section de la vidéo, l'orateur explique les méthodes impliquées dans la mise en œuvre d'une table de hachage telles que l'insertion, l'obtention, la suppression, la recherche d'entrée et le redimensionnement de la table. La méthode insert ajoute une nouvelle entrée à la table de hachage ou met à jour une entrée existante, tandis que get récupère la valeur associée à une clé spécifique. Remove supprime la paire clé-valeur de la table de hachage et la méthode de recherche d'entrée aide à trouver l'entrée à un index de compartiment donné. Enfin, redimensionner la table redimensionne la table en doublant sa capacité, puis crée une nouvelle table avec la nouvelle capacité, déplace les données de l'ancienne table vers la nouvelle table et supprime les anciennes données.
  
  
• 04:35:00 L'instructeur discute de la technique d'adressage ouvert pour résoudre les collisions dans les tables de hachage. Cette méthode stocke les paires clé-valeur dans la table elle-même au lieu d'une structure de données auxiliaire. Par conséquent, il est crucial de gérer la taille de la table de hachage et le nombre d'éléments qu'elle contient. Le facteur de charge, qui est le rapport entre les éléments et la taille de la table, doit être maintenu en dessous d'un certain seuil pour éviter qu'il ne devienne exponentiellement mauvais. Lors de l'insertion d'une nouvelle clé, la fonction de hachage donne une position d'origine pour la clé, mais s'il y a une collision, une séquence de sondage est utilisée pour trouver la prochaine place libre. La séquence de sondage linéaire est l'une des nombreuses parmi lesquelles choisir.
  
  
• 04:40:00 L'instructeur discute de l'adressage ouvert, une méthode de gestion des collisions dans les tables de hachage où l'élément est placé à un emplacement différent lorsque l'index de hachage d'origine est déjà occupé. Diverses fonctions de sondage sont introduites, telles que le sondage linéaire, le sondage quadratique, le double hachage et la fonction de sondage de générateur de nombres pseudo-aléatoires, chacune utilisant une formule mathématique différente pour trouver le créneau suivant. Cependant, la principale difficulté de l'adressage ouvert est la possibilité de produire des cycles plus courts que la taille de la table de hachage, ce qui peut conduire à une boucle infinie. Un exemple pratique est donné pour illustrer ce problème.
  
  
• 04:45:00 L'orateur discute de la question des cycles dans les fonctions de sondage utilisées dans les tables de hachage et comment la gérer. L'orateur explique que des techniques telles que le sondage linéaire, le sondage quadratique et le double hachage sont toutes sujettes à ce problème de cycles mais peuvent être redéfinies pour produire un cycle de longueur afin d'éviter d'être coincé dans une boucle infinie lors de l'insertion d'un élément. La constante "b" dans le sondage linéaire est considérée comme obsolète, et l'orateur mentionne que certaines fonctions linéaires peuvent être incapables de produire un cycle complet d'ordre "n". La solution à ce problème est de choisir des fonctions de sondage qui produisent un cycle d'exactement "n" en s'assurant que la constante "a" et la taille de table "n" sont relativement premières l'une par rapport à l'autre.
  
  
• 04:50:00 L'instructeur discute des tables de hachage et de leur fonctionnement, y compris les fonctions de détection, la taille de la table, le facteur de charge et le redimensionnement. Il utilise un exemple de sondage linéaire pour montrer comment insérer des paires clé-valeur dans une table de hachage et éviter les boucles infinies causées par des collisions de hachage. Cependant, il souligne que le choix de la fonction de sondage et de la taille de la table peut avoir un impact significatif sur les performances, et la sélection d'une fonction dont le plus grand dénominateur commun avec la taille de la table n'est pas un peut entraîner des cycles et causer des problèmes.
  
  
• 04:55:00 Nous voyons un exemple d'utilisation d'une fonction de sondage pour insérer des paires clé-valeur dans une table de hachage sans aucune collision. Si une collision se produit, la fonction de sondage continuera à sonder jusqu'à ce qu'un point vide soit trouvé pour éviter tout cycle. Une fois que le nombre d'éléments dépasse le seuil de la table, la taille de la table est doublée tout en maintenant le PGCD de N. Les anciens éléments sont alors placés dans la nouvelle table en utilisant la nouvelle taille de table tout en gardant la même fonction de sondage. Enfin, une nouvelle paire clé-valeur est insérée, et si la place est libre, il n'y a aucun problème.

Partie 6

• 05:00:00 L'instructeur discute du sondage quadratique dans les tables de hachage, qui est utilisé pour traiter les collisions dans l'adressage ouvert. Cela implique de sonder selon une formule quadratique en utilisant une sélection d'une fonction de sondage aléatoire. L'instructeur explique que toutes les fonctions quadratiques ne sont pas viables car elles ne produisent pas de cycle d'ordre qui aboutit à rester bloquées dans une boucle infinie, mais la plupart des fonctions quadratiques sélectionnées au hasard finiront par produire un cycle. L'instructeur fournit les trois méthodes les plus courantes pour sélectionner une fonction de sondage et se concentre sur la seconde où p de x est égal à x au carré plus x divisé par deux et la taille du tableau est une puissance de deux.
  
  
• 05:05:00 L'orateur discute du processus d'insertion d'éléments dans des tables de hachage en utilisant la technique de double hachage et de résolution de collision d'adressage ouvert. Ils expliquent l'importance que la taille de la table soit une puissance de deux et comment gérer les collisions à l'aide du sondage. L'orateur démontre également le processus de redimensionnement du tableau lorsque le facteur de charge dépasse un certain seuil. Ils discutent ensuite de la façon de mettre à jour les éléments existants et d'en insérer de nouveaux dans le tableau.
  
  
• 05:10:00 L'instructeur explique le concept de double hachage, qui est une méthode de sondage utilisée pour gérer les collisions dans les tables de hachage. Le schéma de double hachage consiste à sonder selon un multiple constant d'une autre fonction de hachage, appelée fonction de hachage secondaire. L'instructeur met en garde contre le problème des cycles infinis qui peuvent survenir en cas de double hachage et propose une stratégie pour y remédier, qui consiste à choisir un nombre premier pour la taille de la table et à construire une valeur appelée delta. Il discute également de la manière systématique de générer de nouvelles fonctions de hachage pour différents types de données en utilisant le même bloc de construction fondamental.
  
  
• 05:15:00 L'orateur explique le concept des fonctions de hachage et comment elles peuvent être combinées pour créer une nouvelle fonction de hachage. Ils mentionnent l'utilisation des fonctions de hachage universelles et fournissent un exemple utilisant le double hachage. Ils discutent du processus d'insertion de paires clé-valeur dans une table de hachage tout en gérant les collisions et les mises à jour de hachage. L'exemple utilise une taille de table de sept et un facteur de charge maximal de 0,75, et la fonction de hachage utilise des entiers et des nombres réels comme blocs de construction.
  
  
• 05:20:00 Le didacticiel explique le processus de redimensionnement et de croissance d'une table de hachage avec double hachage, ce qui implique de doubler la taille de la table, de trouver le nombre premier suivant au-dessus de cette valeur, d'allouer une nouvelle table et d'insérer les anciens éléments dans le nouveau tableau. Le didacticiel fournit un exemple où la table d'origine a atteint son seuil maximal après l'insertion de cinq éléments, et la table est redimensionnée à une nouvelle taille de 17. Le didacticiel explore également les problèmes qui surviennent lors de la suppression d'éléments d'une table de hachage à l'aide de l'adressage ouvert et l'importance d'éviter les collisions lors des opérations d'insertion et de suppression.
  
  
• 05:25:00 La vidéo explique comment gérer les collisions de hachage et la suppression dans une table de hachage. La méthode naïve de suppression, qui efface simplement le contenu du seau, s'avère défectueuse car elle a un impact sur la capacité à trouver correctement des éléments dans la table de hachage. Au lieu de cela, la vidéo recommande de placer un marqueur unique appelé pierre tombale à la place de l'élément supprimé. Ce marqueur peut ensuite être remplacé par une nouvelle paire clé-valeur ou supprimé lors du redimensionnement de la table de hachage. La vidéo fournit un exemple utilisant le sondage quadratique pour montrer comment les pierres tombales sont utilisées lors de la recherche de table de hachage.
  
  
• 05:30:00 L'ingénieur Google donne un aperçu des tables de hachage qui utilisent deux adresses ouvertes comme schéma de résolution des collisions. L'ingénieur discute de la suppression paresseuse ou de la relocalisation paresseuse, qui implique la relocalisation des paires clé-valeur pour éviter de heurter un tas de pierres tombales lors de l'exploration. L'ingénieur fournit également une présentation du code d'une table de hachage qui utilise le sondage quadratique, ce qui implique de stocker des paires clé-valeur directement dans un tableau plutôt que d'avoir un tableau avec une classe wrapper pour une entrée. L'ingénieur explore le constructeur et les constantes par défaut de la table de hachage, ce qui permet aux utilisateurs de l'initialiser sans aucun paramètre.
  
  
• 05:35:00 Dans cette section du cours, l'instructeur explique la mise en œuvre de la table de hachage à l'aide du sondage quadratique. La méthode consiste à calculer le seuil, à normaliser l'index et à initialiser les tables. Les informations sur la méthode d'insertion sont fournies là où les paires clé-valeur sont insérées dans la table de hachage ou mises à jour si la clé existe déjà. L'instructeur discute également du nombre de clés, de la vérification vide de la table de hachage et de l'addition avant de passer à la méthode d'insertion. La boucle do-while pour l'insertion d'une clé est expliquée en détail.
  
  
• 05:40:00 L'instructeur explique les méthodes contains key, has key, get et remove d'une implémentation de table de hachage. Les méthodes contains key et has key vérifient si une clé existe dans la table de hachage en appelant la méthode get, qui renvoie une valeur true ou false pour l'indicateur contains. La méthode get trouve l'index de hachage et recherche la clé. Si la clé existe, l'indicateur contains est défini sur true et la valeur est renvoyée. La méthode de suppression est plus simple, où une clé est d'abord trouvée dans la table de hachage, puis décrémentée, et une pierre tombale est vidée à sa place. La méthode de redimensionnement de table est appelée lorsque de nouveaux éléments sont insérés pour augmenter la taille de la table, où une nouvelle table est allouée et la table actuelle est échangée avec la nouvelle table pour appeler la méthode d'insertion.
  
  
• 05:45:00 L'arbre Fenwick, également connu sous le nom d'arbre d'index binaire, est introduit en tant que structure de données pour calculer efficacement les requêtes de plage sur un tableau et effectuer des mises à jour ponctuelles. La motivation derrière l'arbre de Fenwick est l'inefficacité des requêtes linéaires lors du calcul des plages dans un tableau. En calculant toutes les sommes de préfixes pour le tableau, les requêtes de plage peuvent être calculées en temps constant. Cependant, les mises à jour du tableau nécessitent de recalculer toutes les sommes de préfixes, ce qui rend le processus inefficace. L'arbre Fenwick a été créé pour résoudre ce problème en prenant en charge les requêtes de plage et les mises à jour de points en temps logarithmique avec un temps de construction linéaire. L'arbre de Fenwick fonctionne en ayant chaque cellule responsable d'une plage d'autres cellules en fonction de la valeur de son bit le moins significatif.
  
  
• 05:50:00 Dans cette section de la vidéo, l'instructeur discute des arbres de Fenwick et de leur fonctionnement pour les requêtes de plage. Il montre un diagramme avec un tableau à base un et la représentation binaire de chaque nombre. Le diagramme montre les bits les moins significatifs responsables d'eux-mêmes et toutes les autres cellules responsables d'une plage de 2, 4, 8 ou 16 cellules. Pour effectuer une requête de plage, l'instructeur explique comment calculer la somme des préfixes jusqu'à un certain index en cascade vers le bas jusqu'à atteindre zéro. Il montre comment trouver la somme des préfixes pour un index spécifique et comment faire une somme d'intervalle entre deux indices donnés.
  
  
• 05:55:00 Nous apprenons à calculer des sommes de préfixes à l'aide d'un effet descendant en cascade et à exécuter un algorithme de requête de plage à l'aide d'arbres de Fenwick. Le calcul de la somme des préfixes consiste à commencer à un indice donné et à soustraire le bit le moins significatif de la valeur jusqu'à ce qu'il atteigne zéro, puis à ajouter toutes les valeurs lors de chaque soustraction. L'algorithme de requête de plage utilise des arbres de Fenwick où nous prenons la différence entre les sommes de préfixes pour les requêtes de plage. L'algorithme nécessite une manipulation de bits et fournit un petit algorithme soigné pour un calcul plus rapide. L'auteur de la vidéo recommande de consulter la vidéo précédente sur la requête d'arborescence Fenwick pour plus de contexte sur la configuration de l'arborescence et la manière dont les opérations y sont effectuées.

Partie 7

• 06:00:00 Le concept de mise à jour des points et la construction de l'arbre Fenwick sont expliqués par l'ingénieur Google. Les mises à jour ponctuelles impliquent l'ajout de valeurs à l'arborescence à un index spécifique et la recherche des cellules responsables de cette plage de responsabilité. Pendant ce temps, la construction linéaire de l'arbre de Fenwick implique la mise à jour de la cellule immédiate responsable d'une valeur en propageant les valeurs dans tout l'arbre en place, ce qui donne un arbre de Fenwick entièrement fonctionnel. Le processus de propagation repose sur l'idée en cascade de mettre à jour le parent responsable d'une valeur spécifique.
  
  
• 06:05:00 Dans cette section du didacticiel, le concept d'un arbre Fenwick est expliqué en détail. Un arbre Fenwick est une structure de données utilisée pour effectuer rapidement des requêtes de plage et des mises à jour ponctuelles sur un tableau de valeurs. La structure de données utilise un type d'indexation binaire dans lequel chaque cellule est responsable de la propagation de sa valeur à son parent et ainsi de suite. L'algorithme de construction d'un arbre Fenwick est également discuté, ce qui implique de transformer un tableau de valeurs en un arbre Fenwick en clonant le tableau d'origine et en calculant la cellule parente pour chaque élément dans la nouvelle structure arborescente. Le code source d'une implémentation d'arborescence Fenwick en Java est affiché et est disponible dans un référentiel GitHub.
  
  
• 06:10:00 L'instructeur explique comment créer une classe d'arbre Fenwick et ses différents constructeurs. Il explique également les sommes de préfixes, ce qui permet de calculer la somme de préfixes de un à i tous deux inclus. La vidéo explique également comment ajouter à partir d'une mise à jour ponctuelle et une méthode supplémentaire pour définir l'index égal à k. L'instructeur insiste sur l'importance d'utiliser la manipulation binaire et la structure de données du tableau de suffixes, qui est très utile dans le traitement des chaînes.
  
  
• 06:15:00 Le concept de suffixes et de tableaux de suffixes est introduit, avec un exemple de construction d'un tableau de suffixes pour le mot "chameau". Le tableau de suffixes est un tableau d'indices triés qui permet une représentation compressée des suffixes triés sans stocker les suffixes eux-mêmes, ce qui en fait une alternative peu encombrante à un arbre de suffixes. Le tableau de préfixes communs les plus longs (LCP), qui stocke le nombre de caractères que deux suffixes triés ont en commun, est également présenté comme une information importante associée au tableau de suffixes, avec un exemple de construction du tableau LCP pour un chaîne.
  
  
• 06:20:00 La vidéo traite de l'application des tableaux de suffixes et des tableaux LCP pour trouver et compter des sous-chaînes uniques d'une manière plus efficace que l'algorithme naïf qui nécessite beaucoup d'espace. En utilisant les informations stockées à l'intérieur de la matrice LCP, il fournit non seulement une solution rapide mais aussi une solution peu encombrante. Le tableau LCP représente le nombre partagé de caractères entre deux suffixes adjacents de la chaîne d'origine. En examinant les valeurs LCP, on peut déterminer quelles sous-chaînes sont répétées et les éliminer pour compter efficacement toutes les sous-chaînes uniques.
  
  
• 06:25:00 L'orateur discute du problème de trouver la plus longue sous-chaîne commune partagée entre au moins k sur n chaînes données. Une approche pour résoudre ce problème est la programmation dynamique, mais elle peut rapidement devenir lourde. Une meilleure approche consiste à utiliser un tableau de suffixes, qui peut trouver la solution en temps linéaire. Pour ce faire, l'orateur explique que nous concaténons d'abord toutes les chaînes en une chaîne plus grande, en ajoutant des valeurs sentinelles uniques entre chaque chaîne pour éviter tout mélange de suffixes. Ensuite, nous construisons le tableau de suffixes pour cette chaîne concaténée, ce qui nous permet de trouver la plus longue sous-chaîne commune de K chaînes en recherchant K chaînes avec différentes couleurs qui partagent la plus grande valeur LCP.
  
  
• 06:30:00 Le didacticiel vidéo explique comment trouver la plus longue sous-chaîne commune de k couleurs différentes dans une chaîne à l'aide d'une technique de fenêtre glissante. L'approche consiste à ajuster la taille de la fenêtre pour contenir k suffixes de différentes couleurs et à interroger la valeur LCP minimale dans cette plage. La requête de plage minimale peut être résolue à l'aide d'une solution linéaire ou d'une structure de données de requête de plage minimale telle qu'un arbre de segments. Le tutoriel recommande également d'utiliser une table de hachage pour garder une trace des couleurs dans la fenêtre. La fenêtre coulissante s'étend vers le bas pour capturer les couleurs manquantes et se rétrécit lorsque les critères sont remplis.
  
  
• 06:35:00 Dans cette section de la vidéo, l'instructeur montre un exemple de résolution du problème de sous-chaîne commun le plus long avec un tableau de suffixes. Les valeurs LCP de fenêtre et LCS de fenêtre aident à suivre le préfixe commun le plus long et les valeurs de sous-chaîne communes les plus longues pour la fenêtre actuelle, tandis que la longueur LCS et l'ensemble LCS suivent les meilleures valeurs jusqu'à présent. L'exemple utilise quatre chaînes et un minimum de deux chaînes du groupe de quatre pour partager la plus longue sous-chaîne commune. L'instructeur montre comment agrandir et réduire la fenêtre tout en recherchant la sous-chaîne commune la plus longue, et fait allusion à un défi pour les téléspectateurs à consulter sur le site Web de distribution et fournit un lien vers une implémentation de l'algorithme sur GitHub.
  
  
• 06:40:00 La vidéo explique le processus de résolution du problème de sous-chaîne commun le plus long à l'aide de la technique de la fenêtre glissante. En élargissant et en réduisant la taille de la fenêtre et en utilisant le plus long tableau de préfixes communs pour identifier les sous-chaînes communes, l'algorithme trouve une solution avec une complexité temporelle linéaire. La vidéo présente ensuite le problème de sous-chaîne répétée la plus longue et explique comment utiliser le tableau de préfixes communs le plus long pour trouver efficacement la sous-chaîne répétée la plus longue dans une chaîne donnée, par rapport à l'approche naïve qui nécessite N temps au carré et beaucoup de mémoire.
  
  
• 06:45:00 L'ingénieur Google enseigne comment utiliser un tableau de suffixes et un tableau LCP pour trouver la plus longue sous-chaîne répétée. La valeur LCP à un index donne la longueur du plus long préfixe commun entre deux suffixes adjacents. La valeur maximale dans le tableau LCP donne la longueur de la plus longue sous-chaîne répétée. En cas d'égalité, toutes les valeurs les plus longues possibles doivent être trouvées. Ensuite, l'ingénieur explique l'importance des arbres de recherche binaires équilibrés et comment ils diffèrent des arbres de recherche binaires traditionnels en termes d'auto-ajustement pour maintenir une hauteur logarithmique par rapport au nombre de nœuds qu'ils contiennent, ce qui rend l'insertion et la suppression extrêmement rapides. Le concept clé pour y parvenir est la rotation des arbres, et ils seront discutés plus loin dans la vidéo.
  
  
• 06:50:00 Le concept d'invariant d'arbre et de rotation d'arbre dans les arbres de recherche binaires équilibrés est expliqué. Un invariant d'arbre est une règle imposée à un arbre à respecter à la fin de chaque opération, ce qui est assuré en appliquant une série de rotations d'arbre. Les rotations d'arbres sont des transformations légitimes qui se déplacent autour des nœuds d'un arbre sans casser l'invariant binaire de l'arbre de recherche si l'ordre et le placement des nœuds sont maintenus. Le processus de rotation à droite est expliqué en détail et les étapes impliquées dans la mise à jour des pointeurs lorsque les nœuds ont des références aux nœuds enfants et parents sont discutées.
  
  
• 06:55:00 Le didacticiel vidéo se concentre sur la démonstration de l'insertion de nœuds dans un arbre AVL à l'aide de la technique de rotation d'arbre tout en expliquant les propriétés qui maintiennent l'équilibre des arbres AVL. Tout d'abord, la vidéo explique ce qu'est un arbre AVL et sa signification en tant que premier type d'arbre de recherche binaire équilibré. Ensuite, la vidéo présente le facteur d'équilibre, qui est la différence entre la hauteur du sous-arbre droit et du sous-arbre gauche. La vidéo souligne que le facteur d'équilibre de chaque nœud doit être soit moins un, zéro ou plus un pour maintenir l'équilibre de l'arborescence AVL. Le didacticiel explique ensuite comment gérer les cas où ce n'est pas vrai, ce qui peut être résolu avec des rotations d'arbres.

Partie 8

• 07:00:00 L'instructeur explique les quatre cas distincts de rotations nécessaires pour équilibrer un arbre lourd à gauche dans un arbre AVL. L'instructeur fournit également un pseudocode pour insérer un nœud dans une arborescence AVL et explique les méthodes de mise à jour et d'équilibrage. La méthode de mise à jour calcule la hauteur et le facteur d'équilibre d'un nœud, tandis que la méthode d'équilibre vérifie si le facteur d'équilibre d'un nœud viole la propriété d'arbre AVL et détermine la rotation appropriée pour rééquilibrer l'arbre. Les cas gauche-droite et droite-gauche sont également expliqués car ils se réduisent aux cas gauche-gauche et droite-droite après la première rotation.
  
  
• 07:05:00 La vidéo explique comment supprimer des éléments d'un arbre avielle, ce qui est très similaire à la suppression d'éléments d'un arbre de recherche binaire ordinaire. Le processus de suppression peut être décomposé en deux étapes : trouver l'élément et le remplacer par un nœud successeur pour maintenir l'arbre de recherche binaire invariant. La recherche du nœud implique la comparaison de l'élément cible avec les nœuds de l'arbre jusqu'à ce qu'une correspondance soit trouvée ou que la recherche atteigne la fin de l'arbre. Le processus de remplacement dépend du fait que le nœud à supprimer est un nœud feuille ou n'a qu'un sous-arbre gauche ou droit, le nœud successeur étant l'enfant immédiat dans les deux derniers cas.
  
  
• 07:10:00 L'instructeur explique comment supprimer un nœud d'un arbre de recherche binaire et fournit des exemples pour les trois cas de suppression. Le premier cas est lorsque le nœud à supprimer n'a pas d'enfant, le second lorsqu'il en a un et le dernier lorsqu'il en a deux. L'instructeur explique également comment augmenter la méthode de suppression de l'arbre de recherche binaire pour les arbres AVL en ajoutant simplement deux lignes de code pour s'assurer que l'arbre reste équilibré et que le facteur d'équilibre et les valeurs de hauteur restent à jour. Enfin, l'instructeur fournit un lien vers son référentiel GitHub où les téléspectateurs peuvent trouver le code source de l'arborescence AVL et une démonstration en direct de l'arborescence AVL en action.
  
  
• 07:15:00 L'instructeur fournit une explication du code source pour une implémentation d'arborescence AVL récursive en Java. L'arborescence AVL accepte un argument de type générique et stocke la valeur à l'intérieur du nœud, qui doit être comparable. La sous-classe de nœud stocke les pointeurs enfants gauche et droit, ainsi que le facteur de hauteur et d'équilibre du nœud. L'arborescence peut être affichée sur le terminal à l'aide de l'interface de l'imprimante arborescente, et des méthodes publiques telles que size, is empty et set contains sont fournies dans le code. La méthode d'insertion est également expliquée à l'aide de cas de base et de valeurs comparatives pour déterminer si une insertion a réussi ou non.
  
  
• 07:20:00 La méthode d'insertion privée dans l'arbre AVL est expliquée, qui insère de nouveaux nœuds à gauche ou à droite du sous-arbre, tout en mettant à jour le facteur d'équilibre et la hauteur des nœuds en conséquence. La méthode de mise à jour met à jour la hauteur et le facteur d'équilibre d'un nœud, et la méthode d'équilibre appelle les méthodes de rotation nécessaires pour maintenir l'équilibre de l'arbre. Les cas gauche-gauche, gauche-droite, droite-droite et droite-gauche sont expliqués, et l'ordre des méthodes de mise à jour après la rotation est souligné comme crucial pour que l'arbre AVL maintienne son équilibre.
  
  
• 07:25:00 L'instructeur discute de la méthode de suppression de la structure de données de l'arbre de recherche binaire. Il explique que pour supprimer un élément, la méthode vérifie d'abord si l'élément existe dans l'arborescence et appelle ensuite la méthode privée de suppression. L'instructeur décrit les quatre cas qui peuvent survenir lors de la suppression et propose une heuristique pour déterminer de quel sous-arbre supprimer lors de la tentative de suppression d'un nœud avec les deux sous-arbres. Enfin, il rappelle aux spectateurs d'appeler la méthode de mise à jour et de rééquilibrage lors du rappel de la méthode de suppression pour s'assurer que l'arborescence reste équilibrée malgré les suppressions de nœuds.
  
  
• 07:30:00 L'ingénieur Google présente la file d'attente prioritaire indexée, une structure de données qui prend en charge les mises à jour et suppressions rapides des paires clé-valeur. Il résout le problème de pouvoir rechercher rapidement et modifier dynamiquement les valeurs dans une file d'attente prioritaire, ce qui peut être utile dans diverses situations telles qu'une salle d'attente d'hôpital où les patients doivent d'abord être servis par la priorité la plus élevée. L'ingénieur fournit un exemple de patients avec des priorités différentes et comment la file d'attente prioritaire indexée peut aider à mettre à jour les priorités à la volée.
  
  
• 07:35:00 La vidéo traite des files d'attente de priorité d'index qui permettent une mise à jour dynamique efficace des priorités pour certains éléments. La première étape de l'utilisation d'une file d'attente de priorité d'index consiste à attribuer des valeurs d'index à toutes les clés, en créant un mappage bidirectionnel. Ce mappage doit être bidirectionnel et peut être facilité par une table de hachage bidirectionnelle. La raison de l'utilisation des valeurs d'index sur les clés est de permettre l'indexation dans des tableaux, ce qui est souvent la façon dont les files d'attente prioritaires sont implémentées.
  
  
• 07:40:00 L'orateur présente le concept d'une file d'attente prioritaire d'index et explique les opérations qu'elle doit prendre en charge, notamment la suppression de clés, l'obtention de la valeur associée à une clé, la vérification de l'existence d'une clé dans la file d'attente prioritaire, l'obtention de l'index de clé avec la plus petite valeur, obtenir la plus petite valeur de l'index, pouvoir insérer et mettre à jour des paires clé-valeur, et les opérations de mise à jour spécialisées augmentent et diminuent la clé. La complexité temporelle de toutes ces opérations est soit constante soit logarithmique. L'orateur fournit également un rappel sur la structure de données de la file d'attente prioritaire traditionnelle, y compris le fonctionnement du tas binaire, comment insérer une nouvelle valeur dans la file d'attente prioritaire et comment en supprimer des éléments.
  
  
• 07:45:00 Comment implémenter une file d'attente prioritaire indexée avec un tas binaire ? La première étape consiste à attribuer à chaque élément une valeur d'index unique et une valeur initiale pour la file d'attente de priorité d'index. Ensuite, nous utilisons une file d'attente de priorité indexée min pour trier d'abord par la valeur la plus basse, et nous maintenons une carte de position pour nous indiquer l'index d'un nœud dans le tas pour tout index de clé donné. De plus, nous maintenons une table de recherche inverse pour trouver la clé d'un nœud donné. Ces informations nous permettent d'accéder et de manipuler efficacement la file d'attente prioritaire pour diverses applications, telles que la hiérarchisation des patients dans un hôpital ou des clients dans un restaurant.
  
  
• 07:50:00 La vidéo explique comment effectuer des opérations utiles, telles que l'insertion, la mise à jour et la suppression de paires clé-valeur dans une file d'attente de priorité d'index. Le processus d'insertion est similaire à une file d'attente prioritaire normale, mais avec l'étape supplémentaire de mise à jour de la position et des cartes inverses. La vidéo fournit un pseudocode pour le processus d'insertion, montrant comment le nœud est déplacé vers le haut dans le tas jusqu'à ce que l'invariant du tas soit satisfait. Le processus d'échange implique la mise à jour de la position et des cartes inverses, mais pas du tableau de valeurs, qui reste indexé par l'index de clé plutôt que par l'index de nœud. La vidéo aborde également brièvement l'interrogation et la suppression des paires clé-valeur, qui impliquent des étapes similaires à l'insertion mais en sens inverse.
  
  
• 07:55:00 La vidéo explique comment la suppression d'éléments d'une file d'attente prioritaire indexée est améliorée de la complexité temporelle linéaire à la complexité temporelle logarithmique, en utilisant des recherches de position de nœud qui sont désormais en temps constant. La vidéo donne un exemple étape par étape de la façon de supprimer des nœuds, y compris l'échange de nœuds, le stockage de paires clé-valeur avant la suppression, le nettoyage des nœuds supprimés et la restauration de l'invariant de tas en déplaçant le nœud échangé vers le haut ou vers le bas. De plus, un pseudocode pour supprimer les paires clé-valeur est fourni, présentant une courte implémentation de cinq lignes et un processus de nettoyage de trois lignes. Enfin, la vidéo décrit la méthode de synchronisation et son fonctionnement, ainsi que les mises à jour des paires clé-valeur, qui sont similaires à la suppression mais prennent également un temps logarithmique.

[MetaQuotes]

Cours complet de programmation C gratuit

Cours complet de programmation C gratuit

00:00:00 - 01:00:00 La vidéo "C Programming Full Course for free" enseigne aux téléspectateurs comment installer le compilateur gcc, configurer un IDE et écrire du code C. La vidéo couvre les bases de la programmation C, y compris comment utiliser les instructions printf, les commentaires, les séquences d'échappement et les spécificateurs de format pour afficher différents types de données. L'instructeur explique comment créer et initialiser des variables et comment utiliser les opérateurs arithmétiques et d'incrémentation/décrémentation. De plus, la vidéo couvre l'acceptation des entrées de l'utilisateur à l'aide de scanf et le formatage de la sortie à l'aide de printf. L'instructeur aborde également les fonctions mathématiques utiles en C et comment les utiliser pour calculer la circonférence et l'aire d'un cercle en fonction de l'entrée de l'utilisateur pour le rayon. La vidéo souligne que bien que C soit une langue difficile, n'importe qui peut l'apprendre avec persévérance et effort.

01:00:00 - 02:00:00 La vidéo YouTube "C Programming Full Course for free" enseigne les concepts de programmation en langage C. Dans cette section vidéo, l'instructeur aborde des sujets tels que les instructions if/else, les instructions switch, les opérateurs logiques, les fonctions et les boucles. L'instructeur explique les instructions conditionnelles, permettant au programme de faire des choix en fonction des conditions, et comment l'instruction switch est une version plus efficace de l'instruction else if. De plus, l'instructeur va en profondeur pour montrer comment convertir des unités de température, créer un programme de calcul simple, utiliser des opérateurs logiques pour améliorer l'efficacité du programme et comment utiliser des fonctions pour minimiser la redondance du code. Enfin, l'instructeur explique l'opérateur ternaire et comment les fonctions de chaîne peuvent aider à la création de programmes.

02:00:00 - 03:00:00 Ce cours complet de programmation C couvre un large éventail de sujets, en commençant par expliquer la différence entre une boucle while et do-while, et comment utiliser des boucles imbriquées pour créer des formes. La vidéo couvre ensuite les bases des tableaux et comment parcourir et afficher des éléments dans un tableau unidimensionnel, avant de passer aux tableaux bidimensionnels et comment créer une grille 2D ou un tableau de données. L'instructeur introduit ensuite le concept d'échange de variables, d'algorithmes de tri tels que le tri à bulles, et enseigne les structures et les typedef en C, ainsi que la génération de nombres aléatoires et la création d'un jeu de devinettes. Dans l'ensemble, ce cours fournit une compréhension complète et approfondie des concepts de programmation C.

03:00:00 - 04:00:00 Cette vidéo YouTube intitulée "C Programming Full Course for free" couvre une gamme complète de sujets de programmation C, y compris la création de jeux tels que les jeux de devinettes et de quiz, et couvre des concepts tels que la mémoire, les pointeurs, les opérateurs au niveau du bit et les E/S de fichiers. De plus, la vidéo explique comment créer un jeu Tic Tac Toe qui utilise des boucles for imbriquées et des instructions if pour rechercher un gagnant et générer des mouvements aléatoires pour le joueur informatique. L'instructeur fournit des explications et des démonstrations claires tout au long de la vidéo, ce qui en fait une ressource précieuse pour toute personne intéressée par l'apprentissage de la programmation en C.

04:00:00 - 04:00:00 L'instructeur continue à construire le jeu Tic-Tac-Toe en C, en ajoutant une vérification pour s'assurer que l'emplacement choisi est vide avant de placer un coup et en créant une fonction pour imprimer le gagnant. Ils ajoutent ensuite une option "rejouer" à l'aide d'une boucle do while et réinitialisent les variables au début de chaque boucle. Le code sera partagé dans la section des commentaires pour que les utilisateurs puissent l'utiliser.

Partie 1

• 00:00:00 L'auteur explique l'importance d'apprendre le C, qui est un langage de niveau intermédiaire qui agit comme un pont entre les logiciels de haut niveau et le matériel de bas niveau. C est né dans les années 1970 et est largement utilisé à diverses fins, notamment pour écrire des compilateurs, des systèmes d'exploitation et des bases de données. Le YouTuber fournit également des instructions sur la façon de configurer un IDE et d'installer les extensions et le compilateur nécessaires pour commencer à écrire du code C. Cependant, le YouTuber prévient que le C est un langage difficile pour les débutants, mais avec de la persévérance et des efforts, tout le monde peut l'apprendre.
  
  
• 00:05:00 La vidéo explique comment installer gcc sur un système Mac ou Linux et comment ajouter le chemin vers le compilateur gcc sous les variables d'environnement. Une fois gcc installé, la vidéo explique comment configurer la tâche de génération par défaut afin que VS Code sache comment compiler le programme. La vidéo recommande d'augmenter la taille de la police et d'activer la sauvegarde automatique pour éviter les maux de tête plus tard. La vidéo passe également en revue les bases de la programmation C et inclut des fonctions importantes telles que hashtag include, std pour l'entrée/sortie io standard et print f parenthèses. Enfin, la vidéo souligne la nécessité d'ajouter l'instruction return 0 à la fin de la fonction principale pour vérifier les erreurs.
  
  
• 00: 10: 00 Dans cette section du didacticiel de programmation C, l'instructeur montre comment utiliser les instructions printf pour imprimer du texte et comment ajouter un caractère de nouvelle ligne à l'aide d'une séquence d'échappement. Il montre également comment compiler et exécuter un fichier C à l'aide de l'invite de commande et explique le but des commentaires dans la programmation C. La vidéo couvre les bases de la programmation en C et fournit des conseils utiles aux débutants.
  
  
• 00:15:00 Dans cette section du didacticiel vidéo sur la programmation en C, l'instructeur explique comment utiliser les commentaires et les séquences d'échappement dans votre code. Les commentaires sont utilisés pour des explications, des descriptions ou des notes pour toute personne lisant le code. Les commentaires sur une seule ligne sont faits à l'aide de deux barres obliques, tandis que les commentaires sur plusieurs lignes sont faits à l'aide d'une barre oblique suivie d'un astérisque et se terminant par un astérisque suivi d'une barre oblique. Les séquences d'échappement, quant à elles, sont des combinaisons de caractères qui spécifient des actions dans une ligne de texte ou une chaîne. Les séquences d'échappement les plus couramment utilisées servent à créer de nouvelles lignes et tabulations dans des chaînes de texte. L'instructeur montre également comment afficher les guillemets, les guillemets simples et les barres obliques inverses à l'aide de séquences d'échappement.
  
  
• 00:20:00 la vidéo explique comment créer des variables en programmation C. Tout d'abord, vous devez déclarer une variable et attribuer un nom et un type de données à cette variable. Ensuite, vous devez initialiser cette variable en la définissant égale à une certaine valeur. La vidéo donne des exemples de différents types de données, notamment des nombres entiers, des virgules flottantes, des caractères et des tableaux. La vidéo explique également comment afficher la valeur stockée dans une variable à l'aide d'une instruction printf et d'un spécificateur de format.
  
  
• 00:25:00 Dans cette section de la vidéo, l'instructeur explique comment utiliser les spécificateurs de format pour afficher différents types de données en programmation C. Par exemple, pour afficher un tableau de caractères, utilisez le signe pourcentage suivi de 's' pour chaîne. Pour afficher une variable de type caractère, utilisez pourcentage c et pour afficher un nombre à virgule flottante, utilisez pourcentage f. L'instructeur aborde également les types de données tels que les caractères, les flottants, les entiers et les doubles, les doubles ayant une précision de 64 bits et conservant des chiffres plus significatifs que les flottants. Les booléens sont également introduits, stockant vrai ou faux et utilisant un octet de mémoire. Les différents spécificateurs de format et les moyens de les personnaliser seront abordés dans la vidéo suivante.
  
  
• 00:30:00 Nous apprenons que les booléens peuvent être affichés en utilisant le pourcentage d, un faisant référence à vrai et zéro à faux. Les caractères peuvent stocker des nombres entiers compris entre moins 128 et plus 127, leurs représentations étant affichées à l'aide de spécificateurs de format pourcentage d ou pourcentage c. Les variables non signées doublent notre gamme de nombres positifs pour les caractères et les shorts, donc char peut stocker des nombres entre 0 et 255, tandis que shorts peut stocker des chiffres de moins 32 768 à plus 32 767 s'ils sont signés, et de 0 à 65 535 s'ils ne sont pas signés. Nous apprenons que vous pouvez utiliser short au lieu de short int comme raccourci. Les entiers peuvent stocker des nombres entiers qui peuvent être des valeurs positives ou négatives.
  
  
• 00:35:00 Il est important de noter qu'il existe différents spécificateurs de format pour différents types de données et que l'utilisation du mauvais peut entraîner des erreurs ou une sortie inattendue. Bien qu'il existe de nombreux types de données disponibles en programmation C, nous nous concentrerons principalement sur les caractères, les tableaux de caractères, les doubles, les booléens et les entiers dans ce cours.
  
  
• 00:40:00 L'instructeur explique les spécificateurs de format, qui définissent et formatent les types de données à afficher d'une manière spécifiée. Pour définir une largeur de champ minimale pour l'affichage de la sortie, un nombre est ajouté après le signe de pourcentage pour allouer des espaces spécifiques. L'utilisation d'un signe négatif après le signe de pourcentage à gauche aligne les données. La vidéo couvre également les constantes, qui sont des valeurs fixes qui ne peuvent pas être modifiées par le programme lors de son exécution. Pour convertir une variable en constante, le type de données est précédé du mot-clé 'const' et la convention majuscule est suivie pour nommer la constante. Les opérateurs arithmétiques tels que l'addition, la soustraction, la multiplication et la division sont également couverts, où la division avec des nombres entiers peut tronquer les parties décimales, nécessitant l'utilisation de float ou double pour stocker le résultat, et l'opérateur de module est utilisé pour obtenir le reste de toute division.
  
  
• 00: 45: 00 L'instructeur explique les opérateurs arithmétiques en programmation C, y compris le module, qui peut être utilisé pour déterminer rapidement si un nombre est pair ou impair en trouvant le reste lorsqu'il est divisé par 2. La vidéo couvre également les opérateurs d'incrémentation et de décrémentation, qui peut être utilisé pour augmenter ou diminuer une variable de 1, et les opérateurs d'affectation augmentés, qui permettent aux utilisateurs d'effectuer une opération arithmétique sur une variable et d'attribuer le résultat à la même variable à l'aide d'un raccourci. Enfin, l'instructeur donne un aperçu de l'acceptation des entrées de l'utilisateur avec la fonction scanf et des invites en programmation C.
  
  
• 00: 50: 00 L'instructeur explique comment accepter les entrées de l'utilisateur dans la programmation C à l'aide de la fonction scanf avec le spécificateur de format approprié pour le type de variable utilisé. La section couvre l'acceptation d'entiers et de chaînes, avec la mise en garde que l'acceptation de chaînes avec des espaces nécessite la fonction fgets au lieu de scanf à cause des espaces blancs. L'instructeur explique également comment formater la chaîne après avoir utilisé fgets pour se débarrasser des caractères de nouvelle ligne. La section se termine par un aperçu du formatage de l'instruction printf pour améliorer la lisibilité.
  
  
• 00: 55: 00 Dans cette section de la vidéo, l'instructeur discute des fonctions mathématiques utiles en C lors de l'inclusion du fichier d'en-tête mathématique. Les fonctions de racine carrée, de puissance, d'arrondi (en utilisant le plafond et le plancher), de valeur absolue, de logarithmes et de trigonométrie sont expliquées avec des exemples d'utilisation dans le code. Plus tard, l'instructeur montre comment écrire un programme qui calcule la circonférence d'un cercle en fonction de l'entrée de l'utilisateur pour le rayon, et va plus loin pour calculer et afficher la surface du cercle en utilisant pi fois la formule du rayon au carré.

Partie 2

• 01:00:00 Dans cette section de la vidéo, l'instructeur montre comment calculer la circonférence et l'aire d'un cercle à l'aide du langage de programmation C, et comment trouver l'hypoténuse d'un triangle rectangle, ce qui nécessite l'utilisation de la fonction racine carrée à partir du fichier d'en-tête math.h. L'instructeur présente également les instructions if et comment elles sont utilisées pour ajouter des choix à un programme en vérifiant les conditions et en exécutant le code en conséquence. Il montre comment utiliser la condition supérieur ou égal à et l'opérateur de comparaison à double signe égal, ainsi que comment utiliser les instructions else pour fournir une sortie différente lorsqu'une condition est fausse.
  
  
• 01:05:00 la vidéo traite des instructions if et else if en programmation C. Ces instructions permettent au programme de vérifier si une condition est vraie et d'exécuter un sous-ensemble spécifique de code si c'est le cas, et si ce n'est pas le cas, le programme passera au bloc suivant pour vérifier une autre condition. Si toutes les conditions sont fausses, le programme exécutera le code qui se trouve dans le bloc else. De plus, la vidéo présente l'utilisation d'une instruction switch comme une alternative plus efficace à l'utilisation de plusieurs instructions else if. L'instruction switch permet de tester l'égalité d'une valeur par rapport à de nombreux cas à l'aide du mot-clé case. Enfin, la vidéo souligne l'importance d'ajouter une instruction break après chaque cas dans une instruction switch pour sortir du commutateur une fois qu'un cas correspondant a été trouvé.
  
  
• 01:10:00 Dans cette section de la vidéo, l'instructeur enseigne comment créer un programme qui convertit la température de Celsius en Fahrenheit ou vice versa. Le programme accepte les entrées de l'utilisateur pour l'unité de mesure (Celsius ou Fahrenheit) et la température actuelle, puis utilise les instructions if/else et les formules appropriées pour effectuer la conversion. L'instructeur montre également comment utiliser la fonction to_upper pour gérer la sensibilité à la casse et comment utiliser scanf pour accepter les nombres à virgule flottante. Le programme invite l'utilisateur à entrer et affiche la température convertie.
  
  
• 01:15:00 Dans cette section du cours, l'instructeur montre comment créer un programme en C qui convertit les unités de température (Celsius en Fahrenheit et vice versa) en fonction des entrées de l'utilisateur. Le programme invite l'utilisateur à entrer la température et l'unité de mesure, accepte l'entrée à l'aide de scanf, puis utilise une série d'instructions conditionnelles pour convertir les unités de température selon les besoins. L'instructeur explique l'utilisation des spécificateurs de format, la formule de conversion Celsius en Fahrenheit et l'instruction switch pour gérer différents types d'opérations dans le flux du programme. Le programme final est affiché dans la section des commentaires pour téléchargement et révision.
  
  
• 01:20:00 Dans cette section de la vidéo, l'instructeur montre comment créer un programme de calcul simple en C qui peut effectuer des additions, des soustractions, des multiplications et des divisions. Le programme utilise une instruction switch pour déterminer quelle opération effectuer en fonction de l'entrée de l'utilisateur. De plus, l'utilisation d'opérateurs logiques est expliquée, en particulier l'opérateur "et", qui vérifie si un ensemble de conditions est vrai. L'instructeur fournit des exemples d'utilisation d'opérateurs logiques pour vérifier si une température tombe dans une certaine plage et comment inclure des variables booléennes dans les vérifications de condition.
  
  
• 01:25:00 L'opérateur logique ou et l'opérateur non logique sont discutés. L'opérateur logique ou vérifie si au moins une condition est vraie, tandis que l'opérateur logique non inverse l'état d'une condition. L'opérateur ou peut être utilisé pour vérifier plusieurs conditions en ajoutant plus de barres verticales. D'autre part, l'opérateur not peut offrir plus d'options pour la manière dont un programme est écrit. Ces opérateurs logiques peuvent aider à créer des conditions plus complexes et à améliorer l'efficacité d'un programme.
  
  
• 01:30:00 L'instructeur enseigne comment utiliser les fonctions en programmation C pour éviter de répéter le même code. En créant une nouvelle fonction, le code peut être écrit une fois puis réutilisé plusieurs fois simplement en appelant la fonction. L'instructeur passe ensuite à la discussion des arguments et des paramètres, avec un exemple de transmission de tableaux de caractères et d'entiers comme arguments à une fonction. Les paramètres doivent être déclarés dans la déclaration de la fonction pour que la fonction soit consciente des variables qui lui sont transmises. Sans un jeu de paramètres correspondant, la fonction ne peut pas être appelée.
  
  
• 01:35:00 Dans cette section de la transcription, l'orateur explique le concept de l'instruction return et comment elle peut renvoyer une valeur à la fonction appelante. Ils montrent un exemple de fonction appelée "carré" qui acceptera un argument, mettra cet argument au carré, puis renverra le résultat à la fonction appelante. Ils discutent également de la syntaxe de l'opérateur trinaire, un raccourci pour utiliser une instruction if-else lors de l'attribution ou du retour d'une valeur, et montrent un exemple de la façon dont il peut être utilisé pour trouver le maximum de deux entiers. L'orateur souligne également l'importance de faire correspondre le type de données lors de l'utilisation du mot-clé return dans la déclaration de la fonction.
  
  
• 01:40:00 Nous découvrons l'opérateur ternaire, qui sert de raccourci pour utiliser une instruction if-else lors de l'attribution ou du retour d'une valeur. L'opérateur se compose d'une condition, suivie d'un point d'interrogation, d'une valeur à renvoyer si la condition est vraie, de deux-points et de la valeur à renvoyer si la condition est fausse. Nous discutons également des prototypes de fonction, qui garantissent que les appels à une fonction sont effectués avec le nombre et le type corrects d'arguments. En ajoutant un prototype de fonction avant la fonction principale, nous pouvons éviter un comportement inattendu et recevoir des erreurs si des arguments incorrects sont utilisés.
  
  
• 01:45:00 Dans cette section de la vidéo, l'instructeur explique les prototypes de fonction en C et leurs avantages, ainsi que quelques fonctions de chaîne utiles déjà écrites en C, telles que la longueur de chaîne, la comparaison de chaîne, la chaîne inférieure, la chaîne supérieur et chat à cordes. L'instructeur donne des exemples du fonctionnement de chacune de ces fonctions et démontre leurs résultats. La fonction de comparaison de chaînes renvoie zéro si les deux chaînes comparées sont identiques, et d'autres nombres si ce n'est pas le cas. L'instructeur termine la section en incluant un extrait de code qui utilise ces fonctions de chaîne.
  
  
• 01:50:00 L'instructeur couvre les boucles, qui répètent une section de code un nombre limité de fois. Il fournit un exemple de comptage de 1 à 10 à l'aide d'une boucle for et explique les trois instructions requises pour une boucle for : déclarer un index, définir une condition de durée de répétition du code et un moyen d'incrémenter ou de décrémenter l'index. Il montre également différentes manières d'incrémenter et de décrémenter l'index. L'instructeur passe ensuite à l'explication des boucles while, qui répètent une section de code éventuellement un nombre illimité de fois tant qu'une certaine condition reste vraie, et donne un exemple de demande aux utilisateurs de leur nom jusqu'à ce que l'utilisateur entre une réponse valide.
  
  
• 01:55:00 Dans cette section de la vidéo, l'instructeur montre comment utiliser fgets au lieu de scanf pour la saisie utilisateur en programmation C. Ils utilisent ensuite une boucle while pour inviter l'utilisateur à saisir son nom et lui crier dessus s'il n'a pas saisi son nom correctement. L'instructeur passe ensuite à la discussion de la boucle do-while et fournit une démonstration d'un programme qui demande à l'utilisateur d'entrer autant de nombres qu'il le souhaite, à condition qu'ils soient supérieurs à zéro, et calcule la somme de ces nombres.

Partie 3

• 02:00:00 Dans cette section du cours complet de programmation en C, l'instructeur explique la différence entre une boucle while et une boucle do-while en C. Tandis qu'une boucle while vérifie d'abord la condition, puis exécute le code si la condition est true, une boucle do-while exécute le code une fois, puis vérifie la condition pour voir si elle est vraie avant de continuer. L'instructeur le démontre avec un exemple de code et explique comment modifier une boucle while en une boucle do-while. La section couvre également les boucles imbriquées, c'est-à-dire une boucle à l'intérieur d'une autre boucle, et montre un exemple d'utilisation de boucles imbriquées pour imprimer un rectangle de symboles en fonction des valeurs saisies par l'utilisateur pour les lignes, les colonnes et les symboles.
  
  
• 02:05:00 Dans cette section de la vidéo, l'instructeur montre comment créer des formes rectangulaires à l'aide de boucles imbriquées en C. Il permet à l'utilisateur d'entrer un symbole et le nombre de lignes et de colonnes pour le rectangle, mais il montre également comment pour effacer le tampon d'entrée afin de permettre une entrée utilisateur appropriée. L'instructeur explique également la différence entre les instructions continue et break dans le contexte des boucles C, où continue sautera le reste d'une section de code et forcera l'itération suivante d'une boucle, tandis que break sortira entièrement d'une boucle. Enfin, l'instructeur définit le concept de tableaux comme une structure de données pouvant stocker plusieurs valeurs du même type de données et montre comment transformer une variable en tableau.
  
  
• 02:10:00 La vidéo couvre le concept de tableaux en langage de programmation C. Les tableaux sont un moyen de stocker plusieurs valeurs du même type de données dans une structure de données de taille fixe. La vidéo montre comment initialiser un tableau et accéder à des éléments spécifiques à l'aide de numéros d'index. Il existe différentes manières d'initialiser un tableau, telles que l'affectation immédiate de valeurs ou l'affectation de valeurs ultérieurement dans le programme. La vidéo explique également comment parcourir et imprimer tous les éléments d'un tableau à l'aide d'une boucle for.
  
  
• 02:15:00 La vidéo explique comment parcourir et afficher les éléments d'un tableau en programmation C. L'instructeur montre comment utiliser une boucle for et une instruction printf, l'index de la boucle for étant utilisé pour accéder aux éléments du tableau. Ils montrent également comment calculer le nombre de fois que la boucle doit itérer en utilisant la taille de l'opérateur, qui se mettra automatiquement à jour si des éléments sont ajoutés ou supprimés du tableau. L'instructeur passe ensuite à la création d'un tableau à deux dimensions, qui est un tableau où chaque élément est lui-même un tableau. Ils montrent comment initialiser et organiser un tableau à deux dimensions, en utilisant l'exemple d'une simple grille ou d'un tableau de données.
  
  
• 02:20:00 L'instructeur explique comment déclarer et attribuer des valeurs à un tableau à deux dimensions en programmation C. Ils expliquent également comment afficher les éléments d'un tableau à deux dimensions à l'aide de boucles imbriquées et du spécificateur de format "d". L'instructeur montre ensuite comment calculer le nombre de lignes et de colonnes d'un tableau à deux dimensions en utilisant la taille de l'opérateur et la taille de l'une des lignes, et en utilisant la taille de l'un des éléments trouvés dans la première ligne. La section se termine par un exemple de test du code avec une nouvelle ligne ajoutée au tableau 2D.
  
  
• 02:25:00 Dans cette section de la vidéo, l'instructeur explique comment créer un tableau à deux dimensions en C, qui est un tableau de tableaux où chaque élément est un tableau entier. Deux indices sont utilisés pour accéder à l'un des éléments - un pour la ligne et un pour la colonne. L'instructeur montre également comment créer un tableau de chaînes, qui est un tableau 2D de caractères individuels, sauf que chaque élément est une chaîne. Pour afficher un tableau de chaînes, une boucle for peut être utilisée. Enfin, l'instructeur explique comment les variables peuvent être échangées en C en introduisant une troisième variable comme stockage temporaire de la valeur. L'échange de variables est important dans les algorithmes de tri, qui seront traités dans la rubrique suivante.
  
  
• 02:30:00 L'instructeur enseigne comment échanger les valeurs de deux variables en C, à la fois pour les tableaux d'entiers et de caractères. À l'aide de variables temporaires et de la fonction de copie de chaîne, l'instructeur montre comment échanger des valeurs et éviter un comportement inattendu avec des tableaux de caractères si la longueur du deuxième argument est inférieure à la première. L'instructeur suggère également d'imaginer des variables comme des verres contenant du liquide pour mieux comprendre les valeurs d'échange et fournit un exemple de code dans la section des commentaires. Ensuite, l'instructeur explique comment écrire un programme pour trier les éléments d'un tableau, d'abord avec un tableau d'entiers, puis avec un tableau de caractères. L'instructeur déclare une fonction distincte pour le tri et utilise des boucles for imbriquées pour parcourir le tableau et comparer les valeurs pour le tri.
  
  
• 02:35:00 L'orateur explique comment trier les éléments d'un tableau en C à l'aide de l'algorithme de tri à bulles. Ils expliquent l'utilisation des variables temporaires et des instructions if, et comment la taille du nombre trié affecte sa position finale dans le tableau. L'orateur montre également comment trier un tableau de caractères en modifiant le type de données et la fonction d'impression. Ils introduisent ensuite le concept de structs comme moyen d'organiser les membres associés dans un bloc de mémoire, avec la possibilité d'imiter des objets du monde réel. Une structure est définie à l'aide du mot-clé struct suivi d'un nom de balise et d'un ensemble d'accolades pour représenter ses membres.
  
  
• 02:40:00 Dans cette section de la vidéo, l'instructeur enseigne les structs et le typedef en langage de programmation C. Les structures permettent à un programmeur de regrouper des valeurs associées sous un nom dans un bloc de mémoire, et celles-ci peuvent être utilisées pour attribuer des valeurs à des membres avec différents types de données. Le mot-clé typedef donne un surnom à un type de données existant, ce qui facilite l'utilisation du type de données dans le code. L'instructeur montre également un exemple de création d'une structure avec trois membres et de leur attribution de valeurs. La vidéo fournit un exemple de code pour les utilisateurs qui souhaitent l'utiliser.
  
  
• 02:45:00 La structure est créée en dehors de la fonction principale et reçoit un nom de balise, "student", et contient un tableau de caractères pour le nom et une variable flottante pour le GPA. Un tableau de quatre étudiants est initialisé puis placé dans un tableau appelé "étudiants". À l'aide d'une boucle for, le programme parcourt le tableau et imprime le nom et le GPA de chaque élève à l'aide de l'opérateur d'accès au membre point. Enfin, la vidéo explique que si nous utilisons le mot clé "typedef" avec une structure, nous n'avons plus besoin d'utiliser le mot clé struct pour créer la structure et pouvons à la place utiliser le surnom que nous lui avons attribué.
  
  
• 02:50:00 L'instructeur enseigne la création de tableaux de structures en C, où chaque élément du tableau est une structure contenant des données pour chaque étudiant, telles que le nom et le GPA. L'instructeur passe également en revue l'utilisation des énumérations, qui sont des types d'identificateurs entiers nommés définis par l'utilisateur qui peuvent rendre un programme plus lisible en remplaçant les valeurs entières par des noms associés, ce qui rend le code plus facile à comprendre pour le programmeur et toute personne examinant le code. La structure des énumérations est décrite et l'instructeur montre comment utiliser les énumérations dans les instructions if-else pour imprimer différentes sorties en fonction de la valeur d'une variable enum.
  
  
• 02:55:00 Dans cette section de la vidéo, l'instructeur montre comment générer des nombres aléatoires en programmation C. L'heure actuelle est utilisée pour générer une graine pour la fonction rand, qui génère un nombre aléatoire entre 0 et 32767. Pour obtenir un nombre aléatoire dans une plage donnée, l'opérateur de module peut être utilisé. L'instructeur donne un exemple de génération d'un nombre aléatoire entre 1 et 6 (pour lancer un dé) et pour lancer trois dés. Un jeu de devinettes est également introduit en utilisant la connaissance de la génération de nombres aléatoires. Des constantes pour la plage minimale et maximale sont définies et l'utilisateur est invité à deviner le nombre. Le programme utilise la fonction rand pour générer un nombre aléatoire entre la plage donnée, et l'utilisateur reçoit des commentaires pour ajuster sa supposition jusqu'à ce que le nombre correct soit entré.

Partie 4

• 03:00:00 L'instructeur enseigne comment créer un jeu de devinettes en C, où le programme génère un nombre aléatoire entre deux valeurs spécifiées, invite l'utilisateur à deviner le nombre et fournit des commentaires si la supposition est trop élevée, trop faible , ou correcte. Le programme utilise une boucle do-while pour s'assurer qu'au moins une supposition est faite et compte le nombre de suppositions faites par l'utilisateur. L'instructeur ajoute également des décorations de texte pour rendre la sortie plus attrayante visuellement. Cet exemple illustre l'utilisation des conditions, des boucles, des entrées utilisateur et de la génération de nombres aléatoires en C.
  
  
• 03:05:00 L'instructeur montre comment créer un jeu de quiz en C. Le jeu utilise un tableau de caractères à deux dimensions pour stocker les questions et un tableau de caractères à deux dimensions séparé pour stocker les options. Les bonnes réponses sont stockées dans un tableau de caractères à une dimension. Le jeu calcule le nombre de questions qu'il a et utilise une boucle for pour les parcourir une par une, en les affichant avec leurs options possibles. Pour ce faire, l'instructeur utilise une boucle for imbriquée qui commence à chaque quatrième chaîne dans le tableau d'options. Cette boucle for se répète quatre fois, affichant les quatre options possibles pour chaque question.
  
  
• 03:10:00 L'instructeur explique comment créer un jeu-questionnaire simple en C qui invite l'utilisateur à poser des questions et vérifie ses réponses. Le code utilise une boucle for imbriquée pour afficher les questions et les options, accepte les entrées de l'utilisateur à l'aide de scanf et convertit les caractères minuscules en majuscules à l'aide de la fonction "toupper". Le programme vérifie ensuite si l'hypothèse de l'utilisateur correspond à la bonne réponse et incrémente le score en conséquence. Une fois que toutes les questions ont été répondues, le programme affiche le score final. L'instructeur explique également brièvement les opérateurs au niveau du bit et montre comment utiliser cinq opérateurs au niveau du bit différents en C.
  
  
• 03:15:00 Nous apprenons les opérations au niveau du bit en programmation C. Nous commençons par l'opérateur AND, qui, lorsqu'il est appliqué à deux nombres binaires, attribue un un à notre résultat uniquement si les deux bits correspondants sont un. Nous passons ensuite à l'opérateur OU, qui attribue un un à notre résultat si l'un des bits correspondants est un. L'opérateur OU-exclusif affecte un un au résultat si un seul bit correspondant est un. Nous apprenons également les opérateurs de décalage gauche et droite qui décalent les bits d'un nombre binaire vers la gauche ou la droite. Le décalage des bits vers la gauche double effectivement le nombre, tandis que le décalage vers la droite a l'effet inverse.
  
  
• 03:20:00 La vidéo explique la mémoire dans la programmation C, qui est un tableau d'octets dans la RAM, chaque unité étant un bloc de mémoire pouvant contenir une valeur. Une adresse mémoire indique où se trouve un bloc de mémoire dans la RAM, et c'est comme une adresse de rue. Lors de la déclaration d'une variable, il met de côté certains blocs de mémoire pour contenir une valeur associée à une adresse mémoire. Chaque variable utilise un bloc mémoire d'un octet, et la vidéo affiche les adresses mémoire et les tailles de différents caractères à titre d'exemples. La vidéo explique également brièvement les valeurs hexadécimales, qui utilisent des nombres de 0 à 9 et des lettres de a à f pour créer 16 valeurs possibles pour chaque chiffre. Enfin, la vidéo couvre les types de données courts, qui utilisent deux octets de mémoire.
  
  
• 03:25:00 L'instructeur explique les bases de la mémoire en programmation C, notamment comment les variables utilisent des blocs de mémoire et comment les tableaux utilisent plusieurs blocs de mémoire en fonction de leur taille et de leur type de données. Il introduit également le concept de pointeurs, qui contiennent une adresse mémoire comme valeur d'une autre variable, et explique comment ils peuvent être utilisés pour effectuer certaines tâches plus facilement. L'instructeur montre comment afficher la valeur et l'adresse d'une variable et comment créer un pointeur du même type de données que la variable vers laquelle il pointe.
  
  
• 03:30:00 Nous découvrons les pointeurs en programmation C. Les pointeurs sont déclarés à l'aide d'un astérisque comme opérateur d'indirection et une convention de dénomination commune utilise un "p" minuscule suivi du nom de la variable avec la première lettre en majuscule. La valeur d'un pointeur est une adresse, et nous pouvons accéder à la valeur stockée à cette adresse en utilisant l'opérateur d'indirection. Il est important de s'assurer que les types de données du pointeur et de la variable vers laquelle il pointe sont cohérents. Les pointeurs peuvent également être passés en tant qu'arguments aux fonctions, permettant à la fonction d'accéder et de modifier la valeur stockée dans la variable pointée. De plus, les pointeurs peuvent être déclarés et initialisés en deux étapes, mais l'attribution immédiate d'une valeur est une bonne pratique.
  
  
• 03:35:00 L'instructeur explique les pointeurs en programmation C. Un pointeur est une variable qui contient une adresse mémoire vers une autre variable, un tableau, etc. Pour déclarer un pointeur, on utilise l'opérateur d'indirection. Pour affecter une valeur à un pointeur, vous utilisez le même opérateur. L'instructeur montre comment écrire dans un fichier en C à l'aide de pointeurs, fopen, fwrite et fclose. Pour écrire dans un fichier, vous devez créer un pointeur vers un fichier et utiliser `fprintf` pour écrire dans le fichier. L'instructeur montre également les E/S de fichiers en supprimant un fichier et en écrivant dans un fichier à un emplacement spécifique du répertoire d'un ordinateur.
  
  
• 03:40:00 L'instructeur montre comment lire le contenu d'un fichier en programmation C en créant un pointeur avec le type de données "file" et en utilisant la fonction fopen pour ouvrir le fichier. L'instructeur montre comment utiliser un tampon pour contenir un tableau de caractères pour contenir une ligne du document texte à la fois et comment lire une seule ligne du fichier à l'aide de la fonction fgets. La section explique également comment afficher toutes les lignes d'un fichier à l'aide d'une boucle while et comment ajouter une détection de fichier pour vérifier si le fichier existe avant d'essayer de le lire.
  
  
• 03:45:00 Dans cette section de la vidéo, l'instructeur passe en revue les prototypes de fonctions qui seront utilisés dans le programme, y compris les fonctions pour réinitialiser le tableau, imprimer le tableau, vérifier les espaces libres, déplacer le joueur, déplacer l'ordinateur, vérifier le gagnant , et gagnant de l'impression. Après avoir déclaré ces fonctions, l'instructeur discute de certaines variables globales à utiliser, y compris un tableau 2D de personnages nommé board, ainsi que des constantes pour les personnages du joueur et de l'ordinateur. La fonction principale est discutée ensuite, où elle déclare une variable locale pour le gagnant, la définit sur un espace vide, réinitialise le tableau et l'imprime. La vidéo comprend également des détails sur les boucles for imbriquées utilisées dans la fonction de réinitialisation de la carte et une instruction printf utilisée dans la carte d'impression.
  
  
• 03:50:00 Dans cette section du cours complet de programmation en C, l'instructeur explique comment créer une boucle while dans la fonction principale qui entourera la fonction de carte d'impression. La condition de la boucle while est que si le gagnant est un espace vide et que la valeur renvoyée par l'appel de la fonction de vérification des espaces libres n'est pas égale à zéro, la boucle se poursuivra. La fonction de vérification des espaces libres est également créée à l'aide de deux boucles for imbriquées pour parcourir le tableau 2D de caractères et décrémenter la variable locale des espaces libres si un emplacement est occupé. La fonction de déplacement du joueur est expliquée, ce qui invite l'utilisateur à entrer les numéros de ligne et de colonne pour effectuer un déplacement, et vérifie si la place est occupée ou non. La fonction de vérification du gagnant est également créée pour vérifier chaque ligne pour une condition de gain et pour vérifier chaque colonne pour une condition de gain.
  
  
• 03:55:00 L'instructeur passe en revue le code pour vérifier les lignes, les colonnes et les diagonales pour un gagnant dans un jeu Tic Tac Toe. Ils expliquent l'utilisation des boucles for et des instructions if pour parcourir les éléments du plateau de jeu et vérifier les correspondances. S'il y a un gagnant, la fonction renvoie la valeur de caractère de l'élément gagnant. Sinon, un caractère vide est retourné. L'instructeur fournit ensuite un code pour le mouvement de l'ordinateur, ce qui implique de générer des coordonnées aléatoires pour placer son symbole sur le plateau. Avant de générer des nombres aléatoires, le programme vérifie s'il y a des places disponibles sur le tableau.
  
  
• 04:00:00 L'instructeur continue de construire le jeu Tic Tac Toe en C. Il ajoute une vérification pour s'assurer que l'emplacement généré est un espace vide avant de placer un mouvement. S'il n'y a plus d'espaces disponibles, la fonction "imprimer le gagnant" est invoquée avec un espace vide, ce qui signifie que le jeu est un match nul. Ils expliquent que cette fonction est assez simple car elle affiche "Vous gagnez" si le gagnant est le joueur, "Vous perdez" si le gagnant est l'ordinateur et "C'est une égalité" s'il n'y a pas de gagnant. L'instructeur implémente une option "rejouer" à l'aide d'une boucle do while et réinitialise les variables de gagnant et de réponse au début de chaque boucle. Le jeu est exécuté et testé plusieurs fois, l'instructeur expliquant chaque étape. Enfin, ils mentionnent que le code sera publié dans la section des commentaires pour que les utilisateurs puissent l'utiliser.

[MetaQuotes]

Concepts fondamentaux de la programmation orientée objet

Concepts fondamentaux de la programmation orientée objet

Les quatre concepts fondamentaux de la programmation orientée objet sont l'abstraction, l'encapsulation, l'héritage et le polymorphisme. Avant de se plonger dans leurs significations, il est important de comprendre ce qu'est un objet. Un objet représente quelque chose du monde réel, qui peut être physique, comme une voiture ou un livre, ou non physique, comme un rendez-vous chez le dentiste ou un compte bancaire.

Dans le contexte de la programmation orientée objet, un objet fait référence à tout ce qui intéresse l'application logicielle en cours de développement, où les données doivent être stockées et traitées. Les objets sont également appelés entités.

L'abstraction est le premier concept fondamental, qui consiste à simplifier la réalité en se concentrant uniquement sur les données pertinentes et les tâches liées à un objet. Lors de la conception d'une application pour traiter des données sur une personne, par exemple, seules les données et les opérations nécessaires sont prises en compte.

Pour créer des objets par programmation, une classe est requise. Une classe sert de modèle pour créer des objets et est écrite par un programmeur pour définir les attributs (également appelés champs ou propriétés) et les opérations (également appelées comportements ou méthodes) d'un objet. Les attributs décrivent les données de l'objet, tandis que les opérations représentent les actions pouvant être effectuées par l'objet.

L'encapsulation est le deuxième concept fondamental et consiste à cacher la complexité du fonctionnement interne d'un objet aux autres programmes et programmeurs. On parle souvent de dissimulation d'informations car les données et les fonctions d'un objet sont liées entre elles et protégées des interférences externes. Les programmeurs expérimentés créent souvent des classes qui sont utilisées par les programmeurs débutants, et les bibliothèques de classes compilées protègent la propriété intellectuelle.

L'héritage est le troisième concept fondamental, permettant à une classe de dériver ses méthodes et ses propriétés d'une autre classe. Cela conduit à une hiérarchie de classes, où les sous-classes héritent d'une super-classe. Par exemple, une classe d'employés hérite d'une classe de personnes et une classe de clients hérite également de la classe de personnes. Cela crée un type de relation, avec des sous-classes étendant les propriétés et les méthodes de leur super-classe.

Le polymorphisme, le concept fondamental final, permet à une classe d'implémenter des méthodes héritées à sa manière. Différentes sous-classes de la même superclasse peuvent avoir différentes implémentations pour les méthodes héritées. Le polymorphisme permet à différentes formes d'objets avec la même interface de se comporter différemment, en fonction de leur implémentation de sous-classe spécifique.

Pour résumer, l'abstraction simplifie la réalité, l'encapsulation masque la complexité, l'héritage établit des hiérarchies de classes et le polymorphisme permet diverses implémentations des méthodes héritées. Ces concepts fondamentaux forment la base de la programmation orientée objet.

[MetaQuotes]

Cours de Programmation Orientée Objet (POO) en C++

Cours de Programmation Orientée Objet (POO) en C++

Cette vidéo donne un aperçu de la programmation orientée objet (POO) en C++. Il explique les concepts fondamentaux de la POO, tels que les classes, les objets et les méthodes. L'instructeur montre la création d'une classe C++ et de ses membres, en insistant sur l'importance de déclarer des variables en tant que types de données définis par l'utilisateur. Les modificateurs d'accès tels que privé, public et protégé sont expliqués en relation avec l'accès aux membres de l'objet.

La vidéo couvre également la mise en œuvre des principes de la POO, notamment l'encapsulation, l'abstraction, l'héritage et le polymorphisme. Il présente des exemples de la façon dont ces principes sont appliqués dans le code, tels que la création de constructeurs et de classes abstraites. L'instructeur met en évidence les avantages de la POO, tels que la simplification du développement de logiciels et la dissimulation de la complexité aux utilisateurs.

De plus, la vidéo explore le concept d'héritage, où une classe dérivée hérite des propriétés d'une classe de base. L'instructeur montre le processus de création de classes dérivées et explique comment elles peuvent avoir leurs propres propriétés uniques en plus de celles héritées.

La vidéo se termine par des discussions sur les fonctions virtuelles et le polymorphisme. Il explique comment le polymorphisme permet aux objets et aux méthodes d'avoir plusieurs formes, permettant à une référence de classe parent d'être utilisée avec des objets de classe enfant. Le concept de fonctions virtuelles est introduit, soulignant que la version la plus dérivée d'une fonction est exécutée lorsqu'elle est invoquée.

Dans l'ensemble, cette vidéo vise à fournir une compréhension complète de la POO en C++, couvrant les concepts essentiels, les principes et les implémentations pratiques. L'instructrice encourage les téléspectateurs à suivre sa chaîne, Code Beauty, et accueille les commentaires sur les vidéos.

• 00:00:00 Cette vidéo explique les bases de la programmation orientée objet et son fonctionnement pratique. Les classes sont un concept clé dans la programmation orientée objet, et les variables doivent être déclarées en tant que types de données définis par l'utilisateur afin de les utiliser.
  
  
• 00:05:00 Dans cette vidéo, une classe C++ est créée et des membres sont ajoutés. La classe a trois attributs, le nom, la société et l'âge. Une instance de la classe est créée et le numéro de variable lui est affecté.
  
  
• 00:10:00 Dans cette vidéo, l'instructeur explique comment accéder aux membres d'un objet en C++. Les modificateurs d'accès, tels que privé, public et protégé, déterminent comment les membres d'un objet sont accessibles. Une méthode de classe peut être utilisée pour décrire le comportement d'un objet.
  
  
• 00:15:00 Cette vidéo explique le fonctionnement de la programmation orientée objet (POO) en C++. Une fonction est créée avec le type de retour void et la fonction est appelée en utilisant la même syntaxe que la fonction qui a été introduite. La fonction est ensuite invoquée cinq fois, chaque fois avec un nom d'employé et une société différents. Les noms des employés et les valeurs de l'entreprise sont ensuite copiés dans un nouvel objet employé, et les attributs de l'objet employé sont définis sur les valeurs des valeurs nouvellement copiées.
  
  
• 00:20:00 Dans cette vidéo, l'instructeur passe en revue les trois règles de création de constructeurs en C++. La première règle est qu'un constructeur a le même nom que la classe à laquelle il appartient, la seconde est qu'un constructeur doit être public et la troisième est qu'un constructeur doit être accessible. Lors de la création d'un constructeur, il est important de garder à l'esprit les règles décrites dans cette vidéo. Si un constructeur ne respecte pas l'une de ces règles, une erreur sera générée.
  
  
• 00:25:00 Dans cette vidéo, l'instructeur explique les bases de la programmation orientée objet, y compris les concepts de classes, d'objets et de méthodes. Il décrit ensuite quatre principes clés de la programmation orientée objet : encapsulation, abstraction, héritage et polymorphisme. Enfin, il explique comment implémenter ces concepts dans un exemple de code.
  
  
• 00:30:00 Cette vidéo présente la programmation orientée objet (POO) en C++. Une classe est une structure qui encapsule des données et des méthodes publiques que d'autres classes peuvent invoquer pour accéder aux données et les modifier. Pour assurer l'encapsulation, les champs de classe sont privés et les getters et setters sont publics.
  
  
• 00:35:00 Dans cette vidéo, un instructeur de cours C++ discute des principes de la programmation orientée objet (POO). L'instructeur explique comment l'encapsulation et l'abstraction aident à masquer des données complexes derrière une interface simplifiée. L'instructeur explique également comment les règles de validation peuvent être appliquées aux méthodes de définition des propriétés privées.
  
  
• 00:40:00 Dans cette vidéo, le présentateur explique comment la programmation orientée objet (POO) peut simplifier le développement de logiciels en cachant la complexité aux utilisateurs. Ils utilisent un exemple de smartphone pour illustrer comment la POO peut rendre simple un processus complexe. Ils montrent ensuite comment créer un contrat qui rend un côté d'un système simple tout en cachant la complexité du système à l'utilisateur.
  
  
• 00:45:00 Cette vidéo explique le concept de programmation orientée objet (POO) en C++. La vidéo explique comment créer une classe abstraite qui nécessite l'implémentation d'une fonction virtuelle et comment tester la fonction pour voir si un employé particulier peut obtenir une promotion.
  
  
• 00: 50: 00 Dans cette vidéo, l'auteur est promu, puis si cette personne a moins de 30 ans, cette personne ne sera pas promue. Cela nous permet d'implémenter un contrat qui est en fait une classe abstraite et cette classe abstraite ou ce contrat n'a qu'une seule règle et cette règle est cette pure fonction virtuelle ici qui s'appelle demander une promotion. Ainsi, quelle que soit la classe qui signe ce contrat, quelle que soit la classe qui hérite de cet employé abstrait, qui est cette classe ici, devra fournir l'implémentation de cette méthode ici. Nous l'avons testé et comme vous avez pu le voir, je n'ai pas eu de promotion et John l'a fait, c'est l'idée de l'abstraction. Et cette méthode de demande de promotion n'est que ce bouton que nous avons mentionné un bouton sur votre smartphone depuis le début de ce chapitre. Le troisième principe de la programmation orientée objet dont je veux parler s'appelle l'héritage. L'idée d'héritage est la suivante : il y a cette classe de base aussi appelée super classe ou classe mère et puis il y a la classe dérivée aussi appelée classe enfant ou sous-classe.
  
  
• 00:55:00 Dans cette vidéo, un instructeur de cours C++ montre comment fonctionne la programmation orientée objet en créant une classe dérivée à partir d'une classe de base existante. Les propriétés de la classe de base sont alors héritées par la classe dérivée, qui acquiert également ses propres propriétés spécifiques à la classe développeur.
  
  
• 01:00:00 Dans cette vidéo, l'instructeur explique comment fonctionne la programmation orientée objet en C++. Il explique comment une classe développeur hérite d'une classe employé et comment le constructeur de la classe employé peut être utilisé pour initialiser certaines propriétés de la classe développeur. L'instructeur montre ensuite comment une méthode peut être créée sur la classe développeur pour tester si les propriétés ont été définies correctement. Enfin, il montre comment fermer la classe développeur.
  
  
• 01:05:00 Dans cette vidéo, l'instructeur aborde les concepts de programmation orientée objet (POO) d'héritage et de polymorphisme. Il montre comment utiliser ces concepts pour résoudre un problème avec un exemple de code. Enfin, l'instructeur montre comment créer une classe qui hérite d'une autre classe.
  
  
• 01:10:00 Cette vidéo donne un bref aperçu de la programmation orientée objet (POO) en C++. La vidéo explique comment créer une classe d'enseignants qui hérite d'une classe d'employés et implémente une fonction de préparation de cours. La vidéo aborde également certains des problèmes qui peuvent survenir lors de la création et de l'utilisation de classes POO, et comment les résoudre.
  
  
• 01:15:00 Dans cette vidéo, l'instructeur explique le concept de programmation orientée objet (POO) en C++. Le polymorphisme fait référence à la capacité d'un objet ou d'une méthode à avoir plusieurs formes. Une utilisation courante du polymorphisme en programmation est lorsqu'une référence de classe parent est utilisée pour faire référence à un objet d'une classe enfant. Cet exemple montre comment fonctionne le polymorphisme en revenant à la fonction principale et en invoquant la nouvelle méthode de travail sur les classes développeur et enseignant, qui héritent toutes deux de la classe employé.
  
  
• 01:20:00 Cette vidéo couvre les bases de la programmation orientée objet en C++. La première partie de la vidéo couvre l'histoire de la programmation orientée objet et comment elle diffère des autres paradigmes de programmation. La deuxième partie de la vidéo explique comment créer un pointeur vers une classe de base, et comment rendre virtuelle une méthode de travail dans une classe d'employés. Enfin, la vidéo montre comment fonctionne le pointeur et comment le programme fonctionne en conséquence.
  
  
• 01:25:00 Dans cette vidéo, l'instructeur discute du concept des fonctions virtuelles et du polymorphisme en C++. Il explique que, lorsqu'une fonction virtuelle est invoquée, la version la plus dérivée de la fonction est exécutée. Cela signifie que, si une fonction n'est pas implémentée dans les classes dérivées d'une classe, la classe développeur de la classe sera invoquée à la place. Il note également qu'avec le polymorphisme, différents types d'employés peuvent être traités comme s'ils étaient un seul grand objet, ce qui leur permet d'être référencés avec un pointeur de classe de base.
  
  
• 01:30:00 Cette vidéo présente la programmation orientée objet (POO) en C++. Il explique comment la POO rend la programmation plus organisée et plus facile à comprendre. La présentatrice recommande également aux téléspectateurs de suivre sa chaîne, de coder la beauté et de s'y abonner. Enfin, la présentatrice encourage les téléspectateurs à laisser des commentaires sur ses vidéos.