DocumentationSections
Référence MQL5Concepts de Base du LangageProgrammation Orientée ObjetMembres Statiques de Classe 

Membres Statiques d'une Classe/Structure

Membres Statiques

Les membres d'une classe peuvent être déclarés en utilisant le modificateur de classe de stockage static. Ces membres sont partagés par toutes les instances de cette classe et sont stockés dans un seul endroit. Les membres de données non-statiques sont créés pour chaque variable d'objet de classe.

L'incapacité de déclarer des membres statiques d'une classe aurait mené au besoin de déclarer ces données au niveau global du programme. Cela casserait la relation entre les données et leur classe, et ce n'est pas consistent avec le paradigme de base de la POO - joindre les données et les méthodes pour les gérer dans une classe. Le membre statique permet aux données de classe qui ne sont pas spécifiques à une instance particulière d'exister dans la portée de la classe.

Puiqu'un membre statique de classe ne dépend pas d'une instance particulière, la référence sur lui sera du format suivant :

class_name::variable

où class_name est le nom de la classe, et variable est le nom du membre de la classe.

Comme vous le voyez, pour accéder au membre statique d'une classe, l'opérateur de résolution de contexte :: est utilisé. Lorsque vous accédez à un membre statique dans des méthodes de la classe, l'opérateur de contexte est optionnel.

Le membre statique d'une classe doit être initialisé explicitement avec la valeur désirée. Pour cela, il doit être déclaré et initialisé au niveau de la portée globale. La suite d'initialisation des membres statiques correspondra à la suite de leur déclaration dans la portée globale.

Par exemple, nous avons la classe CParser utilisée pour parcourir le texte, et nous avons besoin de compter le nombre total de mots et caractères traités. Nous n'avons qu'à déclarer les membres de classe nécessaires comme static et les initialiser au niveau global. Ensuite toutes les instances de la classe utiliseront un compteur commun pour les mots et les caractères.

//+------------------------------------------------------------------+
//| Classe "Analyseur de texte"                                      |
//+------------------------------------------------------------------+
class CParser
  {
public:
   static int        s_words;
   static int        s_symbols;
   //--- Constructeur et destructeur
                     CParser(void);
                    ~CParser(void){};
  };
...
//--- Initialisation des membres statiques de la classe Parser au niveau global
int CParser::s_words=0;
int CParser::s_symbols=0;

Un membre statique de classe peut être déclaré avec le mot-clé const. Ce type de constante statique doit être initialisée au niveau global avec le mot-clé const :

//+------------------------------------------------------------------+
//| Classe "Stack" pour stocker les données traitées                 |
//+------------------------------------------------------------------+
class CStack
  {
public:
                     CStack(void);
                    ~CStack(void){};
...
private:
   static const int  s_max_length; // Capacité maximum de la pile
  };
 
//--- Initialisation de la constante statique de la classe CStack
const int CStack::s_max_length=1000;

Pointeur this #

Le mot-clé this dénote un pointeur déclaré implicitement sur lui-même — vers une instance spécifique de la classe, dans le contexte de laquelle la méthode est exécutée. Il ne peut être utilisé que dans les méthodes non-statiques de la classe. Le pointeur this est un membre implicite non-statique de n'importe quelle classe.

Dans les fonctions statiques, vous ne pouvez accéder qu'aux membres/méthodes statiques d'une classe.

Méthodes Statiques

En MQL5, les fonctions membres de type static peuvent être utilisées. Le modificateur static doit précéder le type de retour d'une fonction dans la déclaration dans une classe.

class CStack
  {
public:
   //--- Constructeur et destructeur
                     CStack(void){};
                    ~CStack(void){};
   //--- Capacité maximum de la pile
   static int        Capacity();
private:
   int               m_length;     // Le nombre d'élément dans la pile
   static const int  s_max_length; // Capacité maximum de la pile
  };
//+------------------------------------------------------------------+
//| Retourne le nombre maximum d'éléments à stocker sur la pile      |
//+------------------------------------------------------------------+
int CStack::Capacity(void)
  {
   return(s_max_length);
  }
//--- Initialisation de la constante statique de la classe CStack
const int CStack::s_max_length=1000;
//+------------------------------------------------------------------+
//| Fonction de lancement du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare la variable de type CStack
   CStack stack;
//--- appelle la méthode statique de l'objet
   Print("CStack.s_max_length=",stack.Capacity());
//--- elle peut également être appelée de la façon suivante, comme la méthode est statique et ne requiert pas la présence d'un objet
   Print("CStack.s_max_length=",CStack::Capacity());
  }

Une méthode avec le modificateur const est appelée constante et ne peut pas modifier les membres implicite de sa classe. La déclaration des fonctions constantes d'une classe et des paramètres constants est appelée contrôle de const-correction. Grâce à ce contrôle, vous êtes sûrs que le compilateur s'assurera de la cohérence des valeurs des objets et retournera une erreur pendant la compilation s'il y a quelque chose de faux.

Le modificateur const est placé après la liste des arguments dans la déclaration d'une classe. La définition en dehors d'une classe doit également inclure le modificateur const :

//+------------------------------------------------------------------+
//| Classe "Rectangle"                                               |
//+------------------------------------------------------------------+
class CRectangle
  {
private:
   double            m_width;      // Largeur 
   double            m_height;     // Hauteur
public:
   //--- Constructeurs et destructeur
                     CRectangle(void):m_width(0),m_height(0){};
                     CRectangle(const double w,const double h):m_width(w),m_height(h){};
                    ~CRectangle(void){};
   //--- Calcul de la surface
   double            Square(void) const;
   static double     Square(const double w,const double h);// { return(w*h); }
  };
//+------------------------------------------------------------------+
//| Retourne l'aire de l'objet "Rectangle"                           |
//+------------------------------------------------------------------+
double CRectangle::Square(void) const
  {
   return(Square(m_width,m_height));
  }
//+------------------------------------------------------------------+
//| Retourne le produit de deux variables                            |
//+------------------------------------------------------------------+
static double CRectangle::Square(const double w,const double h)
  {
   return(w*h);
  }
//+------------------------------------------------------------------+
//| Fonction de lancement du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Crée un rectangle rect avec les côtés égaux à 5 et 6
   CRectangle rect(5,6);
//--- Trouve l'aire du rectangle en utilisant une méthode constante
   PrintFormat("rect.Square()=%.2f",rect.Square());
//--- Trouve le produit des nombres en utilisant la méthode statique de la classe CRectangle
   PrintFormat("CRectangle::Square(2.0,1.5)=%f",CRectangle::Square(2.0,1.5));
  }

Un argument supplémentaire en faveur de l'utilisation du contrôle de constance est le fait que dans ce cas, le compilateur génèrera une optimisation spéciale, par exemple, placera un objet constant en mémoire en lecture seule.

Une fonction statique ne peut pas être déterminée avec le modificateur const, car ce modificateur assure que les membres de l'instance sont constants lors de l'appel à cette fonction. Mais comme mentionné plus haut, la fonction statique ne peut pas accéder aux membres non-statiques de la classe.

Voir aussi

Variables Statiques, Variables, Références. Modificateur & et Mot-Clé this