Programmier-Tutorial - Seite 4
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
C++-FUNKTIONEN (2020) – Was ist Rekursion? Lernen Sie rekursive Funktionen!
C++-FUNKTIONEN (2020) – Was ist Rekursion? Lernen Sie rekursive Funktionen! PROGRAMMIERTUTORIAL
Rekursion ist ein Prozess, bei dem eine Funktion sich selbst aufruft und die entsprechende Funktion als rekursive Funktion bezeichnet wird.
Rekursion ist eines dieser Themen in der Programmierung, das Schüler oft verwirrt. In diesem Video erkläre ich, wie Rekursion funktioniert, und vergleiche auch verschiedene Lösungen für dasselbe Problem (Verwendung von Schleifen und Rekursion).
Wie erstellt man eine ATM-Anwendung in C++? (Für Anfänger)
Wie erstellt man eine ATM-Anwendung in C++? (Für Anfänger) - PROGRAMMIERTUTORIAL (2020)
Willkommen auf meinem Kanal! Ich bin Saldina und ich erstelle Videos zum Thema Programmierung. Wenn Sie daran interessiert sind, sollten Sie meinen Kanal abonnieren und diesem Video einen Daumen nach oben geben.
In diesem Video zeige ich Ihnen, wie Sie eine Geldautomatenanwendung erstellen. Lassen Sie uns zunächst die Funktionalitäten der Anwendung planen. Wir benötigen Folgendes:
Beginnen wir nun mit der Implementierung der Funktion „Menü anzeigen“. Wir erstellen eine Funktion namens „showMenu“, die dem Benutzer die Menüoptionen anzeigt.
Nachdem wir das Menü definiert haben, rufen wir die Funktion „showMenu“ auf, um es anzuzeigen. Dann ermöglichen wir dem Benutzer, eine Option auszuwählen.
Um die Auswahl des Benutzers zu handhaben, verwenden wir ein Schaltergehäuse. Für jeden Fall führen wir die entsprechende Aktion durch. Bei Option 1 zeigen wir den Saldo an. Bei Option 2 fragen wir nach dem Einzahlungsbetrag und aktualisieren den Saldo entsprechend. Im Fall von Option 3 fragen wir nach dem Auszahlungsbetrag und prüfen, ob dieser gültig ist, bevor wir den Kontostand aktualisieren. Abschließend fügen wir eine Option 4 zum Beenden des Programms hinzu.
Damit der Benutzer wiederholt mit dem Menü interagieren kann, verwenden wir eine do-while-Schleife. Die Schleife wird fortgesetzt, bis der Benutzer Option 4 auswählt.
Fühlen Sie sich frei, das Programm zu erweitern, indem Sie weitere Funktionen hinzufügen, wie z. B. den Geldtransfer zwischen Konten. Teile deinen Code in den Kommentaren und ich werde ihn überprüfen. Vergessen Sie nicht, den Beitrag zu liken, zu abonnieren und auf das Glockensymbol zu klicken. Wir sehen uns im nächsten Video!
C++-FUNKTIONEN (2020) – Was sind generische Funktionen und Vorlagen? PROGRAMMIERTUTORIAL
C++-FUNKTIONEN (2020) – Was sind generische Funktionen und Vorlagen? PROGRAMMIERTUTORIAL
Hallo zusammen, willkommen auf meinem Kanal! Mein Name ist Saldina und ich erstelle Videos zum Thema Programmierung. Wenn Sie am Programmieren interessiert sind, abonnieren Sie bitte meinen Kanal und geben Sie diesem Video einen Daumen nach oben. Ihre Unterstützung hilft mir, mehr Menschen zu erreichen und Programmierkenntnisse zu verbreiten.
In diesem Video möchte ich über Generika und Vorlagen in C++ sprechen. Generics ermöglichen es uns, denselben Code mit unterschiedlichen Datentypen zu verwenden. Das bedeutet, dass wir eine einzige Funktion haben können, die mit verschiedenen Datentypen arbeitet.
Nehmen wir ein Beispiel, um dieses Konzept zu verstehen. Angenommen, wir möchten eine Funktion erstellen, die die Werte zweier Variablen vertauscht. Zunächst erstellen wir die Funktion zum Austauschen zweier Integer-Variablen, können sie aber auch auf andere Datentypen erweitern.
Um eine generische Funktion zu erstellen, verwenden wir Vorlagen in C++. Wir definieren einen Vorlagentyp mit dem Schlüsselwort „template“, gefolgt vom Typnamen, der üblicherweise als „T“ bezeichnet wird. Innerhalb der Funktion ersetzen wir den spezifischen Datentyp durch „T“. Dadurch ist die Funktion generisch und kann mit verschiedenen Datentypen arbeiten.
Wir müssen nicht mehr für jeden Datentyp separate Funktionen erstellen. Die Vorlagenfunktion kann mit jedem Datentyp verwendet werden, der die Austauschlogik unterstützt.
Um die Funktion zu testen, erstellen wir Variablen des gewünschten Typs und übergeben sie an die generische Swap-Funktion. Der Typinferenzmechanismus in C++ ermöglicht es uns, auf die explizite Angabe des Typs zu verzichten.
Durch die Verwendung von Generika und Vorlagen können wir Codeduplizierungen vermeiden und flexibleren und wiederverwendbaren Code schreiben. Dieser Ansatz ermöglicht es uns, verschiedene Datentypen zu verarbeiten, ohne für jeden Typ separate Funktionen zu erstellen.
Ich hoffe, dieses Video hat Ihnen geholfen, das Konzept von Generika und Vorlagen in C++ zu verstehen. Wenn Sie es nützlich fanden, abonnieren Sie bitte meinen Kanal und geben Sie diesem Video einen Daumen nach oben. Ihre Unterstützung wird sehr geschätzt. Vielen Dank fürs Zuschauen, wir sehen uns in meinem nächsten Video. Auf Wiedersehen!
Lambda-Ausdrücke in modernem C++ (ausführliche Schritt-für-Schritt-Anleitung)
Lambda-Ausdrücke in modernem C++ (ausführliche Schritt-für-Schritt-Anleitung)
Willkommen auf meinem Kanal, alle zusammen! In diesem Video bespreche ich ein wichtiges Thema im modernen C++, nämlich Lambda-Ausdrücke, auch Lambdas genannt. Sie haben wahrscheinlich schon einmal von Lambdas gehört, und heute erkläre ich Ihnen alles, was Sie wissen müssen, um mit Lambdas in modernem C++ schnelleren und saubereren Code zu schreiben.
Ich werde die wichtigsten Konzepte behandeln, aber bedenken Sie, dass Lambdas ein weit gefasstes Thema sind, zu dem es viel zu lernen gibt. Wenn Sie weitere Beispiele und Übungen wünschen, stelle ich in der Beschreibung ein kostenloses Buch zur Verfügung, das sich auf Lambdas in modernem C++ konzentriert. Schauen Sie sich das gerne an.
Lambda-Ausdrücke wurden im modernen C++ eingeführt und sind in C++11 und höher verfügbar. Ihr Hauptzweck besteht darin, Ihnen das Schreiben anonymer Inline-Funktionen zu ermöglichen. Was sind also anonyme Inline-Funktionen? Mit regulären Funktionen können Sie Code einmal schreiben und ihn wiederverwenden, indem Sie die Funktion immer dann aufrufen, wenn Sie diesen Code erneut benötigen, wodurch redundanter Code überflüssig wird. Andererseits ist eine Inline-Funktion eine kleine, einfache Funktion, die nicht für die Wiederverwendung gedacht ist regelmäßige Funktionen. Sie werden häufig für kleine Codeschnipsel verwendet, die keinen Namen erfordern und für die sich die Erstellung einer separaten Funktion nicht lohnt. Hier glänzen Lambdas, da sie eine Möglichkeit bieten, unbenannte Funktionen zu schreiben, die prägnant, leicht zu lesen und schnell auszuführen sind und alles an einem Ort aufbewahren.
Lassen Sie uns nun in den Code eintauchen. Für diese Demonstration verwende ich C++Builder, die ideale IDE zum Erstellen von C++-Benutzeroberflächenanwendungen. Wenn Sie mehr über C++-Benutzeroberflächenanwendungen erfahren möchten, gebe ich in der Beschreibung einen Link an, über den Sie C++Builder herunterladen können. Erstellen wir zunächst eine Konsolenanwendung. Klicken Sie auf „Datei“, dann auf „Neue andere“ und wählen Sie „Konsolenanwendung“. Stellen Sie sicher, dass C++ ausgewählt ist, und klicken Sie auf „OK“. Hier ist unser erster Code. Lassen Sie uns ein paar Ergänzungen vornehmen.
Zuerst füge ich einen „Systempause“-Befehl hinzu, um das Konsolenfenster nach der Ausführung des Codes geöffnet zu halten. Als Nächstes füge ich die „iostream“-Bibliothek für Eingabe-/Ausgabeoperationen hinzu. Jetzt ist unser Code zur Ausführung bereit und wenn wir das Programm ausführen, sehen wir die Meldung „Hello, World!“ Nachricht in der Konsole. Schauen wir uns nun die Struktur eines Lambda-Ausdrucks an. Ich werde den vorherigen Code entfernen und wir beginnen mit einem einfachen Beispiel. Um ein Lambda zu erstellen, verwenden wir die folgende Syntax: spitze Klammern (Capture-Klausel), Klammern (Parameter) und geschweifte Klammern (Funktionsdefinition).
Innerhalb der Capture-Klausel können wir Variablen aus dem umschließenden Bereich angeben, die wir im Lambda verwenden möchten. Lassen wir zunächst die Capture-Klausel leer und konzentrieren uns auf die Parameter. Wir können die Parameter innerhalb der Klammern definieren. In diesem Beispiel verwende ich einen einzelnen Parameter, „p“. Schließlich definieren wir den Funktionskörper des Lambda innerhalb der geschweiften Klammern. Lassen Sie uns nun ein Beispiel erstellen, in dem wir auf ein Problem stoßen und es dann mithilfe von Lambdas lösen. Da wir mit einem Vektor arbeiten, müssen wir die „Vektor“-Bibliothek einbinden. Ich werde einen Vektor aus ganzen Zahlen namens „v“ erstellen und ihn mit einigen Werten initialisieren. Als Nächstes stelle ich eine nützliche Funktion aus der „algorithm“-Bibliothek namens „for_each“ vor. Diese Funktion iteriert über Elemente in einem Bereich, beispielsweise unserem Vektor, und wendet eine bestimmte Funktion auf jedes Element an.
Innerhalb der Funktion „for_each“ geben wir den Bereich mit „v.begin()“ und „v.end()“ an. Definieren wir nun, was wir mit jedem Element machen wollen. Zunächst zeige ich Ihnen ein Problem mit dem Code und stelle dann Lambdas als Lösung vor. Ich habe eine Struktur mit einem überladenen Operator hinzugefügt, der den Parameter ausgibt. Wir erwarten, dass die Funktion „for_each“ alle Elemente im Vektor druckt. Wenn wir den Code ausführen, werden wir feststellen, dass er nicht wie erwartet funktioniert. Es wird nur das letzte Element gedruckt. Dies liegt daran, dass der überladene Operator als Wert übergeben wird und den Parameter bei jedem Aufruf kopiert, was zu einer falschen Ausgabe führt. Um dies zu beheben, können wir den überladenen Operator durch einen Lambda-Ausdruck ersetzen. Ich kopiere die zuvor besprochene Lambda-Ausdruckssyntax und füge sie in die Funktion „for_each“ ein. Jetzt führen wir den Code noch einmal aus.
Wie Sie sehen, funktioniert der Lambda-Ausdruck perfekt und druckt alle Elemente im Vektor. Der Lambda-Ausdruck vereinfacht den Code und verbessert die Lesbarkeit. Es stellt außerdem sicher, dass bei jedem Aufruf der richtige Parameter übergeben wird, wodurch das zuvor aufgetretene Problem vermieden wird. Lassen Sie uns nun eine weitere nützliche Funktion von Lambdas untersuchen, nämlich ihre Fähigkeit, Variablen aus dem umschließenden Bereich zu erfassen. Mit dieser Funktion können Lambdas auf Variablen zugreifen und diese innerhalb des Lambda verwenden. Standardmäßig erfassen Lambdas jedoch Variablen nach Wert, was bedeutet, dass sie eine Kopie der Variablen erstellen.
In unserem nächsten Beispiel erstelle ich eine Variable namens „Multiplikator“ und setze sie auf 2. Innerhalb des Lambda verwende ich diese Variable, um jedes Element im Vektor zu multiplizieren. Dieses Mal verwende ich zu Demonstrationszwecken eine bereichsbasierte for-Schleife anstelle der Funktion „for_each“. Wenn wir den Code ausführen, werden wir sehen, dass die Elemente im Vektor dank der erfassten Variablen mit 2 multipliziert werden. Es gibt jedoch eine Einschränkung bei der Erfassung von Variablen nach Wert. Wir können die erfasste Variable innerhalb des Lambda nicht ändern.
Um diese Einschränkung zu überwinden, können wir die Variable per Referenz erfassen und so ihren Wert ändern. Ich demonstriere dies, indem ich dem Lambda-Ausdruck eine Inkrementierungsoperation hinzufüge. Wenn wir nun den Code ausführen, sehen wir, dass die Elemente im Vektor mit 2 multipliziert und dann um 1 erhöht werden. Das Erfassen von Variablen aus dem umschließenden Bereich bietet Flexibilität und ermöglicht Lambdas die nahtlose Arbeit mit externen Daten. Es ist wichtig zu bedenken, dass die Erfassung von Variablen durch Referenz Auswirkungen haben kann, beispielsweise auf die Lebensdauerverwaltung und potenzielle Datenrennen. Seien Sie also vorsichtig, wenn Sie diese Funktion verwenden, und stellen Sie sicher, dass die erfasste Variable während der Lambda-Ausführung gültig bleibt.
Zusammenfassend lässt sich sagen, dass Lambda-Ausdrücke in modernem C++ leistungsstarke Werkzeuge zum Schreiben prägnanter und lesbarer Codes sind. Sie ermöglichen die Erstellung anonymer Inline-Funktionen und reduzieren so den Bedarf an separaten Funktionen für kleine Codefragmente. Lambdas können auch über ihren umschließenden Bereich auf Variablen zugreifen, was für Flexibilität sorgt und die Wiederverwendung von Code verbessert.
Ich hoffe, dass Sie dieses Video hilfreich fanden, um Lambda-Ausdrücke in modernem C++ zu verstehen. Wenn Sie Fragen haben, können Sie diese gerne in den Kommentaren unten stellen. Vergessen Sie nicht, dieses Video zu liken und meinen Kanal zu abonnieren, um weitere C++-Tutorials zu erhalten. Vielen Dank fürs Zuschauen und viel Spaß beim Codieren!
Visual Studio-Tipps und Tricks für Profis – Visual Studio-Tutorial
Visual Studio-Tipps und Tricks für Profis – Visual Studio-Tutorial
Hallo an alle! Mein Name ist Leslie Richardson und ich arbeite als Programmmanager im Visual Studio-Debugging- und Diagnoseteam. Ich freue mich, in diesem Video eine neue Funktion in Visual Studio 2019 zu besprechen, die Suchfunktion für automatische, lokale und Überwachungsfenster. Diese Funktion wurde entwickelt, um Ihr Debugging-Erlebnis erheblich zu verbessern, Ihnen wertvolle Zeit zu sparen und Ihre Produktivität zu steigern.
Um diese Funktion zu demonstrieren, betrachten wir ein Szenario, in dem ich eine .NET Core-Anwendung in Visual Studio 2019 geöffnet habe. In dieser Anwendung habe ich eine Liste, die mehrere Rezeptobjekte enthält. Die Herausforderung, vor der ich stehe, besteht darin, bestimmte Rezepte in dieser Liste zu finden, was ziemlich mühsam sein kann, insbesondere wenn die Liste 61 Objekte enthält. Jedes Objekt manuell zu erweitern, die Titeleigenschaft zu finden und zu prüfen, ob es meinen Suchkriterien, wie zum Beispiel „Salat“, entspricht, ist eine zeitaufwändige Aufgabe.
Um diesen Prozess zu vereinfachen, verwende ich eine Funktion namens „Debugger Display“. Mit dieser Funktion kann ich anpassen, wie Objekte in verschiedenen Debugger-Fenstern angezeigt werden, einschließlich automatischer, lokaler und Überwachungsfenster. Durch das Hinzufügen des Attributs „Debugger Display“ zur Klassendefinition meiner Objekte kann ich angeben, welche Eigenschaft in der Wertespalte dieser Fenster angezeigt werden soll. In diesem Fall möchte ich jedes Rezept nach seinem Titel anzeigen, also stelle ich das Attribut „Debugger-Anzeige“ so ein, dass die Rezepttiteleigenschaft angezeigt wird.
Wenn ich jetzt die Rezeptliste erneut erweitere, kann ich sofort den Titel jedes Objekts sehen, was es viel einfacher macht, die gewünschten Rezepte zu finden, ohne jedes einzelne einzeln zu erweitern. Das ist eine deutliche Verbesserung, aber bei 61 Einträgen kann es immer noch einige Zeit dauern, die spezifischen Rezepte zu finden, die mich interessieren. Hier erweist sich die Suchfunktion für das Überwachungsfenster als nützlich.
Anstatt manuell zu scrollen oder die Liste zu erweitern, kann ich einfach die bereitgestellte Suchfunktion nutzen. Ich gebe meinen Suchbegriff ein, beispielsweise „Salat“, und drücke die Eingabetaste. Visual Studio führt mich sofort zum ersten Vorkommen des Schlüsselworts und spart mir so viel Zeit und Mühe. Ich kann auch die Schaltfläche „Weitersuchen“ verwenden, um durch andere von Visual Studio gefundene Übereinstimmungen zu navigieren. Um durch die Trefferliste vorwärts und rückwärts zu navigieren, kann ich den Suchschrittparameter anpassen, der die Tiefe der Suche bestimmt.
Zusätzlich zur Suchfunktion möchte ich auch erwähnen, dass die Debugger-Anzeigefunktion für Benutzer von verwaltetem Code verfügbar ist, beispielsweise für diejenigen, die C#, F# oder Visual Basic verwenden. Für C++-Benutzer steht eine entsprechende Funktion namens NATVIS zur Verfügung. Mit NATVIS müssen Sie eine separate XML-Datei erstellen, in der Sie Eigenschaften definieren können, die in den Debugger-Fenstern angezeigt werden sollen.
Ich hoffe, diese Erklärung war hilfreich. Vielen Dank fürs Zuschauen!
Lassen Sie uns nun untersuchen, wie wir die Benutzeroberfläche von Visual Studio besser organisieren und ihre Leistung verbessern können. Wenn wir Lösungen in Visual Studio öffnen, merkt es sich den Status von Dokumenten, Bildlaufpositionen und erweiterten/reduzierten Abschnitten im Projektmappen-Explorer seit unserer letzten Verwendung. Dies kann zwar nützlich sein, verbraucht aber auch CPU-Zyklen und ist möglicherweise nicht immer wünschenswert. Um neu anzufangen und die Leistung zu verbessern, können wir einige Einstellungen ändern.
Im Menü „Extras“ > „Optionen“ im Abschnitt „Projekte und Lösungen“ sind zwei Einstellungen zu berücksichtigen. Die Option „Dokumente beim Laden der Lösung erneut öffnen“ merkt sich die zuvor geöffneten Dokumente, und die Option „Status der Projekthierarchie des Lösungs-Explorers beim Laden der Lösung wiederherstellen“ merkt sich den erweiterten/reduzierten Zustand des Lösungs-Explorers. Durch Deaktivieren dieser Optionen stellt Visual Studio beim Öffnen einer Lösung den vorherigen Status nicht wieder her. Stattdessen beginnt es ganz neu, ohne geöffnete Dokumente oder erweiterte Abschnitte im Projektmappen-Explorer. Dies kann dazu beitragen, die Leistung zu verbessern und für jede Lösung einen Neuanfang zu ermöglichen.
Bei der Arbeit mit Git in Visual Studio gibt es mehrere Funktionen, die Ihre Produktivität und Zusammenarbeit verbessern können. Das Fenster „Git-Änderungen“ bietet eine umfassende Ansicht Ihres Git-Repositorys und ermöglicht Ihnen das Bereitstellen, Festschreiben und Übertragen von Änderungen direkt in Visual Studio. Sie können auf dieses Fenster zugreifen, indem Sie auf „Ansicht“ > „Git-Änderungen“ gehen. Darüber hinaus bietet Visual Studio ein integriertes Git-Diff-Tool, das die Unterschiede zwischen verschiedenen Versionen Ihres Codes hervorhebt. Sie können auf diese Funktion zugreifen, indem Sie im Projektmappen-Explorer mit der rechten Maustaste auf eine Datei klicken und „Mit unveränderter Datei vergleichen“ oder „Mit neuester Datei vergleichen“ auswählen.
Eine weitere nützliche Funktion in Visual Studio ist die Möglichkeit, Code umzugestalten. Refactoring trägt dazu bei, die Struktur und Lesbarkeit Ihres Codes zu verbessern, ohne sein Verhalten zu ändern. Visual Studio bietet eine Vielzahl von Refactoring-Optionen, z. B. das Umbenennen von Variablen oder Methoden, das Extrahieren von Code in separate Methoden oder Klassen und das Neuorganisieren von Codeblöcken. Um auf diese Refactoring-Optionen zuzugreifen, klicken Sie mit der rechten Maustaste auf den Code, den Sie umgestalten möchten, und wählen Sie „Refactor“ aus dem Kontextmenü. Sie können auch Tastaturkürzel für gängige Refactoring-Vorgänge verwenden, z. B. Strg + R, Strg + R, um ein Symbol umzubenennen.
Um Ihr Programmiererlebnis noch weiter zu verbessern, können Sie Codeausschnitte in Visual Studio nutzen. Codeausschnitte sind vordefinierte Codevorlagen, die Sie schnell in Ihren Code einfügen können, indem Sie eine Tastenkombination eingeben und die Tab-Taste drücken. Visual Studio bietet eine breite Palette integrierter Codefragmente für verschiedene Programmiersprachen und Frameworks. Sie können auch Ihre eigenen benutzerdefinierten Code-Snippets erstellen, um sich wiederholende Codierungsaufgaben zu automatisieren. Um auf Code-Snippets zuzugreifen und diese zu verwalten, gehen Sie zu Tools > Code-Snippets-Manager.
Das Debuggen ist ein wesentlicher Bestandteil des Entwicklungsprozesses und Visual Studio bietet leistungsstarke Debugging-Funktionen. Sie können in Ihrem Code Haltepunkte festlegen, um die Ausführung anzuhalten und den Status von Variablen und Objekten zu überprüfen. Während des Debuggens können Sie das Überwachungsfenster verwenden, um die Werte bestimmter Variablen oder Ausdrücke zu überwachen. Im Direktfenster können Sie beim Debuggen Code ausführen und Ausdrücke auswerten. Sie können auch bedingte Haltepunkte nutzen, die nur ausgelöst werden, wenn eine bestimmte Bedingung erfüllt ist, und Tracepoints, die Meldungen im Ausgabefenster ausgeben, ohne den Debugger anzuhalten.
Visual Studio unterstützt auch Unit-Tests, die für die Sicherstellung der Qualität und Korrektheit Ihres Codes von entscheidender Bedeutung sind. Sie können Unit-Tests mit verschiedenen Test-Frameworks wie MSTest, NUnit oder xUnit erstellen. Visual Studio bietet ein Test-Explorer-Fenster, das alle verfügbaren Tests in Ihrer Lösung anzeigt und es Ihnen ermöglicht, sie einzeln oder in Gruppen auszuführen oder zu debuggen. Mithilfe von Attributen können Sie Testmethoden und Behauptungen definieren, um die erwarteten Ergebnisse zu überprüfen. Visual Studio bietet auch eine Codeabdeckungsanalyse, die Ihnen zeigt, wie viel Ihres Codes durch Komponententests abgedeckt wird.
Bei der Arbeit mit großen Projekten oder Lösungen kann es schwierig sein, sich in der Codebasis zurechtzufinden und sie zu verstehen. Visual Studio bietet mehrere Funktionen zur Unterstützung der Codenavigation und des Codeverständnisses. Mit dem Solution Explorer können Sie die Struktur Ihrer Lösung erkunden und schnell zu bestimmten Dateien oder Klassen navigieren. Sie können auch die Funktion „Navigieren zu“ (Strg + ,) verwenden, um in Ihrer Lösung nach Symbolen, Dateien oder Typen zu suchen. Die CodeLens-Funktion zeigt zusätzliche Informationen zu Ihrem Code, wie Referenzen, Änderungen und Testabdeckung, direkt im Editor an.
Für die Webentwicklung bietet Visual Studio hervorragende Unterstützung für gängige Webtechnologien wie HTML, CSS und JavaScript. Der HTML-Editor bietet Funktionen wie IntelliSense, Codeformatierung und die Möglichkeit, eine Vorschau Ihrer HTML-Seiten direkt im Editor anzuzeigen. Der CSS-Editor bietet ähnliche Funktionen, darunter Farbauswahl, IntelliSense für CSS-Eigenschaften und Live-Vorschau von CSS-Änderungen. Visual Studio unterstützt auch das JavaScript-Debugging, sodass Sie Haltepunkte festlegen, Variablen überprüfen und Ihren Code schrittweise durchgehen können, um Probleme zu identifizieren und zu beheben.
Visual Studio verfügt über ein umfangreiches Ökosystem an Erweiterungen und Plugins, die Ihr Entwicklungserlebnis verbessern können. Diese Erweiterungen bieten zusätzliche Funktionalität, Sprachunterstützung und Tools für bestimmte Frameworks oder Plattformen. Sie können Erweiterungen direkt in Visual Studio durchsuchen und installieren, indem Sie zu Erweiterungen > Erweiterungen verwalten gehen. Zu den beliebten Erweiterungen gehören ReSharper, das erweiterte Code-Analyse- und Refactoring-Tools bietet, und Visual Studio Code, das einen kompakten, plattformübergreifenden Code-Editor bietet.
Bei der Arbeit an kollaborativen Projekten bietet Visual Studio die Integration mit Kollaborationsplattformen wie Azure DevOps und GitHub. Sie können Ihr Visual Studio-Projekt ganz einfach mit einem Remote-Git-Repository verbinden und gängige Git-Vorgänge wie Pushen, Pullen und Zusammenführen von Änderungen ausführen. Visual Studio bietet außerdem Tools für Codeüberprüfungen, Arbeitselementverfolgung sowie kontinuierliche Integrations- und Bereitstellungsworkflows.
Visual Studio unterstützt eine Vielzahl von Programmiersprachen und Frameworks, darunter .NET, C++, Python, JavaScript und viele mehr. Es bietet sprachspezifische Funktionen wie IntelliSense, Codeausschnitte und Debugging-Funktionen, die auf jede Sprache zugeschnitten sind. Sie können sprachspezifische Erweiterungen und SDKs installieren, um das Entwicklungserlebnis für Ihre bevorzugten Programmiersprachen weiter zu verbessern.
Zur Leistungsoptimierung und Fehlerbehebung bietet Visual Studio Profilierungstools, mit denen Sie Engpässe und Speicherverluste in Ihren Anwendungen identifizieren können. Mit dem Performance Profiler können Sie die Leistung Ihres Codes analysieren und Bereiche identifizieren, die optimiert werden können. Der Memory Profiler hilft Ihnen, speicherbezogene Probleme in Ihren Anwendungen zu erkennen und zu diagnostizieren. Diese Profilierungstools bieten detaillierte Berichte und Einblicke, die Ihnen bei der Optimierung Ihres Codes und der Verbesserung der Anwendungsleistung helfen.
Visual Studio bietet außerdem Unterstützung für die Entwicklung mobiler Apps für Plattformen wie Android und iOS. Mit Frameworks wie Xamarin oder React Native können Sie plattformübergreifende mobile Apps erstellen. Visual Studio bietet Tools zum Entwerfen von Benutzeroberflächen, zum Debuggen mobiler Apps und zum Bereitstellen dieser auf Emulatoren oder physischen Geräten. Sie können auch Cloud-Dienste wie Azure Mobile Apps für die Backend-Integration und -Speicherung nutzen.
Zusätzlich zu herkömmlichen Desktop- und Webanwendungen unterstützt Visual Studio die Entwicklung von Internet-of-Things-Anwendungen (IoT). Mit Visual Studio können Sie Anwendungen für Geräte wie Raspberry Pi, Arduino und andere IoT-Geräte erstellen. Die IoT-Entwicklungstools von Visual Studio bieten Projektvorlagen, Debugging-Unterstützung und Bereitstellungsoptionen für IoT-Szenarien.
Visual Studio bietet auch Cloud-Entwicklungsfunktionen mit Integrationen für beliebte Cloud-Plattformen wie Azure. Sie können Cloud-Ressourcen direkt in Visual Studio erstellen, verwalten und bereitstellen. Es bietet Tools zum Erstellen und Bereitstellen von Cloud-Anwendungen, zur Integration in Cloud-Dienste und zur Überwachung Ihrer Cloud-Ressourcen.
Dies sind nur einige der vielen Features und Möglichkeiten, die Visual Studio Entwicklern bietet. Es handelt sich um eine leistungsstarke und vielseitige IDE, die eine Vielzahl von Entwicklungsanforderungen und Arbeitsabläufen abdecken kann. Unabhängig davon, ob Sie an kleinen Projekten oder großen Unternehmenslösungen arbeiten, bietet Visual Studio die Tools und Funktionen, mit denen Sie Ihren Entwicklungsprozess optimieren und Ihre Produktivität steigern können.
Code-vollständiger EA für MetaTrader 5 in 20 Minuten!
Code-vollständiger EA für MetaTrader 5 in 20 Minuten!
Heute freuen wir uns, mit der Aufnahme unseres ersten EA (Expert Advisor) für die Handelsplattform MetaTrader zu beginnen. Dieser EA ist als Handelssystem für MetaTrader konzipiert und in unserem Video werden wir auch einen kurzen Backtest durchführen, um seine Leistung zu bewerten.
Zunächst starten wir die MetaTrader-Plattform und greifen auf den MetaEditor zu, indem wir auf „Tools“ klicken und im Dropdown-Menü „MetaQuotes Language Editor“ auswählen. Im MetaEditor erstellen wir unsere Expertenberater sowie Skripte und Indikatoren für MetaTrader.
Um einen neuen Expert Advisor zu erstellen, klicken wir auf die Schaltfläche „Neu“ oben links im MetaEditor. Im erscheinenden Assistenten wählen wir die erste Option und klicken auf „Weiter“. Anschließend können wir unserem EA einen Namen geben, beispielsweise „Erster EA“, und erneut auf „Weiter“ klicken. Wir überspringen die Auswahl weiterer Optionen und fahren mit einem Klick auf „Fertig stellen“ fort.
Jetzt haben wir den ersten Code für unseren EA. Zunächst bereinigen wir den Code, indem wir unnötige Kommentare entfernen, beispielsweise die grauen Kommentare, die dem Code selbst keine Funktionalität bieten. Wir löschen die ersten fünf Zeilen und einige andere unnötige Zeilen nach unserem Wunsch.
Bevor wir mit dem Codieren beginnen, nehmen wir uns einen Moment Zeit und überlegen, was unser EA tun soll. Unser Ziel für dieses Video ist es, dass der EA zu einem bestimmten Zeitpunkt einen Kaufhandel eröffnet und ihn zu einer anderen vorher festgelegten Tageszeit schließt. Um dies zu erreichen, benötigen wir zwei Eingabevariablen: eine für die Öffnungszeit und eine andere für die Schließzeit.
Zurück zum MetaEditor deklarieren wir diese beiden Eingabevariablen in einem neuen Abschnitt namens „Variablen“. Wir verwenden das Schlüsselwort „input“, um anzugeben, dass diese Variablen von außerhalb des Codes geändert werden können. Wir legen ihre Typen als Ganzzahlen fest, da wir bestimmte Stundenwerte eingeben möchten. Beispielsweise können wir die Variablen „openHour“ und „closeHour“ benennen.
Nach der Deklaration der Variablen kompilieren wir den Code, um sicherzustellen, dass keine Fehler vorliegen. Wenn alles korrekt ist, können wir sehen, dass in der Toolbox keine Fehlermeldungen vorhanden sind.
Als nächstes wechseln wir zurück zur MetaTrader-Plattform und ziehen unseren EA auf einen beliebigen Chart. Wir können den Namen, die Version und den Link des EA im Navigator unter „Expert Advisors“ sehen. Durch die Erweiterung des EA können wir auf die Eingabevariablen zugreifen und ihre Werte ändern, ohne den Code zu ändern.
Kommen wir nun zur Funktion „OnTick“, die bei jeder Preisänderung aufgerufen wird. Wir wollen prüfen, ob wir die vom Benutzer angegebene Öffnungszeit erreicht haben. Dazu müssen wir die aktuelle Zeit des Symbols und des Servers abrufen. Wir erstellen eine Variable namens „time“ vom Typ „datetime“ und weisen ihr mit der Funktion „TimeCurrent“ die aktuelle Uhrzeit zu.
Mit der aktuellen Zeit, die in unserer Variablen „time“ gespeichert ist, können wir nun prüfen, ob sie mit der offenen Zeit übereinstimmt. Wir verwenden eine „if“-Anweisung, um die Variable „openHour“ mit der Stundenkomponente der aktuellen Zeit („time.hour“) zu vergleichen. Wenn die Bedingung wahr ist, betreten wir den „if“-Block.
Innerhalb des „if“-Blocks eröffnen wir eine Position mit der Funktion „OrderSend“. Als Parameter geben wir das Symbol, die Handelsrichtung (Kauf), die Lotgröße (1 Lot) und den Briefkurs an. Darüber hinaus legen wir die Stop-Loss- und Take-Profit-Werte nach unseren Wünschen fest.
Nachdem wir den Code kompiliert und einen Backtest mit dem MetaTrader-Strategietester durchgeführt haben, stellen wir fest, dass der EA zum angegebenen Öffnungszeitpunkt eine Position eröffnet. Wir stellen jedoch fest, dass aufgrund nachfolgender Preisbewegungen mehrere Positionen eröffnet werden und die „OnTick“-Funktion erneut ausgelöst wird.
Um zu verhindern, dass mehrere Positionen eröffnet werden, führen wir eine boolesche Variable namens „isTradeOpen“ ein, um zu verfolgen, ob ein Trade bereits offen ist. Zunächst setzen wir den Wert von „isTradeOpen“ auf false. Bevor wir eine neue Position eröffnen, prüfen wir, ob „isTradeOpen“ falsch ist. Wenn dies der Fall ist, öffnen wir die Position und setzen den Wert von „isTradeOpen“ auf „true“. Selbst wenn die „OnTick“-Funktion mehrmals ausgelöst wird, wird auf diese Weise nur dann eine neue Position eröffnet, wenn noch kein offener Trade besteht.
Nachdem wir diese Logik implementiert haben, kompilieren wir den Code erneut und führen einen Backtest durch. Dieses Mal beobachten wir, dass der EA eine Position zum angegebenen Öffnungszeitpunkt eröffnet und keine weiteren Positionen eröffnet, bis die vorherige geschlossen wird.
Um den Handel zum angegebenen Schlusszeitpunkt zu schließen, müssen wir eine weitere Prüfung in der Funktion „OnTick“ einführen. Nach dem Öffnen der Position vergleichen wir die aktuelle Zeit mit der vom Benutzer angegebenen Schlusszeit. Wenn sie übereinstimmen, geben wir einen „Wenn“-Block ein.
Innerhalb des „if“-Blocks schließen wir den Handel mit der Funktion „OrderClose“. Als Parameter stellen wir die Ticketnummer der zu schließenden Position sowie die Losgröße und den Geldkurs zur Verfügung. Darüber hinaus können wir auf Wunsch zusätzliche Parameter wie Stop-Loss- und Take-Profit-Werte festlegen.
Wir kompilieren den Code erneut und führen einen Backtest durch, um zu überprüfen, ob der Handel zum angegebenen Schlusszeitpunkt geschlossen wird. Während des Backtests können wir die Handelshistorie überprüfen, um sicherzustellen, dass die Positionen zu den angegebenen Zeiten geöffnet und geschlossen werden.
Wir haben unseren ersten EA für die Handelsplattform MetaTrader erfolgreich erstellt. Der EA ist darauf ausgelegt, einen Kaufhandel zu einem bestimmten Eröffnungszeitpunkt zu eröffnen und ihn zu einem vorher festgelegten Schlusszeitpunkt zu schließen. Wir haben Eingabevariablen implementiert, um die Anpassung der Öffnungs- und Schließzeiten zu ermöglichen, ohne den Code zu ändern. Durch die Einführung von Prüfungen und Variablen stellen wir sicher, dass jeweils nur ein Trade geöffnet und zum angegebenen Schlusszeitpunkt geschlossen wird.
Moving Average Crossover EA mql5 Programmierung
Moving Average Crossover EA mql5 Programmierung
Hallo, das ist Toby, und im heutigen Video zeige ich Ihnen, wie Sie einen einfachen Crossover-Expertenberater für gleitende Durchschnitte für MetaTrader 5 programmieren. Fangen wir an.
Definieren wir zunächst, was der Fachberater tun soll. Wir möchten, dass der EA eine Kaufposition eröffnet, wenn der schnell gleitende Durchschnitt (blaue Linie) den langsam gleitenden Durchschnitt (rote Linie) überschreitet, und eine Verkaufsposition eröffnet, wenn der schnell gleitende Durchschnitt den langsam gleitenden Durchschnitt unterschreitet. Wir fügen dem EA außerdem einen Stop-Loss und Take-Profit sowie Eingabevariablen für die Zeiträume der gleitenden Durchschnitte hinzu.
Um mit dem Codieren zu beginnen, öffnen Sie den MetaEditor in MetaTrader 5. Erstellen Sie mithilfe der Vorlage einen neuen Expert Advisor und nennen Sie ihn „Moving Average“. Bereinigen Sie den Code, indem Sie unnötige Zeilen und Kommentare entfernen. Fügen Sie als Nächstes Eingabevariablen für die Zeiträume der schnellen und langsamen gleitenden Durchschnitte hinzu. Legen Sie Standardwerte für diese Variablen fest und zeigen Sie sie im Eingaberegister der EA-Einstellungen an.
Überprüfen Sie die Benutzereingaben in der OnInit-Funktion, um sicherzustellen, dass gültige Werte eingegeben werden. Wenn die Eingabe ungültig ist (null oder negativ), zeigen Sie eine Warnmeldung an und stoppen Sie den EA. Erstellen Sie mithilfe der ma-Funktion Handles für die schnellen und langsamen gleitenden Durchschnitte. Legen Sie das Symbol, die Periode und die Eingabevariablen für jeden gleitenden Durchschnitt fest. Überprüfen Sie, ob die Erstellung der Handles erfolgreich war. Wenn nicht, zeigen Sie eine Warnmeldung an und stoppen Sie den EA. Erstellen Sie globale Variablen zum Speichern der Indikatorwerte. Verwenden Sie dynamische Arrays für die schnellen und langsamen Puffer. Kopieren Sie in der OnTick-Funktion die neuesten Indikatorwerte in die Puffer und prüfen Sie, ob genügend Daten verfügbar sind. Wenn nicht, kehren Sie zurück und zeigen Sie eine Warnmeldung an.
Drucken Sie die Anzeigewerte auf dem Bildschirm aus, um zu überprüfen, ob alles ordnungsgemäß funktioniert. Verwenden Sie die Kommentarfunktion, um die Werte der schnellen und langsamen gleitenden Durchschnitte anzuzeigen.
Testen Sie im Strategietester den EA, um zu überprüfen, ob die Indikatorwerte korrekt angezeigt werden. Jetzt können wir prüfen, ob sich die gleitenden Durchschnitte kreuzen. Wenn der schnell gleitende Durchschnitt bei Balken 1 unter dem langsam gleitenden Durchschnitt und bei Balken 0 über dem langsam gleitenden Durchschnitt liegt, liegt ein Crossover vor. Eröffnen Sie in diesem Fall eine Kaufposition.
Um Positionen zu eröffnen, verwenden Sie die CTrade-Klasse. Definieren Sie eine Handelsvariable und fahren Sie mit den erforderlichen Aktionen fort. Kompilieren Sie den Code und testen Sie den EA im Strategietester, um zu überprüfen, ob die Crossover-Bedingung korrekt funktioniert und Positionen entsprechend geöffnet werden.
Das ist alles für die Kodierung des Expert Advisors für gleitende Durchschnitts-Crossovers in MetaTrader 5. Und dann können wir die Funktion „trade.Buy“ verwenden, um eine Kaufposition zu eröffnen. Wir legen das Volumen der Position fest, das als Festwert oder auf Basis Ihrer Risikomanagementstrategie erfolgen kann. Lassen Sie uns zunächst ein festes Volumen von 0,1 Lots verwenden. Jetzt müssen wir eine Bedingung hinzufügen, um zu prüfen, ob eine Verkaufsposition vorliegt. Wenn der schnell gleitende Durchschnitt für Balken 1 über dem langsam gleitenden Durchschnitt und für den aktuellen Balken darunter liegt, liegt ein Crossover in die entgegengesetzte Richtung vor. In diesem Fall möchten wir eine Verkaufsposition eröffnen. Dazu können wir die Funktion „trade.Sell“ verwenden.
Schließlich können wir unseren Positionen einen Stop-Loss und Gewinnmitnahmen hinzufügen. Wir verwenden die Funktionen trade.SetStopLoss und trade.SetTakeProfit. Für dieses Beispiel legen wir einen Stop-Loss von 100 Pips und eine Gewinnmitnahme von 200 Pips fest. Jetzt haben wir einen vollständigen Code für unseren einfachen Crossover-Expertenberater für gleitende Durchschnitte. Wir können es kompilieren und auf der MetaTrader 5-Plattform testen.
Sobald Sie den Code fehlerfrei kompiliert haben, können Sie den Expert Advisor speichern und in MetaTrader 5 verwenden. Denken Sie daran, Ihren Expert Advisor erneut zu testen und zu optimieren, bevor Sie ihn mit echtem Geld verwenden.
Range Breakout EA mql5 Programmierung | Teil 1/4
Range Breakout EA mql5 Programmierung | Teil 1/4
Hallo, das ist Toby, und im heutigen Video zeige ich Ihnen, wie Sie einen Time Range Breakout Expert Advisor (EA) für MetaTrader 5 programmieren. Das Ziel besteht darin, ähnliche Ergebnisse wie die im Video gezeigte Strategie zu erzielen.
Lassen Sie uns zunächst die Logik hinter dem EA besprechen. Wir definieren einen einfachen Zeitbereich, der zu einem bestimmten Zeitpunkt beginnt und zu einem anderen Zeitpunkt endet. Der EA speichert die höchsten und niedrigsten Preise innerhalb dieser Spanne. Wenn der Preis den höchsten Preis nach der Spanne überschreitet, geht der EA einen Kaufhandel ein. Wenn der Preis hingegen unter die Spanne fällt, geht der EA einen Verkaufshandel ein. Darüber hinaus legen wir eine Schließzeit fest, um alle Positionen zu schließen. Diese einfache Logik wird unseren EA leiten.
Um mit dem Codieren zu beginnen, öffnen Sie MetaEditor und erstellen Sie einen neuen Expert Advisor. Bereinigen Sie den Vorlagencode nach Ihren persönlichen Vorlieben und entfernen Sie unnötige Zeilen.
Als nächstes definieren Sie Eingabevariablen für die Startzeit, die Bereichsdauer, die Schlusszeit, die Losgröße und die magische Zahl. Mithilfe dieser Eingaben können Benutzer das Verhalten des EA anpassen. Es ist wichtig, die Eingabewerte zu überprüfen, um Fehleingaben zu vermeiden. Beispielsweise können wir sicherstellen, dass die magische Zahl nicht Null oder negativ ist, die Lots nicht negativ sind, die Startzeit und die Dauer innerhalb gültiger Bereiche liegen und die Schlusszeit nicht gleich der Startzeit plus der Bereichsdauer ist.
Nachdem wir die Eingabevariablen definiert und ihre Werte überprüft haben, fahren wir mit der Erstellung globaler Variablen fort. Diese Variablen werden im gesamten EA verwendet. Wir gruppieren Variablen, die sich auf den Bereich beziehen, in einer Struktur namens „Bereichsstruktur“. Diese Struktur enthält Variablen für die Startzeit, Endzeit, Schlusszeit, Höchst- und Tiefstkurse sowie Flags für Einstieg, Hoch- und Tiefstausbruch.
Zusätzlich definieren wir den Konstruktor der Struktur, in dem wir die Anfangswerte für die Variablen vorgeben. Dies hilft, die Struktur mit Standardwerten zu initialisieren. Außerdem fügen wir nach jeder Variable Kommentare hinzu, um ihren Zweck zu beschreiben.
Wir kompilieren den Code, um ihn auf Fehler zu prüfen und sicherzustellen, dass alles ordnungsgemäß funktioniert.
Abschließend erstellen wir noch ein paar weitere Variablen, wie zum Beispiel „MqlTick“ und „last_tick“ vom MetaTrader 5-Typ „MqlTick“. Wir definieren außerdem eine Variable vom Typ „CTrade“, um handelsbezogene Vorgänge abzuwickeln.
Zu diesem Zeitpunkt haben wir die notwendigen Variablen und Strukturen für unseren EA eingerichtet. Im nächsten Teil werden wir uns mit der Codierung der eigentlichen Logik des EA in der Funktion „OnTick“ befassen. Im nächsten Teil des Videos konzentrieren wir uns auf die Codierung der eigentlichen Logik des Expert Advisors in der OnTick-Funktion. Bevor wir jedoch fortfahren, schauen wir uns zunächst an, was wir bisher getan haben.
Wir begannen mit der Definition der Eingabevariablen für den EA, wie z. B. der Startzeit des Bereichs, der Dauer, der Schlusszeit, der Losgröße und der magischen Zahl. Wir haben auch Eingabevalidierungsprüfungen hinzugefügt, um sicherzustellen, dass der Benutzer gültige Werte für diese Eingaben eingibt. Als Nächstes haben wir eine Struktur namens „rangeStructure“ erstellt, um die mit dem Bereich verbundenen Variablen zu speichern, einschließlich Startzeit, Endzeit, Schlusszeit, Hoch und Tief des Bereichs sowie Flags für den Einstieg, den oberen und unteren Ausbruch. Anschließend haben wir einen Konstruktor für die RangeStructure definiert, um die Variablen mit Standardwerten zu initialisieren. Darüber hinaus haben wir einige globale Variablen deklariert, darunter eine Instanz der rangeStructure, zwei Variablen vom Typ MqlTick zum Speichern der aktuellen und vorherigen Ticks und ein CTrade-Objekt zur Abwicklung von Handelsoperationen.
Kommen wir nun zur Implementierung der OnTick-Funktion, um die Hauptlogik des EA zu codieren. Hier ist die Fortsetzung des Videos: In der OnTick-Funktion aktualisieren wir zunächst die aktuellen Tick-Informationen mithilfe der SymbolInfoTick-Funktion. Dies ermöglicht uns den Zugriff auf die Geld- und Briefkurse sowie den Zeitpunkt des Ticks. Als nächstes prüfen wir, ob die aktuelle Tick-Zeit innerhalb des vom Benutzer definierten Bereichs liegt. Dazu vergleichen wir die aktuelle Tickzeit mit der Startzeit und Endzeit der Range. Wenn die Tick-Zeit innerhalb des Bereichs liegt, setzen wir den flagEntry auf true, um anzuzeigen, dass wir uns innerhalb des Bereichs befinden.
Danach prüfen wir, ob ein hoher Ausbruch vorliegt. Wenn der aktuelle Tick-Preis das vorherige Hoch der Spanne überschreitet und das FlagHighBreakout falsch ist, initiieren wir einen Kaufhandel. Wir setzen das flagHighBreakout auf true, um wiederholte Einträge zu vermeiden. Ebenso prüfen wir, ob ein niedriger Ausbruch vorliegt. Wenn der aktuelle Tick-Preis unter das vorherige Tief der Spanne fällt und das FlagLowBreakout falsch ist, initiieren wir einen Verkaufshandel. Wir setzen das flagLowBreakout auf true, um Mehrfacheinträge zu verhindern. Abschließend prüfen wir, ob die aktuelle Tick-Zeit mit der Schlusszeit übereinstimmt. Wenn ja, schließen wir alle offenen Positionen mit der Methode trade.CloseAll.
Das ist die Grundlogik des EA. Natürlich gibt es zusätzliche Elemente, die Sie hinzufügen können, um die Funktionalität zu erweitern, wie z. B. Stop-Loss- und Take-Profit-Level, Geldverwaltungsregeln und zusätzliche Handelsfilter. In diesem Video haben wir uns jedoch auf das Kernkonzept der Time-Range-Breakout-Strategie konzentriert.
Denken Sie daran, dass dieser EA als Ausgangspunkt dienen soll und Sie ihn entsprechend Ihren Anforderungen und Handelspräferenzen weiter anpassen können.
Im nächsten Teil des Videos werden wir mit dem Codierungsprozess fortfahren und den notwendigen Code hinzufügen, um die besprochene Logik zu implementieren. Wenn Sie dieses Video hilfreich fanden, vergessen Sie nicht, ein „Gefällt mir“ zu hinterlassen und meinen Kanal zu abonnieren, um über zukünftige Videos auf dem Laufenden zu bleiben. Wenn Sie Fragen haben oder Hilfe benötigen, hinterlassen Sie gerne einen Kommentar, ich helfe Ihnen gerne weiter. Vielen Dank fürs Zuschauen, wir sehen uns im nächsten Video. Tschüss!
Range Breakout EA mql5 Programmierung| Teil 2/4
Range Breakout EA mql5 Programmierung| Teil 2/4
Hallo, das ist Toby, und im heutigen Video werden wir mit der Codierung unseres Zeitbereichs-Breakout-EA für MetaTrader 5 fortfahren. Wenn Sie das erste Video noch nicht gesehen haben, finden Sie den Link hier. Im vorherigen Video habe ich die Logik des EA erklärt und was wir zu codieren versuchen.
Wechseln wir nun zum MetaEditor und setzen wir die Codierung fort. Wir werden an der OnTick-Funktion arbeiten, die jedes Mal aufgerufen wird, wenn sich der Preis für unser Symbol ändert. In dieser Funktion codieren wir unsere Range-Berechnung und den Breakout-Check. Zuerst müssen wir den aktuellen Tick für das Symbol ermitteln. Wir speichern den aktuellen Tick in einer Variablen namens currentTick, und wir haben auch eine Variable previousTick, um den vorherigen Tick zu speichern.
Als nächstes prüfen wir, ob wir einen neuen Bereich berechnen müssen. Es gibt mehrere Bedingungen für die Berechnung eines neuen Bereichs.
Wenn wir eine Range-Close-Zeit festgelegt haben und die aktuelle Tick-Zeit größer oder gleich der Range-Close-Zeit ist, berechnen wir eine neue Range.
Wenn sowohl das High-Breakout- als auch das Low-Breakout-Flag auf „true“ gesetzt sind, berechnen wir einen neuen Bereich.
Wenn es das erste Mal ist, dass der EA ausgeführt wird und wir noch keinen Bereich berechnet haben, berechnen wir einen neuen Bereich.
Wenn die Endzeit des Bereichs nicht Null ist und wir uns hinter dem Bereich befinden und den Bereich noch nicht betreten haben, berechnen wir einen neuen Bereich.
Wir prüfen auch, ob wir offene Stellen haben. Wenn keine offenen Positionen vorhanden sind, berechnen wir eine neue Spanne.
Sobald wir feststellen, dass wir einen neuen Bereich berechnen müssen, rufen wir die Funktion CalculateRange auf. In dieser Funktion setzen wir alle Bereichsvariablen auf ihren Standardzustand zurück. Anschließend berechnen wir die Startzeit des Bereichs, indem wir den Beginn des Tages ermitteln und die Startzeit des Eingabebereichs in Minuten hinzufügen. Wenn die berechnete Startzeit bereits überschritten ist, verschieben wir sie auf den nächsten Tag und betrachten Samstag und Sonntag als Wochenendtage. Auf ähnliche Weise berechnen wir die Endzeit des Bereichs, indem wir die Dauer des Eingabebereichs in Minuten zur Startzeit addieren. Fällt die Endzeit auf einen Samstag oder Sonntag, verschieben wir sie auf den nächstgültigen Tag.
Wir berechnen auch die Reichweitenschlusszeit nach der gleichen Logik wie die Berechnung der Startzeit und Endzeit. Um die berechneten Zeiten im Diagramm zu visualisieren, erstellen wir Objekte mit der Funktion ObjectCreate. Wir erstellen ein vertikales Linienobjekt für die Startzeit des Bereichs und löschen alle zuvor gezeichneten Objekte.
Dies ist der Fortschritt, den wir bisher gemacht haben, und wir werden im nächsten Video mit dem Codieren fortfahren.
Range Breakout EA mql5 Programmierung | Teil 3/4
Range Breakout EA mql5 Programmierung | Teil 3/4
Hallo, das ist Toby, und im heutigen Video werden wir mit der Codierung unseres Breakout-EA fortfahren. In den vorherigen Videos haben wir bereits die Startzeit, Endzeit und Schlusszeit des Bereichs berechnet. Jetzt wollen wir das Range-Hoch und das Range-Tief sowie die Ausbruchsbedingungen und den Positionsschluss kodieren. Wenn Sie die vorherigen Videos noch nicht gesehen haben, finden Sie die Links in der Beschreibung unten. Lassen Sie uns in den MetaEditor springen und mit dem Codieren beginnen.
Zuerst gehen wir zur OnTick-Funktion. Wir beginnen damit, zu prüfen, ob wir uns innerhalb des Bereichs befinden, und speichern die Höchst- und Tiefstwerte. Wir verwenden eine if-Anweisung, um zu prüfen, ob die aktuelle Zeit zwischen den Start- und Endzeiten des Bereichs liegt. Wenn dies der Fall ist, aktualisieren wir die Höchst- und Tiefstwerte entsprechend. Wir setzen außerdem ein Eintrittsflag auf „True“, um anzuzeigen, dass wir einen Tick innerhalb des Bereichs hatten. Anschließend aktualisieren wir die Diagrammobjekte für die Bereichshochs und -tiefs.
Als nächstes gehen wir zur DrawObject-Funktion über, um die oberen und unteren Ebenen des Bereichs zu zeichnen. Wir kopieren den Codeblock für die Schließzeit und nehmen die notwendigen Änderungen für die hohe Ebene vor. Wir verwenden den Objektnamen „Range High“ und zeichnen eine Trendlinie von der Range-Startzeit bis zum Range-High-Preis. Wir aktualisieren auch den Tooltip, um den oberen Bereichswert anzuzeigen. Dasselbe machen wir für das Range-Tief, indem wir den Objektnamen ändern und eine Trendlinie von der Range-Startzeit zum Range-Tiefpreis zeichnen.
Um eine Linie vom Ende des Bereichs bis zum Schlusszeitpunkt zu zeichnen, die einen Ausbruch anzeigt, kopieren wir den Codeblock erneut und ändern ihn entsprechend. Wir ändern den Objektnamen und zeichnen eine Trendlinie vom Endzeitpunkt des Bereichs bis zum Schlusszeitpunkt. Außerdem stellen wir den Linienstil auf gepunktet ein.
Nachdem wir einen visuellen Test zusammengestellt und ausgeführt haben, können wir die Bereichsobergrenze, die Bereichsuntergrenze und die Ausbruchslinien im Diagramm sehen. Lassen Sie uns nun die Ausbruchsbedingungen codieren. Wir fügen eine neue Funktion namens CheckBreakouts innerhalb der OnTick-Funktion hinzu. Zuerst prüfen wir, ob wir nach der Bereichsendzeit sind. Wir stellen außerdem sicher, dass das Eingabeflag auf „True“ gesetzt ist, was anzeigt, dass wir einen Tick innerhalb des Bereichs hatten. Wenn diese Bedingungen erfüllt sind, prüfen wir, ob hohe und niedrige Ausbrüche vorliegen.
Bei einem hohen Ausbruch prüfen wir, ob die Flagge für den hohen Ausbruch falsch ist und ob der Briefkurs des letzten Ticks größer oder gleich dem Hoch der Spanne ist. Wenn ja, eröffnen wir eine Kaufposition mit der PositionOpen-Funktion. In ähnlicher Weise prüfen wir bei einem Tiefdurchbruch, ob die Tiefstdurchbruchsflagge falsch ist und ob der Geldkurs des letzten Ticks unter oder gleich dem Tiefstkurs der Spanne liegt. Wenn diese Bedingungen erfüllt sind, eröffnen wir eine Verkaufsposition.
Wir kompilieren den Code und führen einen visuellen Test durch, um zu bestätigen, dass die Positionen geöffnet werden, wenn ein Ausbruch auftritt. Als nächstes implementieren wir die Positionsschließung. Bevor wir eine neue Spanne berechnen, prüfen wir, ob die aktuelle Zeit größer oder gleich der Spannenschlusszeit ist. Wenn ja, rufen wir die Funktion ClosePositions auf. Diese Funktion durchläuft alle offenen Positionen mit der angegebenen magischen Zahl und schließt sie mithilfe der PositionClose-Funktion. Wir verwenden eine Countdown-Schleife, um sicherzustellen, dass alle Positionen geschlossen werden, auch wenn sich die Gesamtzahl der Positionen während der Schleife ändert.
Abschließend kompilieren wir den Code und führen einen visuellen Test durch, um zu bestätigen, dass die Positionen geschlossen werden, wenn die Range-Close-Zeit erreicht ist.
Das war’s für dieses Video. Wenn Sie Fragen haben, können Sie diese gerne unten in den Kommentaren hinterlassen. Vergessen Sie nicht, weitere Coding-Videos zu liken und zu abonnieren. Danke fürs zuschauen!