MetaTrader 4 Build 970 : Ouverture simplifiée des comptes de démo et caractéristiques MQL4 améliorées

Release Notes : MetaTrader 4

3 juin 2016

Terminal

  1. Fenêtre simplifiée de création d'un compte de démo, ajout de la possibilité de crér des comptes de couverture. Vous n'avez plus à remplir le long formulaire. Spécifiez simplement les données de base et sélectionnez les paramètres de trading : type du compte, dépôt, effet de levier et possibilité de couverture.




MQL4

  1. Le format des fichiers exécutables EX4 a changé pour implémenter les nouvelles caractéristiques du langage MQL4. Toutes les applications EX4 compilées dans des versions antérieures de MetaEditor continueront à fonctionner normalement après la mise à jour. La compatibilité ascendante est donc complétement conservée.

    Les programmes EX4 compilés sur le build 970 et supérieur ne fonctionneront pas sur les anciennes versions du terminal - la compatibilité descendante n'est pas supportée.

  2. Ajout du support des classes abstraites et des fonctions virtuelles pures.

    Les classes abstraites sont utilisées pour créer des entités génériques, que vous that you souhaitez utiliser pour créer des classes dérivées spécifiques. Une classe abstraite ne peut être utilisée que comme classe de base pour d'autres classes, c'est pourquoi il est impossible de créer un objet d'une classe abstraite.

    Une classe qui contient au moins une fonction virtuelle pure est abstraite. Les classes dérivées d'une classe abstraite doivent donc implémenter toutes ses fonctions virutelles pures, autrement elles seront également des classes abstraites.

    Une fonction virtuelle est déclarée comme "pure" en utilisant la syntaxe du spécificateur pure. Considérons l'exemple de la classe CAnimal, qui n'est créée que pour fournir des fonctions communes – les objets de type CAnimal sont trop générales pour être utilisées en pratique. CAnimal est donc un bon exemple pour une classe abstraite :
    class CAnimal
      {
    public:
                          CAnimal();     // Constructeur
       virtual void       Sound() = 0;   // Une fonction virtuelle pure
    private:
       double             m_legs_count;  // Le nombre de jambes de l'animal
      };
    
    Ici Sound() est une fonction virtuelle pure, car elle est déclarée avec le spécificateur de fonction virtuelle pure PURE (=0).

    Les fonctions virtuelles pures sont uniquement celles déclarées avec le spécificateur PURE : (=NULL) ou (=0). Exemple de déclaration et d'utilisation d'une classe abstraite :
    class CAnimal
      {
    public:
       virtual void       Sound()=NULL;   // méthode PURE, doit être surchargée dans la classe dérivée, CAnimal est maintenant abstraite et ne peut pas être créée
      };
    //--- Dé"rivée d'une classe abstraite
    class CCat : public CAnimal
     {
    public:
      virtual void        Sound() { Print("Myau"); } // PURE est surchargée, CCat n'est pas abstraite et peut être créée
     };
    
    //--- exemples de mauvaises utilisation
    new CAnimal;         // Erreur de 'CAnimal' - le compilateur retourne l'erreur "ne peut pas instancier une classe abstraite"
    CAnimal some_animal; // Erreur de 'CAnimal' - le compilateur retourne l'erreur "ne peut pas instancier une classe abstraite"
    
    //--- exemples d'utilisations correctes
    new CCat;  // aucune erreur - la classe CCat n'est pas abstraite
    CCat cat;  // aucune erreur - la classe CCat n'est pas abstraite
    
    Restrictions sur les classes abstraites
    Si le constructeur d'une classe abstraite appelle une fonction virtuelle pure (directement ou indirectement), le résultat est indéfini.
    //+------------------------------------------------------------------+
    //| Une classe de base abstraite                                           |
    //+------------------------------------------------------------------+
    class CAnimal
      {
    public:
       //--- une fonction virtuelle pure
       virtual void      Sound(void)=NULL;
       //--- fonction
       void              CallSound(void) { Sound(); }
       //--- constructeur
       CAnimal()
        {
         //--- un appel explicite à la méthode virtuelle
         Sound();
         //--- un appel implicite (en utilisant une troisième fonction)
         CallSound();
         //--- un constructor et/ou un destructeur appelle toujours ses propres fonctions,
         //--- même si elles sont virtuelles et surchargées par une fonction appelée dans une classe dérivée
         //--- si la fonction appelée est virtuelle pure
         //--- l'appel générera l'erreur d'exécution critique "appel à une fonction virtuelle pure"
        }
      };
    
    Cependant, les constructeurs et les destructeurs des classes abstraites peuvent appeler d'autres fonctions membres.

  3. Ajout du support des pointeurs de fonctions pour simplifier l'organisation des modèles d'évènements.

    Pour déclarer un pointeur de fonction, spécifiez le type "pointeur vers une fonction", par exemple :
    typedef int (*TFunc)(int,int);
    Maintenant, TFunc est un type, et il est possible de déclarer une variable comme un pointeur vers la fonction :
    TFunc func_ptr;
    La variable func_ptr peut stocker le pointeur vers une fonction pour la déclarer plus tard :
    int sub(int x,int y) { return(x-y); }
    int add(int x,int y) { return(x+y); }
    int neg(int x)       { return(~x);  }
    
    func_ptr=sub;
    Print(func_ptr(10,5));
    
    func_ptr=add;
    Print(func_ptr(10,5));
    
    func_ptr=neg;           // erreur : neg n'est pas du type   int (int,int) type
    Print(func_ptr(10));    // erreur : il devrait y avoir deux paramètres
    
    Le pointeurs de fonctions peuvent être stockés et passés comme paramètres. Vous ne pouvez pas avoir un pointeur vers une méthode de classe non statique.

  4. Ajout de la valeur TERMINAL_SCREEN_DPI à l'énumération ENUM_TERMINAL_INFO_INTEGER de la propriété du terminal client — la résolution d'affichage des données est mesurée en points par pouce (dots per inch - DPI). La connaissance de ce paramètre permet de spécifier la taille des objets graphiques, afin qu'ils paraissent identiques sur des écrans avec des résolutions différentes.
  5. Ajout de la valeur TERMINAL_PING_LAST aux propriétés ENUM_TERMINAL_INFO_INTEGER du terminal client — la dernière valeur du ping au serveur de trading en microsecondes. Une seconde est faite d'un million de microsecondes.
  6. Les buffers DRAW_NONE (aucun construction graphique) ne participe plus aux calculs du minimum et du maximum d'une fenêtre d'un graphique dans les indicateurs personnalisés.
  7. Correction de la génération des évènements relatifs aux mouvements de la souris et aux appuis sur les boutons de la souris sur les types d'objet OBJ_LABEL et OBJ_TEXT. Avant, les évènements étaient générés incorrectement s'ils étaient inclus dans d'autres objets de type OBJ_RECTANGLE_LABEL et OBJ_RECTANGLE.
  8. Correction de l'affichage des barres d'histogramme de taille zéro dans les indicateurs personnalisés. Avant, ces barres n'étaient pas affichées, elles ont maintenant une taille de 1 pixel.

Signaux

  1. Correction de la recherche des symboles de trading lors de la comparaison des symboles de trading d'un fournisseur de signaux et de l'abonné.

Tester

  1. Correction de l'utilisation du spread dans un fichier fxt si le spread courant est utilisé dans les paramètres du test.

Market

  1. Correction de quelques erreurs d'affichage dans la vitrine du Market.

MetaEditor

  1. Correction de la recherche de mots dans les fichiers dans le mode "Mot Entier Uniquement".
  2. Ajout du déplacement d'un fichier en double cliquant sur la ligne du résultat de la compilation du fichier.
  3. Correction de l'affichage de certains éléments de contrôle sous Windows XP.

Corrections d'erreurs rapportées dans les journaux de crash.