Tutoriels de programmation - page 4
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
FONCTIONS C++ (2020) - Qu'est-ce que la récursivité ? Apprenez les fonctions récursives !
FONCTIONS C++ (2020) - Qu'est-ce que la récursivité ? Apprenez les fonctions récursives ! TUTORIEL DE PROGRAMMATION
La récursivité est un processus dans lequel une fonction s'invoque elle-même et la fonction correspondante est appelée fonction récursive.
La récursivité est l'un de ces sujets de programmation qui déroute souvent les étudiants, et dans cette vidéo, j'explique comment fonctionne la récursivité et je compare également différentes solutions au même problème (en utilisant des boucles et en utilisant la récursivité).
Comment construire une application ATM en C++ ? (Pour les débutants)
Comment construire une application ATM en C++ ? (Pour les débutants) - TUTORIEL DE PROGRAMMATION (2020)
Bienvenue sur ma chaîne ! Je m'appelle Saldina et je crée des vidéos liées à la programmation. Si cela vous intéresse, pensez à vous abonner à ma chaîne et à donner un coup de pouce à cette vidéo.
Dans cette vidéo, je vais vous montrer comment créer une application ATM. Tout d'abord, planifions les fonctionnalités de l'application. Nous aurons besoin des éléments suivants :
Maintenant, commençons par implémenter la fonction "Afficher le menu". Nous allons créer une fonction appelée "showMenu" qui affiche les options de menu à l'utilisateur.
Après avoir défini le menu, nous invoquerons la fonction "showMenu" pour l'afficher. Ensuite, nous permettrons à l'utilisateur de choisir une option.
Pour gérer le choix de l'utilisateur, nous utiliserons un boîtier de commutation. Pour chaque cas, nous effectuerons l'action correspondante. Dans le cas de l'option 1, nous afficherons le solde. Dans le cas de l'option 2, nous demanderons le montant du dépôt et mettrons à jour le solde en conséquence. Dans le cas de l'option 3, nous demanderons le montant du retrait et vérifierons s'il est valide avant de mettre à jour le solde. Enfin, nous ajouterons une option 4 pour quitter le programme.
Pour permettre à l'utilisateur d'interagir avec le menu de manière répétée, nous utiliserons une boucle do-while. La boucle continuera jusqu'à ce que l'utilisateur sélectionne l'option 4.
N'hésitez pas à améliorer le programme en ajoutant plus de fonctionnalités, telles que le transfert d'argent entre comptes. Partagez votre code dans les commentaires, et je l'examinerai. N'oubliez pas d'aimer, de vous abonner et d'appuyer sur l'icône de la cloche. Rendez-vous dans la prochaine vidéo !
FONCTIONS C++ (2020) - Que sont les fonctions génériques et les modèles ? TUTORIEL DE PROGRAMMATION
FONCTIONS C++ (2020) - Que sont les fonctions génériques et les modèles ? TUTORIEL DE PROGRAMMATION
Bonjour à tous, bienvenue sur ma chaîne ! Je m'appelle Saldina et je crée des vidéos liées à la programmation. Si vous êtes intéressé par la programmation, abonnez-vous à ma chaîne et donnez un coup de pouce à cette vidéo. Votre soutien m'aide à toucher plus de personnes et à diffuser mes connaissances en programmation.
Dans cette vidéo, je veux parler des génériques et des modèles en C++. Les génériques nous permettent d'utiliser le même code avec différents types de données. Cela signifie que nous pouvons avoir une seule fonction qui fonctionne avec différents types de données.
Prenons un exemple pour comprendre ce concept. Supposons que nous voulions créer une fonction qui échange les valeurs de deux variables. Initialement, nous créons la fonction pour échanger deux variables entières, mais nous pouvons l'étendre pour qu'elle fonctionne également avec d'autres types de données.
Pour créer une fonction générique, nous utilisons des modèles en C++. Nous définissons un type de modèle à l'aide du mot-clé "template" suivi du nom du type, communément appelé "T". Dans la fonction, nous remplaçons le type de données spécifique par "T". Cela rend la fonction générique et capable de travailler avec différents types de données.
Nous n'avons plus besoin de créer des fonctions distinctes pour chaque type de données. La fonction de modèle peut être utilisée avec n'importe quel type de données prenant en charge la logique de permutation.
Pour tester la fonction, nous créons des variables du type souhaité et les transmettons à la fonction d'échange générique. Le mécanisme d'inférence de type en C++ nous permet d'omettre de spécifier explicitement le type.
En utilisant des génériques et des modèles, nous pouvons éliminer la duplication de code et écrire un code plus flexible et réutilisable. Cette approche nous permet de gérer différents types de données sans créer de fonctions distinctes pour chaque type.
J'espère que cette vidéo vous a aidé à comprendre le concept de génériques et de modèles en C++. Si vous l'avez trouvé utile, abonnez-vous à ma chaîne et donnez un coup de pouce à cette vidéo. Votre aide est très appréciée. Merci d'avoir regardé, et je vous verrai dans ma prochaine vidéo. Au revoir!
Expressions lambda en C++ moderne (tutoriel détaillé étape par étape)
Expressions lambda en C++ moderne (tutoriel détaillé étape par étape)
Bienvenue sur ma chaîne, tout le monde ! Dans cette vidéo, je vais aborder un sujet crucial dans le C++ moderne, à savoir les expressions lambda, également appelées lambdas. Vous avez probablement déjà entendu parler des lambdas, et aujourd'hui je vais vous expliquer tout ce que vous devez savoir pour commencer à écrire du code plus rapidement et plus proprement en utilisant les lambdas en C++ moderne.
Je couvrirai les concepts les plus importants, mais gardez à l'esprit que les lambdas sont un vaste sujet avec beaucoup à apprendre. Si vous voulez des exemples et des exercices supplémentaires, je fournirai un livre gratuit dans la description qui se concentre sur les lambdas en C++ moderne. N'hésitez pas à y jeter un œil.
Les expressions lambda ont été introduites dans le C++ moderne et sont disponibles dans C++11 et supérieur. Leur objectif principal est de vous permettre d'écrire des fonctions anonymes en ligne. Que sont donc les fonctions anonymes en ligne ? Les fonctions régulières vous permettent d'écrire du code une fois et de le réutiliser en invoquant la fonction chaque fois que vous avez besoin de ce code à nouveau, éliminant ainsi le besoin de code redondant. D'autre part, une fonction en ligne est une petite fonction simple qui n'est pas destinée à être réutilisée comme fonctions régulières. Ils sont souvent utilisés pour de petits extraits de code qui ne nécessitent pas de nom et ne valent pas la peine de créer une fonction distincte. C'est là que les lambdas brillent car ils fournissent un moyen d'écrire des fonctions sans nom qui sont concises, faciles à lire, rapides à exécuter et qui conservent tout au même endroit.
Maintenant, plongeons dans le code. Pour cette démonstration, j'utiliserai C++Builder, l'IDE idéal pour créer des applications d'interface utilisateur C++. Si vous souhaitez en savoir plus sur les applications d'interface utilisateur C++, je fournirai un lien dans la description où vous pourrez télécharger C++Builder. Pour commencer, créons une application console. Cliquez sur « Fichier », puis sur « Nouveau autre » et sélectionnez « Application console ». Assurez-vous que C++ est sélectionné et cliquez sur "OK". Voici notre code initial. Faisons-y quelques ajouts.
Tout d'abord, je vais ajouter une commande "system pause" pour garder la fenêtre de la console ouverte après l'exécution du code. Ensuite, j'inclurai la bibliothèque "iostream" pour les opérations d'entrée/sortie. Maintenant, notre code est prêt à être exécuté, et si nous exécutons le programme, nous verrons le "Hello, World!" message dans la console. Maintenant, regardons la structure d'une expression lambda. Je supprimerai le code précédent et nous commencerons par un exemple simple. Pour créer un lambda, nous utilisons la syntaxe suivante : crochets angulaires (clause de capture), parenthèses (paramètres) et accolades (définition de la fonction).
À l'intérieur de la clause de capture, nous pouvons spécifier des variables de la portée englobante que nous voulons utiliser à l'intérieur du lambda. Pour l'instant, laissons la clause de capture vide et concentrons-nous sur les paramètres. Nous pouvons définir les paramètres à l'intérieur des parenthèses. Dans cet exemple, j'utiliserai un seul paramètre, "p". Enfin, nous définissons le corps de la fonction lambda à l'intérieur des accolades. Maintenant, créons un exemple où nous rencontrerons un problème, puis résolvons-le à l'aide de lambdas. Nous allons travailler avec un vecteur, nous devons donc inclure la bibliothèque "vecteur". Je vais créer un vecteur d'entiers appelé "v" et l'initialiser avec quelques valeurs. Ensuite, je vais vous présenter une fonction utile de la bibliothèque "algorithm" appelée "for_each". Cette fonction itère sur les éléments d'une plage, comme notre vecteur, et applique une fonction donnée à chaque élément.
Dans la fonction "for_each", nous spécifierons la plage en utilisant "v.begin()" et "v.end()". Maintenant, définissons ce que nous voulons faire avec chaque élément. Dans un premier temps, je vais vous montrer un problème avec le code, puis présenter les lambdas comme solution. J'ai ajouté une structure avec un opérateur surchargé qui imprime le paramètre. Nous nous attendons à ce que la fonction "for_each" imprime tous les éléments du vecteur. Si nous exécutons le code, nous verrons qu'il ne fonctionne pas comme prévu. Il n'imprime que le dernier élément. Cela est dû au fait que l'opérateur surchargé est passé par valeur et copie le paramètre pour chaque appel, ce qui entraîne une sortie incorrecte. Pour résoudre ce problème, nous pouvons remplacer l'opérateur surchargé par une expression lambda. Je vais copier la syntaxe de l'expression lambda dont nous avons parlé plus tôt et la coller dans la fonction "for_each". Maintenant, exécutons à nouveau le code.
Comme vous pouvez le voir, l'expression lambda fonctionne parfaitement et imprime tous les éléments du vecteur. L'expression lambda simplifie le code et améliore la lisibilité. Cela garantit également que le paramètre correct est transmis à chaque appel, évitant ainsi le problème que nous avons rencontré précédemment. Explorons maintenant une autre fonctionnalité utile des lambdas, qui est leur capacité à capturer des variables de la portée englobante. Cette fonctionnalité permet aux lambdas d'accéder aux variables et de les utiliser à l'intérieur du lambda. Cependant, par défaut, les lambdas capturent les variables par valeur, ce qui signifie qu'ils créent une copie de la variable.
Dans notre prochain exemple, je vais créer une variable appelée "multiplicateur" et la définir sur 2. À l'intérieur du lambda, j'utiliserai cette variable pour multiplier chaque élément du vecteur. Cette fois, j'utiliserai une boucle for basée sur une plage au lieu de la fonction "for_each" à des fins de démonstration. Si nous exécutons le code, nous verrons que les éléments du vecteur sont multipliés par 2, grâce à la variable capturée. Cependant, il y a une limitation avec la capture de variables par valeur. Nous ne pouvons pas modifier la variable capturée à l'intérieur du lambda.
Pour surmonter cette limitation, nous pouvons capturer la variable par référence, ce qui nous permet de modifier sa valeur. Je vais le démontrer en ajoutant une opération d'incrémentation à l'expression lambda. Maintenant, si nous exécutons le code, nous verrons que les éléments du vecteur sont multipliés par 2 puis incrémentés de 1. La capture de variables à partir de la portée englobante offre de la flexibilité et permet aux lambdas de travailler avec des données externes de manière transparente. Il est important de garder à l'esprit que la capture de variables par référence peut avoir des implications, telles que la gestion de la durée de vie et les courses de données potentielles. Soyez donc prudent lorsque vous utilisez cette fonctionnalité et assurez-vous que la variable capturée reste valide pendant l'exécution du lambda.
Pour résumer, les expressions lambda sont des outils puissants du C++ moderne pour écrire du code concis et lisible. Ils vous permettent de créer des fonctions anonymes en ligne, réduisant ainsi le besoin de fonctions distinctes pour les petits extraits de code. Les lambdas peuvent également accéder aux variables à partir de leur portée englobante, offrant une flexibilité et améliorant la réutilisation du code.
J'espère que vous avez trouvé cette vidéo utile pour comprendre les expressions lambda en C++ moderne. Si vous avez des questions, n'hésitez pas à les poser dans les commentaires ci-dessous. N'oubliez pas d'aimer cette vidéo et de vous abonner à ma chaîne pour plus de tutoriels C++. Merci d'avoir regardé et bon codage !
Trucs et astuces Visual Studio pour les professionnels - Tutoriel Visual Studio
Trucs et astuces Visual Studio pour les professionnels - Tutoriel Visual Studio
Bonjour à tous! Je m'appelle Leslie Richardson et je travaille en tant que responsable de programme dans l'équipe Visual Studio Debugging and Diagnostics. Dans cette vidéo, je suis ravi de discuter d'une nouvelle fonctionnalité de Visual Studio 2019 appelée la fonctionnalité de recherche pour les fenêtres Autos, Locals et Watch. Cette fonctionnalité est conçue pour améliorer considérablement votre expérience de débogage et vous faire gagner un temps précieux, ce qui vous rend plus productif.
Pour illustrer cette fonctionnalité, considérons un scénario dans lequel j'ai une application .NET Core ouverte dans Visual Studio 2019. Dans cette application, j'ai une liste qui contient plusieurs objets de recette. Le défi auquel je suis confronté est de localiser des recettes spécifiques dans cette liste, ce qui peut être assez fastidieux, surtout lorsque la liste contient 61 objets. Développer manuellement chaque objet, trouver la propriété title et vérifier s'il correspond à mes critères de recherche, tels que "salade", est une tâche qui prend du temps.
Pour simplifier ce processus, j'utiliserai une fonctionnalité appelée "Affichage du débogueur". Cette fonctionnalité me permet de personnaliser l'affichage des objets dans diverses fenêtres de débogage, notamment les fenêtres Autos, Locals et Watch. En ajoutant l'attribut "Debugger Display" à la définition de classe de mes objets, je peux spécifier quelle propriété doit être affichée dans la colonne de valeur de ces fenêtres. Dans ce cas, je souhaite afficher chaque recette par son titre, j'ai donc défini l'attribut "Affichage du débogueur" pour afficher la propriété du titre de la recette.
Maintenant, lorsque je développe à nouveau la liste des recettes, je peux voir immédiatement le titre de chaque objet, ce qui facilite grandement la localisation des recettes souhaitées sans développer chacune individuellement. C'est une amélioration significative, mais avec 61 articles, cela peut encore prendre du temps pour trouver les recettes spécifiques qui m'intéressent. C'est là que la fonction de recherche de la fenêtre de surveillance est utile.
Au lieu de faire défiler ou de développer manuellement la liste, je peux simplement utiliser la fonctionnalité de recherche fournie. Je saisis mon terme de recherche, tel que "salade", et j'appuie sur Entrée. Visual Studio m'amène immédiatement à la première occurrence du mot-clé, ce qui me fait gagner beaucoup de temps et d'efforts. Je peux également utiliser le bouton "Rechercher le suivant" pour parcourir d'autres correspondances trouvées par Visual Studio. Pour naviguer en avant et en arrière dans la liste des correspondances, je peux ajuster le paramètre d'étape de recherche, qui détermine la profondeur de la recherche.
En plus de la fonctionnalité de recherche, je tiens également à mentionner que la fonctionnalité d'affichage du débogueur est disponible pour les utilisateurs de code managé, tels que ceux qui utilisent C#, F# ou Visual Basic. Pour les utilisateurs de C++, une fonctionnalité équivalente appelée NATVIS est disponible. Avec NATVIS, vous devez créer un fichier XML séparé dans lequel vous pouvez définir les propriétés à afficher dans les fenêtres du débogueur.
J'espère que cette explication a été utile. Merci d'avoir regardé!
Voyons maintenant comment rendre l'interface de Visual Studio plus organisée et améliorer ses performances. Lorsque nous ouvrons des solutions dans Visual Studio, il se souvient de l'état des documents, des positions de défilement et des sections développées/réduites dans l'Explorateur de solutions depuis la dernière fois que nous l'avons utilisé. Bien que cela puisse être utile, cela consomme également des cycles CPU et n'est pas toujours souhaitable. Pour repartir à zéro et améliorer les performances, nous pouvons modifier certains paramètres.
Dans le menu Outils > Options, sous la section Projets et solutions, il y a deux paramètres à prendre en compte. L'option "Rouvrir les documents lors du chargement de la solution" mémorise les documents précédemment ouverts, et l'option "Restaurer l'état de la hiérarchie du projet de l'explorateur de solutions lors du chargement de la solution" mémorise l'état développé/réduit de l'explorateur de solutions. En décochant ces options, Visual Studio ne restaurera pas l'état précédent lors de l'ouverture d'une solution. Au lieu de cela, cela commencera par une table rase, sans aucun document ouvert ou section développée dans l'Explorateur de solutions. Cela peut aider à améliorer les performances et fournir un nouveau départ pour chaque solution.
Lorsque vous travaillez avec Git dans Visual Studio, plusieurs fonctionnalités peuvent améliorer votre productivité et votre collaboration. La fenêtre Git Changes fournit une vue complète de votre référentiel Git et vous permet de mettre en scène, de valider et de transmettre des modifications directement depuis Visual Studio. Vous pouvez accéder à cette fenêtre en allant dans View > Git Changes. En outre, Visual Studio fournit un outil de comparaison Git intégré qui met en évidence les différences entre les différentes versions de votre code. Vous pouvez accéder à cette fonctionnalité en cliquant avec le bouton droit sur un fichier dans l'explorateur de solutions et en sélectionnant "Comparer avec non modifié" ou "Comparer avec le plus récent".
Une autre fonctionnalité utile de Visual Studio est la possibilité de refactoriser le code. La refactorisation permet d'améliorer la structure et la lisibilité de votre code sans modifier son comportement. Visual Studio fournit une variété d'options de refactorisation, telles que renommer des variables ou des méthodes, extraire du code dans des méthodes ou des classes distinctes et réorganiser des blocs de code. Pour accéder à ces options de refactorisation, faites un clic droit sur le code que vous souhaitez refactoriser et sélectionnez "Refactoriser" dans le menu contextuel. Vous pouvez également utiliser des raccourcis clavier pour les opérations de refactorisation courantes, telles que Ctrl + R, Ctrl + R pour renommer un symbole.
Pour améliorer encore votre expérience de codage, vous pouvez tirer parti des extraits de code dans Visual Studio. Les extraits de code sont des modèles de code prédéfinis qui peuvent être rapidement insérés dans votre code en tapant un raccourci et en appuyant sur la touche Tab. Visual Studio fournit une large gamme d'extraits de code intégrés pour différents langages de programmation et frameworks. Vous pouvez également créer vos propres extraits de code personnalisés pour automatiser les tâches de codage répétitives. Pour accéder aux extraits de code et les gérer, accédez à Outils > Gestionnaire d'extraits de code.
Le débogage est une partie essentielle du processus de développement et Visual Studio offre de puissantes fonctionnalités de débogage. Vous pouvez définir des points d'arrêt dans votre code pour interrompre l'exécution et inspecter l'état des variables et des objets. Lors du débogage, vous pouvez utiliser la fenêtre Espion pour surveiller les valeurs de variables ou d'expressions spécifiques. La fenêtre Exécution vous permet d'exécuter du code et d'évaluer des expressions pendant le débogage. Vous pouvez également tirer parti des points d'arrêt conditionnels, qui ne se déclenchent que lorsqu'une condition spécifique est remplie, et des points de trace, qui impriment des messages dans la fenêtre Sortie sans interrompre le débogueur.
Visual Studio prend également en charge les tests unitaires, qui sont essentiels pour garantir la qualité et l'exactitude de votre code. Vous pouvez créer des tests unitaires à l'aide de divers frameworks de test, tels que MSTest, NUnit ou xUnit. Visual Studio fournit une fenêtre Explorateur de tests qui affiche tous les tests disponibles dans votre solution et vous permet de les exécuter ou de les déboguer individuellement ou en groupes. Vous pouvez utiliser des attributs pour définir des méthodes de test et des assertions afin de vérifier les résultats attendus. Visual Studio propose également une analyse de la couverture du code, qui vous montre quelle partie de votre code est couverte par les tests unitaires.
Lorsque vous travaillez avec de grands projets ou solutions, il peut être difficile de naviguer et de comprendre la base de code. Visual Studio fournit plusieurs fonctionnalités pour faciliter la navigation et la compréhension du code. L'explorateur de solutions vous permet d'explorer la structure de votre solution et de naviguer rapidement vers des fichiers ou des classes spécifiques. Vous pouvez également utiliser la fonctionnalité Naviguer vers (Ctrl + ,) pour rechercher des symboles, des fichiers ou des types dans votre solution. La fonctionnalité CodeLens affiche des informations supplémentaires sur votre code, telles que les références, les modifications et la couverture des tests, directement dans l'éditeur.
Pour le développement Web, Visual Studio offre une excellente prise en charge des technologies Web populaires telles que HTML, CSS et JavaScript. L'éditeur HTML fournit des fonctionnalités telles qu'IntelliSense, le formatage du code et la possibilité de prévisualiser vos pages HTML directement dans l'éditeur. L'éditeur CSS offre des fonctionnalités similaires, notamment des sélecteurs de couleurs, IntelliSense pour les propriétés CSS et un aperçu en direct des modifications CSS. Visual Studio prend également en charge le débogage JavaScript, ce qui vous permet de définir des points d'arrêt, d'inspecter des variables et de parcourir votre code pour identifier et résoudre les problèmes.
Visual Studio dispose d'un vaste écosystème d'extensions et de plugins qui peuvent améliorer votre expérience de développement. Ces extensions fournissent des fonctionnalités supplémentaires, une prise en charge linguistique et des outils pour des frameworks ou des plates-formes spécifiques. Vous pouvez parcourir et installer des extensions directement depuis Visual Studio en accédant à Extensions > Gérer les extensions. Certaines extensions populaires incluent ReSharper, qui offre des outils avancés d'analyse de code et de refactorisation, et Visual Studio Code, qui fournit un éditeur de code léger et multiplateforme.
Lorsque vous travaillez sur des projets collaboratifs, Visual Studio offre une intégration avec des plateformes de collaboration comme Azure DevOps et GitHub. Vous pouvez facilement connecter votre projet Visual Studio à un référentiel Git distant et effectuer des opérations Git courantes telles que l'envoi, l'extraction et la fusion de modifications. Visual Studio fournit également des outils pour les révisions de code, le suivi des éléments de travail et les workflows d'intégration et de déploiement continus.
Visual Studio prend en charge un large éventail de langages de programmation et de frameworks, notamment .NET, C++, Python, JavaScript et bien d'autres. Il fournit des fonctionnalités spécifiques à la langue comme IntelliSense, des extraits de code et des capacités de débogage adaptées à chaque langue. Vous pouvez installer des extensions et des SDK spécifiques à un langage pour améliorer encore l'expérience de développement de vos langages de programmation préférés.
Pour l'optimisation des performances et le dépannage, Visual Studio propose des outils de profilage qui aident à identifier les goulots d'étranglement et les fuites de mémoire dans vos applications. Le Performance Profiler vous permet d'analyser les performances de votre code et d'identifier les domaines qui peuvent être optimisés. Le profileur de mémoire vous aide à détecter et à diagnostiquer les problèmes liés à la mémoire dans vos applications. Ces outils de profilage fournissent des rapports et des informations détaillés pour vous aider à optimiser votre code et à améliorer les performances des applications.
Visual Studio prend également en charge le développement d'applications mobiles pour des plates-formes telles qu'Android et iOS. Vous pouvez créer des applications mobiles multiplateformes à l'aide de frameworks tels que Xamarin ou React Native. Visual Studio propose des outils pour concevoir des interfaces utilisateur, déboguer des applications mobiles et les déployer sur des émulateurs ou des appareils physiques. Vous pouvez également tirer parti des services cloud tels qu'Azure Mobile Apps pour l'intégration et le stockage backend.
En plus des applications de bureau et Web traditionnelles, Visual Studio prend en charge le développement d'applications Internet des objets (IoT). Vous pouvez créer des applications pour des appareils tels que Raspberry Pi, Arduino et d'autres appareils IoT à l'aide de Visual Studio. Les outils de développement Visual Studio IoT fournissent des modèles de projet, une prise en charge du débogage et des options de déploiement pour les scénarios IoT.
Visual Studio offre également des fonctionnalités de développement cloud avec des intégrations pour les plates-formes cloud populaires telles qu'Azure. Vous pouvez créer, gérer et déployer des ressources cloud directement depuis Visual Studio. Il fournit des outils pour créer et déployer des applications cloud, s'intégrer aux services cloud et surveiller vos ressources cloud.
Ce ne sont là que quelques-unes des nombreuses fonctionnalités et capacités que Visual Studio offre aux développeurs. C'est un IDE puissant et polyvalent qui peut répondre à un large éventail de besoins de développement et de flux de travail. Que vous travailliez sur de petits projets ou sur des solutions de grande entreprise, Visual Studio fournit les outils et les fonctionnalités nécessaires pour rationaliser votre processus de développement et augmenter votre productivité.
Code complet EA pour MetaTrader 5 en 20 minutes !
Code complet EA pour MetaTrader 5 en 20 minutes !
Aujourd'hui, nous sommes ravis de commencer à enregistrer notre premier EA (Expert Advisor) pour la plateforme de trading MetaTrader. Cet EA est conçu pour être un système de trading pour MetaTrader, et dans notre vidéo, nous effectuerons également un backtest rapide pour évaluer ses performances.
Pour commencer, nous lançons la plateforme MetaTrader et accédons au MetaEditor en cliquant sur "Outils" et en sélectionnant "MetaQuotes Language Editor" dans le menu déroulant. Le MetaEditor est l'endroit où nous créons nos conseillers experts, ainsi que des scripts et des indicateurs pour MetaTrader.
Pour créer un nouvel expert advisor, nous cliquons sur le bouton "Nouveau" dans le coin supérieur gauche du MetaEditor. Dans l'assistant qui apparaît, nous sélectionnons la première option et cliquez sur "Suivant". Nous pouvons ensuite donner à notre EA un nom, tel que "Premier EA", et cliquer à nouveau sur "Suivant". Nous sautons la sélection d'options supplémentaires et procédons en cliquant sur "Terminer".
Nous avons maintenant le code initial de notre EA. Pour commencer, nous nettoyons le code en supprimant les commentaires inutiles, tels que les commentaires gris qui ne fournissent aucune fonctionnalité au code lui-même. Nous supprimons les cinq premières lignes et quelques autres lignes inutiles, selon notre préférence.
Avant de commencer à coder, prenons un moment pour réfléchir à ce que nous voulons que notre EA fasse. Pour cette vidéo, notre objectif est que l'EA ouvre une transaction d'achat à une heure précise et la ferme à une autre heure prédéterminée de la journée. Pour ce faire, nous avons besoin de deux variables d'entrée : une pour l'heure d'ouverture et une autre pour l'heure de fermeture.
De retour au MetaEditor, nous déclarons ces deux variables d'entrée dans une nouvelle section appelée "Variables". Nous utilisons le mot-clé "input" pour spécifier que ces variables peuvent être modifiées depuis l'extérieur du code. Nous définissons leurs types sous forme d'entiers puisque nous voulons entrer des valeurs d'heure spécifiques. Par exemple, nous pouvons nommer les variables "openHour" et "closeHour".
Après avoir déclaré les variables, nous compilons le code pour nous assurer qu'il n'y a pas d'erreurs. Si tout est correct, nous pouvons voir qu'il n'y a pas de message d'erreur dans la boîte à outils.
Ensuite, nous revenons à la plateforme MetaTrader et faisons glisser notre EA sur n'importe quel graphique. Nous pouvons voir le nom, la version et le lien de l'EA dans le navigateur sous "Expert Advisors". En développant l'EA, nous pouvons accéder aux variables d'entrée et modifier leurs valeurs sans modifier le code.
Passons maintenant à la fonction "OnTick", qui est appelée à chaque fois que le prix change. Nous voulons vérifier si nous avons atteint le temps d'ouverture spécifié par l'utilisateur. Pour ce faire, nous devons récupérer l'heure actuelle du symbole et du serveur. Nous créons une variable appelée "time" de type "datetime" et utilisons la fonction "TimeCurrent" pour lui attribuer l'heure actuelle.
Avec l'heure actuelle stockée dans notre variable "time", nous pouvons maintenant vérifier si elle correspond à l'heure d'ouverture. Nous utilisons une instruction "if" pour comparer la variable "openHour" avec la composante heure de l'heure actuelle ("time.hour"). Si la condition est vraie, nous entrons dans le bloc "if".
Dans le bloc "if", nous ouvrons une position à l'aide de la fonction "OrderSend". Nous spécifions le symbole, la direction commerciale (achat), la taille du lot (1 lot) et le prix demandé comme paramètres. De plus, nous définissons les valeurs stop loss et take profit selon nos préférences.
Après avoir compilé le code et exécuté un backtest à l'aide du testeur de stratégie MetaTrader, nous observons que l'EA ouvre une position à l'heure d'ouverture spécifiée. Cependant, nous remarquons que plusieurs positions sont ouvertes en raison de mouvements de prix ultérieurs déclenchant à nouveau la fonction "OnTick".
Pour empêcher l'ouverture de plusieurs positions, nous introduisons une variable booléenne appelée "isTradeOpen" pour savoir si une transaction est déjà ouverte. Initialement, nous définissons la valeur de "isTradeOpen" sur false. Avant d'ouvrir une nouvelle position, nous vérifions si "isTradeOpen" est faux. Si c'est le cas, nous procédons à l'ouverture de la position et définissons la valeur de "isTradeOpen" sur true. De cette façon, même si la fonction "OnTick" est déclenchée plusieurs fois, elle n'ouvrira une nouvelle position que s'il n'y a pas déjà de trade ouvert.
Après avoir implémenté cette logique, nous compilons à nouveau le code et exécutons un backtest. Cette fois, nous observons que l'EA ouvre une position à l'heure d'ouverture spécifiée et n'ouvre aucune position supplémentaire tant que la précédente n'est pas fermée.
Passant à la clôture de la transaction à l'heure de clôture spécifiée, nous devons introduire une autre vérification dans la fonction "OnTick". Après avoir ouvert la position, nous comparons l'heure actuelle avec l'heure de clôture spécifiée par l'utilisateur. S'ils correspondent, nous entrons dans un bloc "if".
Dans le bloc "if", nous clôturons la transaction à l'aide de la fonction "OrderClose". Nous fournissons le numéro de ticket de la position à clôturer, ainsi que la taille du lot et le prix de l'offre comme paramètres. De plus, nous pouvons définir des paramètres supplémentaires tels que les valeurs stop loss et take profit si vous le souhaitez.
Nous compilons à nouveau le code et exécutons un backtest pour vérifier que la transaction est fermée à l'heure de clôture spécifiée. Pendant le backtest, nous pouvons vérifier l'historique des transactions pour nous assurer que les positions sont ouvertes et fermées selon les heures spécifiées.
Nous avons créé avec succès notre premier EA pour la plateforme de trading MetaTrader. L'EA est conçu pour ouvrir une transaction d'achat à une heure d'ouverture spécifique et la fermer à une heure de clôture prédéterminée. Nous avons implémenté des variables d'entrée pour permettre la personnalisation des heures d'ouverture et de fermeture sans modifier le code. En introduisant des contrôles et des variables, nous nous assurons qu'un seul commerce est ouvert à la fois et qu'il est fermé à l'heure de clôture spécifiée.
Programmation moyenne mobile Crossover EA mql5
Programmation moyenne mobile Crossover EA mql5
Salut, c'est Toby, et dans la vidéo d'aujourd'hui, je vais vous montrer comment coder un conseiller expert en croisement de moyenne mobile simple pour MetaTrader 5. Commençons.
Tout d'abord, définissons ce que nous voulons que le conseiller expert fasse. Nous voulons que l'EA ouvre une position d'achat lorsque la moyenne mobile rapide (ligne bleue) passe au-dessus de la moyenne mobile lente (ligne rouge) et ouvre une position de vente lorsque la moyenne mobile rapide passe en dessous de la moyenne mobile lente. Nous ajouterons également un stop loss et un take profit à l'EA, ainsi que des variables d'entrée pour les périodes des moyennes mobiles.
Pour commencer à coder, ouvrez le MetaEditor dans MetaTrader 5. Créez un nouveau conseiller expert en utilisant le modèle et nommez-le "Moyenne mobile". Nettoyez le code en supprimant les lignes et les commentaires inutiles. Ensuite, ajoutez des variables d'entrée pour les périodes des moyennes mobiles rapides et lentes. Définissez des valeurs par défaut pour ces variables et affichez-les dans l'onglet d'entrée des paramètres EA.
Vérifiez l'entrée de l'utilisateur dans la fonction OnInit pour vous assurer que des valeurs valides sont saisies. Si l'entrée est invalide (zéro ou négatif), affichez un message d'alerte et arrêtez l'EA. Créez des poignées pour les moyennes mobiles rapides et lentes à l'aide de la fonction ma. Définissez le symbole, la période et les variables d'entrée pour chaque moyenne mobile. Vérifiez si la création des poignées est réussie. Si ce n'est pas le cas, affichez un message d'alerte et arrêtez l'EA. Créez des variables globales pour stocker les valeurs des indicateurs. Utilisez des tableaux dynamiques pour les tampons rapides et lents. Dans la fonction OnTick, copiez les dernières valeurs des indicateurs dans les tampons et vérifiez si suffisamment de données sont disponibles. Si ce n'est pas le cas, revenez et affichez un message d'alerte.
Imprimez les valeurs des indicateurs à l'écran pour vérifier si tout fonctionne correctement. Utilisez la fonction Commentaire pour afficher les valeurs des moyennes mobiles rapides et lentes.
Dans le testeur de stratégie, testez l'EA pour vérifier si les valeurs des indicateurs s'affichent correctement. Maintenant, nous pouvons vérifier un croisement des moyennes mobiles. Si la moyenne mobile rapide est inférieure à la moyenne mobile lente à la barre 1 et au-dessus de la moyenne mobile lente à la barre 0, nous avons un croisement. Ouvrez une position d'achat dans ce cas.
Pour ouvrir des positions, utilisez la classe CTrade. Définissez une variable commerciale et effectuez les actions nécessaires. Compilez le code et testez l'EA dans le testeur de stratégie pour vérifier si la condition de croisement fonctionne correctement et si les positions sont ouvertes en conséquence.
C'est tout pour coder le conseiller expert de croisement de moyenne mobile dans MetaTrader 5. Et puis nous pouvons utiliser la fonction trade.Buy pour ouvrir une position d'achat. Nous spécifions le volume de la position, qui peut être une valeur fixe ou basée sur votre stratégie de gestion des risques. Pour l'instant, utilisons un volume fixe de 0,1 lots. Nous devons maintenant ajouter une condition pour vérifier une position de vente. Si la moyenne mobile rapide est supérieure à la moyenne mobile lente pour la barre 1 et inférieure pour la barre actuelle, nous avons un croisement dans la direction opposée. Dans ce cas, nous voulons ouvrir une position de vente. Nous pouvons utiliser la fonction trade.Sell pour le faire.
Enfin, nous pouvons ajouter un stop loss et prendre des bénéfices à nos positions. Nous utiliserons les fonctions trade.SetStopLoss et trade.SetTakeProfit. Fixons un stop loss de 100 pips et profitons de 200 pips pour cet exemple. Nous avons maintenant un code complet pour notre conseiller expert en croisement de moyenne mobile simple. Nous pouvons le compiler et le tester sur la plateforme MetaTrader 5.
Une fois que vous avez compilé le code sans aucune erreur, vous pouvez enregistrer l'expert advisor et l'utiliser dans MetaTrader 5. N'oubliez pas de tester et d'optimiser votre expert advisor avant de l'utiliser avec de l'argent réel.
Range Breakout Programmation EA mql5 | Partie 1/4
Range Breakout Programmation EA mql5 | Partie 1/4
Salut, c'est Toby, et dans la vidéo d'aujourd'hui, je vais vous montrer comment coder un conseiller expert (EA) en répartition dans le temps pour MetaTrader 5. L'objectif est d'obtenir des résultats similaires à la stratégie présentée dans la vidéo.
Tout d'abord, discutons de la logique derrière l'évaluation environnementale. Nous définirons une plage de temps simple, commençant à un moment précis et se terminant à un autre moment. L'EA enregistrera les prix les plus élevés et les plus bas dans cette fourchette. Si le prix dépasse le prix le plus élevé après la fourchette, l'EA entrera dans une transaction d'achat. Inversement, si le prix tombe en dessous de la fourchette, l'EA entrera dans une transaction de vente. De plus, nous fixerons une heure de clôture pour fermer toutes les positions. Cette logique simple guidera notre évaluation environnementale.
Pour commencer à coder, ouvrez MetaEditor et créez un nouveau conseiller expert. Nettoyez le code du modèle, selon vos préférences personnelles, en supprimant les lignes inutiles.
Ensuite, définissez les variables d'entrée pour l'heure de début, la durée de la plage, l'heure de clôture, la taille du lot et le nombre magique. Ces entrées permettent aux utilisateurs de personnaliser le comportement de l'EA. Il est important de vérifier les valeurs d'entrée pour éviter des entrées incorrectes. Par exemple, nous pouvons nous assurer que le nombre magique n'est pas nul ou négatif, que les lots ne sont pas négatifs, que l'heure de début et la durée se situent dans des plages valides et que l'heure de clôture n'est pas égale à l'heure de début plus la durée de la plage.
Après avoir défini les variables d'entrée et vérifié leurs valeurs, nous passons à la création des variables globales. Ces variables seront utilisées tout au long de l'EE. Nous regroupons les variables liées à la gamme dans une structure appelée "structure de gamme". Cette structure contient des variables pour l'heure de début, l'heure de fin, l'heure de clôture, les prix hauts et bas, et des indicateurs pour l'entrée, la cassure haute et la cassure basse.
De plus, nous définissons le constructeur de la structure, où nous prédéfinissons les valeurs initiales des variables. Cela permet d'initialiser la structure avec des valeurs par défaut. Nous ajoutons également des commentaires après chaque variable pour décrire leur objectif.
Nous compilons le code pour vérifier les éventuelles erreurs et nous assurer que tout fonctionne correctement.
Enfin, nous créons quelques variables supplémentaires, telles que "MqlTick" et "last_tick" du type MetaTrader 5 "MqlTick". Nous définissons également une variable de type "CTrade" pour gérer les opérations liées au commerce.
À ce stade, nous avons mis en place les variables et les structures nécessaires pour notre EA. Dans la partie suivante, nous plongerons dans le codage de la logique réelle de l'EA dans la fonction "OnTick". Dans la prochaine partie de la vidéo, nous nous concentrerons sur le codage de la logique réelle de l'Expert Advisor dans la fonction OnTick. Cependant, avant de continuer, examinons d'abord ce que nous avons fait jusqu'à présent.
Nous avons commencé par définir les variables d'entrée pour l'EA, telles que l'heure de début de la plage, la durée, l'heure de clôture, la taille du lot et le nombre magique. Nous avons également ajouté des contrôles de validation des entrées pour nous assurer que l'utilisateur saisit des valeurs valides pour ces entrées. Ensuite, nous avons créé une structure appelée rangeStructure pour stocker les variables liées à la plage, y compris l'heure de début, l'heure de fin, l'heure de fermeture, le haut et le bas de la plage et les indicateurs d'entrée, de cassure haute et de cassure basse. Nous avons ensuite défini un constructeur pour la rangeStructure pour initialiser les variables avec des valeurs par défaut. De plus, nous avons déclaré quelques variables globales, y compris une instance de la rangeStructure, deux variables de type MqlTick pour stocker les ticks actuels et précédents, et un objet CTrade pour gérer les opérations commerciales.
Passons maintenant à l'implémentation de la fonction OnTick pour coder la logique principale de l'EA. Voici la suite de la vidéo : Dans la fonction OnTick, nous allons d'abord mettre à jour les informations de tick actuelles à l'aide de la fonction SymbolInfoTick. Cela nous permet d'accéder aux cours acheteur et vendeur, ainsi qu'à l'heure du tick. Ensuite, nous vérifierons si le temps de tick actuel se situe dans la plage définie par l'utilisateur. Pour ce faire, nous comparons l'heure actuelle du tick avec l'heure de début et l'heure de fin de la plage. Si le temps de tick est dans la plage, nous définissons flagEntry sur true, indiquant que nous sommes dans la plage.
Après cela, nous vérifions une cassure élevée. Si le prix du tick actuel dépasse le sommet précédent de la fourchette et que le flagHighBreakout est faux, nous lançons une transaction d'achat. Nous définissons flagHighBreakout sur true pour éviter les entrées répétées. De même, nous vérifions une cassure faible. Si le prix du tick actuel tombe en dessous du plus bas précédent de la fourchette et que le flagLowBreakout est faux, nous lançons une transaction de vente. Nous définissons flagLowBreakout sur true pour éviter les entrées multiples. Enfin, nous vérifions si l'heure actuelle du tick est égale à l'heure de clôture. Si tel est le cas, nous fermons toutes les positions ouvertes à l'aide de la méthode trade.CloseAll.
C'est la logique de base de l'EA. Bien sûr, vous pouvez ajouter des éléments supplémentaires pour améliorer sa fonctionnalité, tels que les niveaux stop-loss et take-profit, les règles de gestion de l'argent et des filtres commerciaux supplémentaires. Cependant, dans cette vidéo, nous nous sommes concentrés sur le concept de base de la stratégie d'évasion de la plage de temps.
N'oubliez pas que cet EA est destiné à servir de point de départ et que vous pouvez le personnaliser davantage en fonction de vos besoins et de vos préférences commerciales.
Dans la prochaine partie de la vidéo, nous continuerons le processus de codage, en ajoutant le code nécessaire pour implémenter la logique discutée. Si vous avez trouvé cette vidéo utile, n'oubliez pas de laisser un j'aime et de vous abonner à ma chaîne pour rester à jour avec les futures vidéos. Si vous avez des questions ou avez besoin d'aide, n'hésitez pas à laisser un commentaire, et je serai ravi de vous aider. Merci d'avoir regardé, et je vous verrai dans la prochaine vidéo. Au revoir!
Range Breakout Programmation EA mql5 | Partie 2/4
Range Breakout Programmation EA mql5 | Partie 2/4
Salut, c'est Toby, et dans la vidéo d'aujourd'hui, nous allons continuer à coder notre EA de répartition temporelle pour MetaTrader 5. Si vous n'avez pas encore regardé la première vidéo, vous pouvez trouver le lien ici. Dans la vidéo précédente, j'ai expliqué la logique de l'EA et ce que nous essayons de coder.
Passons maintenant à MetaEditor et reprenons le codage. Nous allons travailler sur la fonction OnTick, qui est appelée chaque fois que le prix change pour notre symbole. Dans cette fonction, nous allons coder notre calcul de gamme et le contrôle de cassure. Tout d'abord, nous devons obtenir le tick actuel du symbole. Nous stockons le tick actuel dans une variable appelée currentTick, et nous avons également une variable previousTick pour stocker le tick précédent.
Ensuite, nous vérifions si nous devons calculer une nouvelle plage. Il existe plusieurs conditions pour calculer une nouvelle plage.
Si nous avons défini une heure de fermeture de plage et que l'heure actuelle du tick est supérieure ou égale à l'heure de fermeture de plage, nous calculons une nouvelle plage.
Si les indicateurs de cassure haute et de cassure basse sont définis sur vrai, nous calculons une nouvelle plage.
Si c'est la première fois que nous exécutons l'EA et que nous n'avons pas encore calculé de plage, nous calculons une nouvelle plage.
Si l'heure de fin de la plage n'est pas zéro et que nous sommes après la plage et que nous n'avons pas entré la plage, nous calculons une nouvelle plage.
Nous vérifions également si nous avons des postes ouverts. S'il n'y a pas de positions ouvertes, nous procédons au calcul d'une nouvelle fourchette.
Une fois que nous avons déterminé que nous devons calculer une nouvelle plage, nous appelons la fonction CalculateRange. Dans cette fonction, nous réinitialisons toutes les variables de plage à leur état par défaut. Nous calculons ensuite l'heure de début de la plage en obtenant le début de la journée et en ajoutant l'heure de début de la plage d'entrée en minutes. Si l'heure de début calculée est déjà dépassée, nous la décalons au jour suivant, en considérant le samedi et le dimanche comme des jours de week-end. De même, nous calculons l'heure de fin de la plage en ajoutant la durée de la plage d'entrée en minutes à l'heure de début. Si l'heure de fin tombe un samedi ou un dimanche, nous la décalons au jour valide suivant.
Nous calculons également l'heure de fermeture de la plage en utilisant la même logique que le calcul de l'heure de début et de l'heure de fin. Pour visualiser les temps calculés sur le graphique, nous créons des objets à l'aide de la fonction ObjectCreate. Nous créons un objet de ligne verticale pour l'heure de début de la plage et supprimons tous les objets précédemment dessinés.
C'est le progrès que nous avons fait jusqu'à présent, et nous continuerons à coder dans la prochaine vidéo.
Range Breakout Programmation EA mql5 | Partie 3/4
Range Breakout Programmation EA mql5 | Partie 3/4
Salut, c'est Toby, et dans la vidéo d'aujourd'hui, nous allons continuer à coder notre EA en petits groupes. Dans les vidéos précédentes, nous avons déjà calculé l'heure de début, l'heure de fin et l'heure de fermeture de la plage. Maintenant, nous voulons coder la gamme haute et la gamme basse, ainsi que les conditions de cassure et la fermeture de la position. Si vous n'avez pas regardé les vidéos précédentes, vous pouvez trouver les liens dans la description ci-dessous. Passons à MetaEditor et commençons à coder.
Tout d'abord, nous allons passer à la fonction OnTick. Nous allons commencer par vérifier si nous sommes dans la plage et enregistrer les valeurs haute et basse. Nous utilisons une instruction if pour vérifier si l'heure actuelle se situe entre les heures de début et de fin de la plage. Si c'est le cas, nous mettons à jour les valeurs haute et basse en conséquence. Nous avons également défini un indicateur d'entrée sur true pour indiquer que nous avions une coche à l'intérieur de la plage. Nous mettons ensuite à jour les objets du graphique pour la plage haute et basse.
Ensuite, nous passons à la fonction DrawObject pour dessiner les niveaux haut et bas de la plage. Nous copions le bloc de code pour l'heure de fermeture et apportons les modifications nécessaires pour le niveau supérieur. Nous utilisons le nom d'objet "Range High" et traçons une ligne de tendance depuis l'heure de début de la gamme jusqu'au prix le plus élevé de la gamme. Nous mettons également à jour l'info-bulle pour afficher la valeur haute de la plage. Nous faisons la même chose pour la gamme basse, en changeant le nom de l'objet et en traçant une ligne de tendance de l'heure de début de la gamme au prix bas de la gamme.
Pour tracer une ligne entre la fin de la plage et l'heure de fermeture, indiquant une cassure, nous copions à nouveau le bloc de code et le modifions en conséquence. Nous modifions le nom de l'objet et traçons une ligne de tendance entre l'heure de fin de la plage et l'heure de clôture. Nous avons également défini le style de ligne sur pointillé.
Après avoir compilé et exécuté un test visuel, nous pouvons voir la plage haute, la plage basse et les lignes de cassure affichées sur le graphique. Maintenant, codons les conditions d'évasion. Nous ajoutons une nouvelle fonction appelée CheckBreakouts dans la fonction OnTick. Tout d'abord, nous vérifions si nous sommes après l'heure de fin de la plage. Nous nous assurons également que l'indicateur d'entrée est défini sur vrai, indiquant que nous avions une coche à l'intérieur de la plage. Si ces conditions sont remplies, nous procédons à la vérification des cassures hautes et basses.
Pour une cassure haute, nous vérifions si le drapeau de cassure haute est faux et si le cours vendeur du dernier tick est supérieur ou égal au haut de la fourchette. Si tel est le cas, nous ouvrons une position d'achat à l'aide de la fonction PositionOpen. De même, pour une cassure basse, nous vérifions si le drapeau de cassure basse est faux et si le cours acheteur du dernier tick est inférieur ou égal au bas de la fourchette. Si ces conditions sont remplies, nous ouvrons une position de vente.
Nous compilons le code et exécutons un test visuel pour confirmer que les positions sont ouvertes lorsqu'une cassure se produit. Ensuite, nous implémentons la fermeture de position. Avant de calculer une nouvelle plage, nous vérifions si l'heure actuelle est supérieure ou égale à l'heure de fermeture de la plage. Si c'est le cas, nous appelons la fonction ClosePositions. Cette fonction parcourt toutes les positions ouvertes avec le nombre magique spécifié et les ferme à l'aide de la fonction PositionClose. Nous utilisons une boucle de compte à rebours pour nous assurer que toutes les positions sont fermées même si le nombre total de positions change pendant la boucle.
Enfin, nous compilons le code et exécutons un test visuel pour confirmer que les positions sont fermées lorsque l'heure de fermeture de la plage est atteinte.
Voilà pour cette vidéo. Si vous avez des questions, n'hésitez pas à les laisser dans les commentaires ci-dessous. N'oubliez pas d'aimer et de vous abonner pour plus de vidéos de codage. Merci d'avoir regardé!