Le problème du transfert de MT4 à MT5. Ou, plus précisément, l'impossibilité d'exécuter certains algorithmes dans MT5 sans "err". - page 10

Nouveau commentaire
 
Vict:

C'est étrange, mais je n'avais pas pensé à le faire avant :

Cela permettrait de se débarrasser d'une masse de contrôles d'erreurs, comme l'allocation de mémoire.

pas d'option, l'EA sera supprimé du graphique, et vous n'aurez qu'à "quitter le système d'exploitation" avant le prochain tick à partir de n'importe quel endroit du programme.


Très probablement, il est possible d'envelopper élégamment tout dans une macro, pour appeler en toute sécurité les fonctions liées à l'indisponibilité des données sur le tick actuel, voici un "dummy".

void OnStart()
  {
   for(int i=0;i<10;i++)
     {
      double o=Open(i);
      if(o>0.0) printf("%d : %f",i,o);
      else
        {
         printf("Error № %d ",(int)o);
         return;
        }
     }
  }
//+------------------------------------------------------------------+

double Open(int shift)
  {
   ResetLastError();
   double result=iOpen(NULL,0,shift);
   int err=GetLastError();
   if(err>0) result=-err;
   return(result);
  }
//+------------------------------------------------------------------+

pour la lisibilité du code, il serait bien de l'écrire de cette façon :

void OnStart()
  {
   for(int i=0;i<10;i++)
     {
      double o=Try( Open(i),"Текст сообщения" );
      printf("%d : %f",i,o);
     }
  }


Est-il réaliste de penser que cet essai peut être enveloppé dans une macro et qu'il faut "quitter le système d'exploitation" en cas d'échec ?

 
Igor Makanu:

Est-il réaliste d'envelopper cet essai dans une macro et de "quitter le système d'exploitation" en cas d'échec ?

#define  Try(VAR, EXPR, MES)          \
   VAR = EXPR;                       \
   if (VAR <= 0.0) {                 \
     printf("Error: %s ", MES);      \
     return;                         \
   }

double o;
Try(o, Open(i), "something goes wrong");

Non ?

J'écris souvent toutes sortes de minimax au début d'une fonction, avec undefine à la fin. Naturellement, si l'action est répétée souvent, sinon elle n'a pas de sens.

#define  MYERR_HANDLER(INDEX)                                \
{                                                           \
   Alert(__FILE__, " ", __LINE__, "-", INDEX, ": error");   \
   this.state = obst_error;                                 \
   return obev_no_event;                                    \
}

Et vous avez tort à propos de l'avortement, pour certaines erreurs c'est parfait.

 
Vict:

Non ?

Oui !

mais idéalement, je l'aimerais plutôt :

double o;
Try(o, Open(i), "something goes wrong");

comme ça :

double o = Try(Open(i), "something goes wrong");

il ne s'agit pas de rendre la signature de la fonction Open() différente... Mais sous cette forme, j'obtiendrai ce que j'aimerais vraiment ! ;)

----------------------

PS : comme option, même les variables Tryerror ou bool Tryresult décrites globalement feraient l'affaire - le but d'une ligne "appel sûr", si cet appel se termine par une erreur, sortir du corps OnTick().

 
Igor Makanu:

comme ça :

Je doute que ce soit possible, même dans les plus (on peut lancer une exception, mais c'est peu probable). Mais des choses arrivent, peut-être que quelqu'un va surprendre...

 

Donc, en un coup d'œil rapide :

Try(double, o, Open(i), "something goes wrong");

c'est probablement le maximum dans cette situation.

 

Complètement débile, tu peux le faire, n'est-ce pas ?

double Try_helper;
#define  Try(EXPR, MES)               \
   Try_helper = EXPR;                \
   if (Try_helper <= 0.0) {          \
     printf("Error: %s ", MES);      \
     return;                         \
   }

double o = Try(Open(i), "something goes wrong");

Je ne l'ai pas compilé, mais ça devrait fonctionner.

 
Vict:

Je suis tellement stupide, je ne peux pas m'en empêcher, n'est-ce pas ?

Je ne l'ai pas compilé, mais il devrait fonctionner.

Shaitan la machine ! !! Ça a marché ! !!

vérifié et simulé l'erreur ( shift>5 )

double Try_helper;
#define  Try(EXPR, MES)               \
   Try_helper = EXPR;                \
   if (Try_helper <= 0.0) {          \
     printf("Error: %s ", MES);      \
     return;                         \
   }

void OnStart()
  {
   for(int i=0;i<10;i++)
     {
      
      double o = Try(Open(i), "something goes wrong");
      printf("%d : %f",i,o);
     }
  }
//+------------------------------------------------------------------+

double Open(int shift)
  {
   ResetLastError();
   double result=iOpen(NULL,0,shift);
   int err=GetLastError()>0;
   if(err>0) result=-err;
   if(shift>5) result = -999;
   return(result);
  }
//+------------------------------------------------------------------+

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) 0 : 1.115010

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) 1 : 1.114670

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) 2 : 1.114590

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) 3 : 1.114400

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) 4 : 1.115240

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) 5 : 1.115450

2019.07.31 16:58:48.154 tst1 (EURUSD,H1) Erreur : un problème est survenu


Génial ! Et le code de la macro s'est avéré être très simple.


MERCI ! - Vous êtes définitivement un magicien !)

 

N'hésitez pas à l'utiliser.

La macro ci-dessus a un inconvénient - le type de l'aide est codé en dur, vous ne pouvez pas passer à la fonction Try qui retourne une chaîne de caractères et ensuite un double sans créer deux macros. J'ai un intérêt sportif - comment le contourner (écrire une macro pour tous les types. En µl sans options, en c++, bien que ce ne soit pas vraiment nécessaire ici, mais quand même) ? Personne n'est prêt à proposer sa propre variante (il faut bien se maintenir en forme, après tout) ?

 
Vict:

Vous pouvez l'utiliser.

La macro ci-dessus a un inconvénient - le type d'aide est câblé, vous ne pouvez pas passer une fonction retournant une chaîne dans Try

Pourquoi pas ? Le signe + n'a pas été annulé !

voici comment j'ai passé au peigne fin votre macro, et comment je compte l'utiliser :

int    _GetLastError;
double _Try_helper;
string _Try_FUNCSIG;
#define  Try(FUNC,MSG, EXCEPT) _Try_helper=FUNC;if(_GetLastError>0){printf("%s : error № %d %s ",_Try_FUNCSIG,_GetLastError,MSG);EXCEPT;}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   for(int i=0;i<10;i++)
     {

      double o = Try(Open(i), "something goes wrong"+Txt(),return);
      printf("%d : %f",i,o);
     }
  }
//+------------------------------------------------------------------+

double Open(int shift)
  {
   _Try_FUNCSIG=__FUNCSIG__;
   ResetLastError();
   double result=iOpen(NULL,0,shift);
   _GetLastError=GetLastError();
   if(shift>5)_GetLastError=999;
   return(result);
  }
//+------------------------------------------------------------------+
string Txt()
{
return(" Txt ");

maintenant, le paramètre de macroEXCEPT est une action d'exception, qui fonctionne bien comme retour ou juste ; - si vous décidez de ne pas imprimer dans le journal, mais ne laissez pas le corps de OnTick().

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) 0 : 1.113350

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) 1 : 1.114180

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) 2 : 1.115110

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) 3 : 1.115010

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) 4 : 1.114670

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) 5 : 1.114590

2019.07.31 19:01:28.353 tst1 (EURUSD,H1) double Open(int) : error #999 something goes wrong Txt

 
Igor Makanu:

Eh bien, je veux dire, c'est comme ça :

string f(int) {return "hello world";}
double f(double) {return 35;}

int main()
{
   double d = Try(f(0.), "double error");
   string s = Try(f(0), "stirng error");
   cout << s << "-" << d << endl;  // hello world-35
   return 0;
}

Les gens ici n'ont pas l'air de jouer. Oh, allez.

template <typename T> T Try_helper;
#define  Try(EXPR, MES)                                  \
   Try_helper<decltype(EXPR)> = EXPR;                   \
   if (Try_helper<decltype(EXPR)> == decltype(EXPR){}) {\
      printf("%s\n", MES);                              \
      return 1;                                         \
   }
1...3456789101112
Nouveau commentaire