Metatrader Forum | Forex Expert-Advisor | Broker & Forex Tools  
Zurück   Metatrader Forum | Forex Expert-Advisor | Broker & Forex Tools > Metatrader 4 > Programmierung MQL4

Programmierung MQL4 Hier gehts rund ums Programmieren in MQL4.

Login
Benutzername:
Kennwort:


Statistik
Themen: 4280
Beiträge: 39485
Benutzer: 6.595
Aktive Benutzer: 246
Links: 80
Wir begrüßen unseren neuesten Benutzer: rustembilgi
Mit 667 Benutzern waren die meisten Benutzer gleichzeitig online (vor 3 Wochen um 05:39).
Neue Benutzer:
vor einem Tag
- rustembilg...
vor einem Tag
- plamdam
vor 3 Tagen
- sh3ldn
vor 4 Tagen
- trader2
vor 5 Tagen
- qaseem

Onlineuser
'Wer ist online' anzeigen Benutzer: 0
Gäste: 153
Gesamt: 153
Team: 0
Team:  
Benutzer:  
Freunde anzeigen

Empfehlungen

Like Tree2Likes
Antwort
 
Themen-Optionen Thema durchsuchen Ansicht
  #1 (permalink)  
Alt vor 3 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 773
MA-EA befindet sich auf einem aufstrebenden Ast
Standard Anfangswert

Hallo.

Hab gelesen, dass Variablen immer einen Anfangswert brauchen. Wie richtet man das Alles am besten ein? Müsste doch eigentlich korrekt sein, wenn im Programm an der Stelle, wo die Variable das 1. Mal gebraucht wird, sie zum 1. Mal deklariert wird (oder wies heißt) und irgendeinen Startwert bekommt. Oder sollte das besser schon vor Init() oder Start() oder so passieren? Aber das wär ja eigentlich Verschwendung von Rechenleistung, Rechenzeit und Speicher, sie erst zu deklarieren und später im Programm noch mal die Variable aufzurufen, bloß um ihr nen Anfangswert zu geben... Müsste doch eigentlich reichen, das Alles zu machen, wenn sie zum ersten Mal benutzt wird.

Z.B. erst deklarieren, dann Anfangswert zuweisen:
Code:
bool RT;
...
RT=false;
...
Müsste doch reichen, wenn man am Platz im Programm, wo der bool das 1. Mal benutzt wird, einfach schreibt:
Code:
...
bool RT=false;
...
Mit Zitat antworten
  #2 (permalink)  
Alt vor 3 Wochen
Premium Mitglied
 
Registriert seit: Jun 2016
Ort: Österreich
Beiträge: 351
Leopold befindet sich auf einem aufstrebenden Ast
Standard

Kommt drauf an wo du die Variable benötigst.

Wenn du eine Variable im Programm öfter an verschiedenen stellen aufrufst, musst du die Variable am Anfang deklarieren. Hier bleibt der Wert der Variable gespeichert.
Wenn du eine Variable nur in einer Funktion benötigst kannst du diese auch dort deklarieren. Hier geht der Wert nach beenden der Funktion verloren. Du kannst die Variable nicht wo anders wieder abfragen.

Einer Variable sollte immer ein Wert zugewiesen werden!

Das sind eigentlich absolute Basics.

---Leopold---
Ca$hDigger likes this.
Mit Zitat antworten
  #3 (permalink)  
Alt vor 3 Wochen
Mitglied
 
Registriert seit: Jun 2013
Beiträge: 255
Ca$hDigger befindet sich auf einem aufstrebenden Ast
Standard

Zitat:
Zitat von MA-EA Beitrag anzeigen
Hallo.
Oder sollte das besser schon vor Init() oder Start() oder so passieren? Aber das wär ja eigentlich Verschwendung von Rechenleistung, Rechenzeit und Speicher, sie erst zu deklarieren und später im Programm noch mal die Variable aufzurufen, bloß um ihr nen Anfangswert zu geben... Müsste doch eigentlich reichen, das Alles zu machen, wenn sie zum ersten Mal benutzt wird.
Nein eher im Gegenteil, zum einen die Variable verbraucht im RAM immer den selben Speicher egal ob sie initialisiert wurde oder nicht. Wenn die Variable global also im scope des ganzen Programms sichbar ist, dann ist es sowieso keine Verschwendung von Rechenleistung oder Rechenzeit eben weil es nur einmal passiert beim Laden des Programms.
Lokal gesehen macht manchmal Sinn zB bei Schleifen die Deklaration und Initialisierung außerhalb der Schleife (also ein scope höher) zu machen, damit in der Schleife nur noch zugegriffen werden muss, eine wiederholte Deklaration und Initialisierung fällt dann dort weg, also ein Performancegewinn. Aber "Premature optimization is the root of all evil" viel wichtiger ist ein Programm "sicher" zu schreiben und das macht man zB durch initialisieren der Variablen.

Nicht initialisierte Variablen machen das Programm nicht deterministisch. Das heißt es existiert ein reservierter Speicherplatz wo nie klar ist was er enthält. Dies kann jedes mal wenn das Programm geladen wird unterschiedlich sein. Das Problem ist, ein Programm kann 5 Jahre fehlerfrei oder gar 5 Millionen mal fehlerfrei funktionieren und erst dann kommt dadurch ein Fehler. Dieser Fehler ist dann nicht reproduzierbar (Alptraum) eben weil die Ursache nicht deterministisch ist.

C$D
Mit Zitat antworten
  #4 (permalink)  
Alt vor 3 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 773
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

Danke.

Das wurde in keinem meiner beiden MQL4 Bücher richtig beschrieben.

Also vor Init() eigene Variablen deklarieren. Z.B.
Code:
...

//=============================================================================================================
// D E K L A R A T I O N E N
//=============================================================================================================
int i,Buy_Ticket,Sell_Ticket,j,k;
bool RT,SPR_AL,IsInv,OM,OC;
//=============================================================================================================
// I N I T / D E I N I T
//=============================================================================================================
 int OnInit(){


 ...
Und nach Start(), bevor sie benutzt werden, einen 1. Wert zu weisen, z.B.
Code:

 ...

int start(){
//=============================================================================================================
// O P E N   T I M E
//=============================================================================================================

RT=false; // RT = Right Time
if(Open_Only_From_Till==false){
  RT=true;
  Close_all_Orders_after=false;}

if(Open_Only_From_Till==true&&Hour()>=Open_From_Hour&&Minute()>=Open_From_Min&&Seconds()>=Open_From_Sec&&Hour()<=Open_Till_Hour&&Minute()<=Open_Till_Min&&Seconds()<=Open_Till_Sec)RT=true;

...
Der EA scheint jetzt jedenfalls zu funktionieren...
Angehängte Dateien
Dateityp: mq4 STOCH_WPR_AutoL_B0B1_EA.mq4 (36,1 KB, 1x aufgerufen)
Mit Zitat antworten
  #5 (permalink)  
Alt vor 3 Wochen
Mitglied
 
Registriert seit: Jun 2013
Beiträge: 255
Ca$hDigger befindet sich auf einem aufstrebenden Ast
Standard

Ne so genau nicht
Bei der Deklaration sollten die Variablen schon initialisiert werden.

Code:
int i = 0; // deklaratieren UND initialisieren
bool RT = false; // deklaratieren UND initialisieren
//usw
Wichtig ist, dass ein Wert gesetzt wird mit dem im Programm kein unvorgesehenes Verhalten ausgelöst wird, falls der Wert vor der Nutzung nicht anderweitig beschrieben wurde.

Du muss auch nicht alle Variablen global deklaratieren und initialisieren, im Gegenteil oft reicht es die Variablen lokal zu deklaratieren und initialisieren. So lokal wie möglich und so global wie nötig ist eine Grundregel.
Die Begriffe Scope/Sichtbarkeitsbereich/Gültigkeitsbereich/Lebensdauer von Variablen ist ganz wichtig als Basis zu verstehen. Das ist das Thema was @Leopold auch angesprochen hatte.

"Sichtbarkeitsbereich und Lebensdauer von Variablen sind in klassischen blockstrukturierten Programmiersprachen so aufeinander abgestimmt, dass Speicherplatz für eine Variable nur so lange zugeordnet sein muss, wie Code aus dem Sichtbarkeitsbereich ausgeführt wird."
https://de.wikipedia.org/wiki/Variab..._von_Variablen
Mit Zitat antworten
  #6 (permalink)  
Alt vor 3 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 773
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

Code:
//=============================================================================================================
// D E K L A R A T I O N E N
//=============================================================================================================
int i=1,Ticket=2;
bool RT=false,SPR_AL=false,IsInv=false,OM=false,OC=false;
Aber eigentlich kapier ich gar nix mehr.
Angehängte Dateien
Dateityp: mq4 STOCH_WPR_AutoL_B0B1_EA.mq4 (36,3 KB, 0x aufgerufen)
Mit Zitat antworten
  #7 (permalink)  
Alt vor 3 Wochen
Mitglied
 
Registriert seit: Jun 2013
Beiträge: 255
Ca$hDigger befindet sich auf einem aufstrebenden Ast
Standard

Sieh es einfach als "Sicherheit" Aber eigentlich ist doch klar wenn man nicht initialisiert ist der Speicherbereich zunächst Junk.

Selbst der Großmeister Bjarne Stroustrup (der Erfinder von C++) hält es für sinnvoll, sieht man in seinen von Ihm verfassten Guidelines:
https://isocpp.github.io/CppCoreGuid...tml#Res-always

ps: wenn man aus Deklaration ein neues Verb zaubert komm deklaratieren raus , sollte oben natürlich // deklarieren heißen
Mit Zitat antworten
  #8 (permalink)  
Alt vor 3 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 773
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

Also, wenn ich irgendwas kapiert habe, dann

1. kann man Variablen, die im ganzen Programm nur ein mal vorkommen, an der entsprechenden Stelle im Programm deklarieren. Da kann sie dann auch ihren 1. und einzigen Wert bekommen.

2. Variablen, die im Programm mehrmals vorkommen, muss man global vor Init() deklarieren und ihnen auch gleich einen 1. Wert zuweisen, egal Welchen.

Was ist mit int i ? Wird im Programm 2 - 3 mal in for-Schleifen zum Order Zählen, Suchen und Selektieren verwendet. Könnte es vielleicht Probleme geben, wenn i bis zu 3x benutzt wird? Sollte man für jede Order-Suche nen anderen Buchstaben benutzen?
Angehängte Dateien
Dateityp: mq4 STOCH_WPR_AutoL_B0B1_EA.mq4 (36,2 KB, 0x aufgerufen)
Mit Zitat antworten
  #9 (permalink)  
Alt vor 3 Wochen
Mitglied
 
Registriert seit: Jun 2013
Beiträge: 255
Ca$hDigger befindet sich auf einem aufstrebenden Ast
Standard

Also Deklarieren und Initialisieren ist eine Sache, das Thema Geltungsbereich von Variablen nochmal eine andere.

Deklarieren und Initialisieren:
Nochmal abschließend, beim Deklarieren wird empfohlen auch direkt zu Initialisieren. Dies ist keine Pflicht, kann aber unauffindbare Fehler vermeiden.

Geltungsbereich:
Alles was außerhalb von Funktionen und Anweisungsblöcken ist, ist global und überall gültig.

Alles was innerhalb eines Anweisungsblocks { //code } deklariert wird ist lokal und auch nur dort gültig und natürlich in dessen untergeordneten Anweisungsblöcken. Dazu gehören auch Funktionen.
Beispiel { //code1 { //code2 { //code3}} }
Was in code1 deklariert ist, ist unter code1 code2 code3 gültig. Was in code2 deklariert ist, ist aber nur in code2 und code3 gültig...
Einfach mal nach Begriff Geltungsbereich suchen, findet man direkt in den ersten Treffern:
Rheinwerk Computing :: C von A bis Z &ndash; 9.11 Geltungsbereich von Variablen
Geltungsbereich von Variablen in C++
Funktionen: Bausteine eines C-Programms: Gültigkeitsbereich von Variablen

int i:
int i findet normal in Schleifen Verwendung und sollte auch nur dort verwendet werden also nicht global. Bei verschachtelten Schleifen nimmt man dann bei der Inneren int j oder int k usw. Es ist nur eine Variable und der Name ist natürlich auch frei wählbar aber in 99.9% nimmt man eben i,j,k etc.
Wenn Schleifen hintereinander also nicht verschachtelt vorkommen, können sie aber alle problemlos int i haben, da int i nur für den jeweils eigenen Geltungsbereich gültig ist und nicht mit den anderen kollidiert.
AVT likes this.
Mit Zitat antworten
  #10 (permalink)  
Alt vor 2 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 773
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

Danke. Aber es geht nicht um C++ sondern um MQL 4...

In der Vers. im Anhang siehts so aus:
Code:
//=============================================================================================================
// D E K L A R A T I O N E N
//=============================================================================================================

int i=1,Ticket=2;
bool RT=false,SPR_AL=false,IsInv=false,OM=false,OC=false;

//=============================================================================================================
// I N I T / D E I N I T
//=============================================================================================================
 int OnInit(){
...
Kurz erklärt:

int i um in for-Schleifen Orders zu zählen und zu selektieren.

int Ticket ist der Return-Rückgabewert bei OrderSend Buy und Sell.

bool RT legt fest, ob zur momentanen Zeit Orders geöffnet werden dürfen.

bool SPR_AL legt fest, ob der Spread entsprechend der Globalen Variable im grünen Bereich ist.

bool IsInv wird zusammen mit i in der 1. for Schleife zum Order zählen und selektieren benutzt. Wenn er keine findet, also IsInv==false, dürfen Welche geöffnet werden.

bool OM und bool OC sind die Return-Rückgabewerte in den for-Schleifen zu OrderModify und OrderClose am Ende des EAs.

Irgendwie hat er heute wieder nur 1. mal gemacht was er soll. Da ist irgendwo der Wurm drin. Liegts vielleicht gerade daran, dass diese Globalen Variablen Anfangswerte für den ganzen EA gelten? Ich seh gar nicht mehr durch.
Angehängte Dateien
Dateityp: mq4 CCI_RSI_RVI_STOCH_WPR_B0B1_EA.mq4 (42,7 KB, 0x aufgerufen)
Mit Zitat antworten
Antwort

Lesezeichen


Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln
Es ist Ihnen nicht erlaubt, neue Themen zu verfassen.
Es ist Ihnen nicht erlaubt, auf Beiträge zu antworten.
Es ist Ihnen nicht erlaubt, Anhänge hochzuladen.
Es ist Ihnen nicht erlaubt, Ihre Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are aus
Pingbacks are aus
Refbacks are aus




Alle Zeitangaben in WEZ +2. Es ist jetzt 08:42 Uhr.


Der Wavesnode - Spam Firewall
-----------------------------------------------------------------------------------------------------------------------------
Powered by vBulletin® Version 3.8.5 (Deutsch)
Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
Powered by vBCMS® 2.7.0 ©2002 - 2019 vbdesigns.de
SEO by vBSEO 3.6.1
Copyright ©2009 - 2017 by Expert-Advisor.com - Das Metatrader Forum
MetaTrader bzw. MetaTrader 4 und MetaTrader 5 sind eingetragene Marken der MetaQuotes Software Corp.
-----------------------------------------------------------------------------------------------------------------------------