Référence MQL5Concepts de Base du LangageTypes de DonnéesTypes IntegerTypes Char, Short, Int et Long

Types Char, Short, Int et Long

char #

Le type char occupe 1 octet en mémoire (8 bits) et permet d'exprimer 2^8=256 valeurs en représentation binaire. Le type char peut contenir des valeurs positives et des valeurs négatives. Les valeurs possibles vont de -128 à 127.

uchar #

Le type entier uchar occupe également 1 octet en mémoire, comme le type char, mais contrairement à lui, uchar n'est prévu que pour les valeurs positives. La valeur minimum est zéro, la valeur maximum est 255. La première lettre u dans le nom du type uchar est l'abréviation de unsigned.

short #

La taille du type short est de 2 octets (16 bits) et de la même façon, il permet d'exprimer l'intervalle de valeurs égales à 2 puissance 16 : 2^16 = 65 536. Puisque le type short est signé, et qu'il contient à la fois des valeurs positives et des valeurs négatives, l'intervalle des valeurs est compris entre -32 768 et 32 767.

ushort #

Le type non signé short est le type ushort, qui a également une taille de 2 octets. La valeur minimum est 0, la valeur maximum est 65 535.

int #

La taille du type int est de 4 octets (32 bits). La valeur minimale est -2 147 483 648, la valeur maximale est 2 147 483 647.

uint #

Le type entier non signé est uint. Il occupe 4 octets en mémoire et permet d'exprimer des entiers de 0 à 4 294 967 295.

long #

La taille du type long est de 8 octets (64 bits). La valeur minimum est -9 223 372 036 854 775 808, la valeur maximum est 9 223 372 036 854 775 807.

ulong #

Le type ulong occupe également 8 octets et peut stocker des valeurs de 0 à 18 446 744 073 709 551 615.

Exemples :

char ch=12;
short sh=-5000;
int in=2445777;

Puisque les types entiers non signés ne sont pas conçus pour stocker des valeurs négatives, la tentative d'affecter une valeur négative peut mener à des conséquences inattendues. Le script simple suivant génèrera une boucle infinie :

//--- Boucle infinie
void OnStart()
  {
   uchar  u_ch;

   for(char ch=-128;ch<128;ch++)
     {
      u_ch=ch;
      Print("ch = ",ch," u_ch = ",u_ch);
     }
  }

La variante correcte est :

//--- Variante correcte
void OnStart()
  {
   uchar  u_ch;

   for(char ch=-128;ch<=127;ch++)
     {
      u_ch=ch;
      Print("ch = ",ch," u_ch = ",u_ch);
      if(ch==127) break;
     }
  }

Résultat :

   ch= -128  u_ch= 128
   ch= -127  u_ch= 129
   ch= -126  u_ch= 130
   ch= -125  u_ch= 131
   ch= -124  u_ch= 132
   ch= -123  u_ch= 133
   ch= -122  u_ch= 134
   ch= -121  u_ch= 135
   ch= -120  u_ch= 136
   ch= -119  u_ch= 137
   ch= -118  u_ch= 138
   ch= -117  u_ch= 139
   ch= -116  u_ch= 140
   ch= -115  u_ch= 141
   ch= -114  u_ch= 142
   ch= -113  u_ch= 143
   ch= -112  u_ch= 144
   ch= -111  u_ch= 145
    ...

Exemples :

//--- Les valeurs négatives ne peuvent pas être stockées dans les types non signés
uchar u_ch=-120;
ushort u_sh=-5000;
uint u_in=-401280;

Héxadecimal : nombres de 0 à 9, lettres de a à f ou A à F pour les valeurs 10 à 15 ; démarre avec 0x ou 0X.

Exemples :

0x0A, 0x12, 0X12, 0x2f, 0xA3, 0Xa3, 0X7C7

Pour les variables entières, les valeurs peuvent être affectées sous la forme binaire en utilisant le préfixe B. Par exmeple, vous pouvez encoder les heures de travail d'une session de trading dans une variable de type int et utiliser ses informations selon l'algorithme désiré :

//+------------------------------------------------------------------+
//| Fonction de lancement du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- utilise 1 pour les heures travaillées et 0 pour les autres
   int AsianSession   =B'111111111'; // Session asiatique de 0:00 à 9:00
   int EuropeanSession=B'111111111000000000'; // Session européenne 9:00 - 18:00
   int AmericanSession =B'111111110000000000000011'; // Session américaine 16:00 - 02:00
//--- dérive les valeurs numériques des sessions
   PrintFormat("Les heures de la session asiatique sous forme de valeur =%d",AsianSession);
   PrintFormat("Les heures de la session européenne sous forme de valeur =%d",EuropeanSession);
   PrintFormat("Les heures de la session américaine sous forme de valeur =%d",AmericanSession);
//--- et affichons maintenant les représentations textuelles des heures de travail des sessions
   Print("Session asiatique ",GetHoursForSession(AsianSession));
   Print("Session européenne ",GetHoursForSession(EuropeanSession));
   Print("Session américaine ",GetHoursForSession(AmericanSession));
//---
  }
//+------------------------------------------------------------------+
//| retourne les heures travaillées de la session sous forme de texte|
//+------------------------------------------------------------------+
string GetHoursForSession(int session)
  {
//--- pour vérifier, utilisez les opérations sur les bits AND et décalage à gauche de 1 bit <<=1
//--- commence par vérifier à partir du plus petit bit
   int bit=1;
   string out="heures de travail : ";
//--- vérifie les 24 bits en commencant par l'indice 0 et jusqu'au 23
   for(int i=0;i<24;i++)
     {
      //--- récupère l'état de chaque bit sous forme d'un nombre
      bool workinghour=(session&bit)==bit;
      //--- ajoute le numéro de l'heure au message
      if(workinghour )out=out+StringFormat("%d ",i);
      //--- décalage d'un bit vers la gauche pour vérifier la valeur du suivant
      bit<<=1;
     }
//--- chaîne résultat
   return out;
  }

Voir aussi

Conversion de Type

Types Integer

Constantes Caractères