Erreurs, bugs, questions - page 96

[Mykola Demko]

Je suis confus, veuillez me conseiller.

J'ai créé une structure, je l'ai remplie de données, j'ai créé un tableau de structures.

Comment puis-je maintenant passer un tableau à une fonction, mais seulement pour un élément de la structure ? ?????????????.

struct Str
  {
   int               a;
   int               b;
                     Str(){a=2;b=3;};
                    ~Str(){};
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Str srt[10];
void OnStart()
  {
   Print("sum a=",OnStr(srt[].a));??????????????????
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnStr(const Str &x[].y)?????????????????????
  {
   int sum=0;
   for(int i=0;i<10;i++)
     {
      sum+=x[i].y;
     }
   return(sum);
  }

[Mykola Demko]

Suggestion aux développeurs: si possible, il serait bon d'effectuer des opérations standard avec les structures.

pas comme ça :

struct Str
  {
   int               a;
   int               b;
                     Str(){a=2;b=3;};
                    ~Str(){};
  };
Str x;
Str y;
void OnStart()
  {
   x.a+=y.a;
   x.b+=y.b;   
  }

mais comme ça :

void OnStart()
  {
   x+=y;     
  }

La copie des structures fait partie du passé.

[[Supprimé]]

Urain:

Je suis confus, veuillez me conseiller.

J'ai créé une structure, je l'ai remplie de données, j'ai créé un tableau de structures.

Comment passer un tableau à une fonction, mais seulement pour un élément de la structure ? ?????????????

Tu ne peux pas. Et vous n'en avez pas besoin.

Parce que - qui empêche la fonction de sommation de faire la somme de cet élément seulement ?

Et donc le code a été corrigé pour le rendre "kasher" :

struct Str
  {
   int               a;
   int               b;
                     Str(){a=2;b=3;};
                    ~Str(){};
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Str srt[10];
void OnStart()
  {
   Print("sum a=",OnStr(srt));??????????????????
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnStr(const Str &x[])?????????????????????
  {
   int sum=0;
   for(int i=0;i<10;i++)
     {
      sum+=x[i].y;
     }
   return(sum);
  }

Seul quelque chose comme ArraySize() devrait être utilisé en réalité au lieu de 10 dans la boucle for de la fonction OnStr(). Et au lieu de y dans "sum+=x[i].y", il faut ajouter le champ de données réel défini dans la structure (a ou b, par exemple).

[[Supprimé]]

Urain:

Suggestion aux développeurs : si possible, il serait bon d'effectuer des opérations standard avec les structures.

pas comme ça :

mais comme ça :

La copie des structures fait partie du passé.

Il existe une telle chose en C++. Cela s'appelle "surcharge des opérateurs". C'est le programmeur qui définit comment cela doit fonctionner en utilisant la fonction correspondante.

Mais cette fonction Renat a dit "non". Pas de chance, hein ?

[Mykola Demko]

simpleton:

Je ne peux pas. Et il n'y a pas besoin de le faire.

Car qui vous empêche d'additionner exactement cet élément dans la fonction de sommation ?

Le code a donc été corrigé en "kasher" :

Seul quelque chose comme ArraySize() devrait être utilisé au lieu de 10 dans la boucle for de la fonction OnStr(). Et au lieu de y dans "sum+=x[i].y", il faut ajouter le champ de données réel défini dans la structure (a ou b, par exemple).

Comme toujours, quand je donne des exemples, le point s'envole, mais je ne suis pas surpris, c'est probablement ma langue osseuse.

L'essentiel est le suivant : écrivez une fonction de moyenne arithmétique et, en passant simplement un tableau de structures à cette fonction, obtenez la structure de la moyenne arithmétique pour chacun des membres de la structure.

L'exemple est donné par souci de simplicité, mais il est probablement infructueux. Mais merci pour les clarifications de principe.

Je suppose que nous devrions vraiment frapper les développeurs pour qu'ils autorisent la "surcharge des opérateurs".

[Mykola Demko]

oui j'ai du écrire un tas de méthodes juste pour ajouter, multiplier, diviser, deux structures,

le plus ennuyeux est que nous devrons tout réécrire sur d'autres structures.

PS : En plus des méthodes qui donnent le type de structure, celles qui sont retournées ont la même structure que celle avec laquelle nous opérons, donc l'appel imbriqué ne passe pas.

le résultat doit d'abord être sauvegardé dans une structure temporaire, puis transmis au traitement suivant ? la raison de cette opération n'est pas claire.

PPS Bien que tous les paramètres soient constants, il n'est pas possible de modifier une variable inexistante.

PPPS Et désolé, les structures sont passées par référence, comment pouvez-vous faire référence à une structure inexistante (apparemment, il est temps de se reposer).

[Evgeniy Trofimov]

int sl_pips = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);

Remarque erronée"perte possible de données en raison de la conversion de type" ? (Bâtiment : 305)

[[Supprimé]]

Urain:

Je suis confus, veuillez me conseiller.

J'ai créé une structure, je l'ai remplie de données, j'ai créé un tableau de structures.

Comment passer un tableau à une fonction, mais seulement pour un élément de la structure ? ?????????????

struct Str
  {
   int               a;
   int               b;
                     Str(){a=2;b=3;};
                    ~Str(){};
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Str srt[10];
void OnStart()
  {
   Print("sum a=",OnStr(srt[].a));??????????????????
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnStr(const Str &x[].y)?????????????????????
  {
   int sum=0;
   for(int i=0;i<10;i++)
     {
      sum+=x[i].y;
     }
   return(sum);
  }

simplet:

Tu ne peux pas. Et vous n'en avez pas besoin.

Parce que - qui empêche la fonction de sommation de faire la somme de cet élément seulement ?

Le code est donc ajusté à "kasher" :

Seul quelque chose comme ArraySize() devrait être utilisé, et non 10 dans la boucle for à l'intérieur de OnStr(). Et au lieu de y dans "sum+=x[i].y", il faut ajouter le champ de données réel défini dans la structure (a ou b, par exemple).

Il y a deux façons de procéder (pour autant que je sache) :

1. Passez le tableau lui-même, en spécifiant l'index de l'enregistrement avec lequel nous allons travailler comme paramètre supplémentaire.

Dans ce cas, nous devons contrôler la dimension du tableau, et la déclaration de la fonction ressemblerait à ceci...

OnStr(const Str &x[], int Index=-1)

2. Passez le tableau secondaire avec la dimension d'un enregistrement, respectivement tout le travail sur le contrôle et le traitement des résultats de la fonction est tenu au point d'appel de la fonction.

La déclaration de la fonction ressemblera alors à quelque chose comme ceci

OnStr(const Str &x[1])

[[Supprimé]]

EvgeTrofi:
Remarque erronée"perte possible de données en raison de la conversion de type" ? (Bâtiment : 305)

Vous devez convertir explicitement le résultat en type int.

int sl_pips = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);

PS

Vous pouvez voir un exemple fonctionnel ici - OrderSend()

Mais si je comprends bien, cet avertissement peut être ignoré en principe...

[Evgeniy Trofimov]

Si la déclaration comporte beaucoup de parenthèses, elle commence à s'embrouiller !

Voici, par exemple, une fonction qui renvoie un nombre à partir d'une chaîne comme "klsfd Step 2 :

int GetStep(string text){
   string Right;
   int U = StringFind(text, "Step ");
   int End, result;
   if(U>=0){
      U=U+5;
      Right = StringSubstr(text, U);
      End = StringFind(Right, ".");
      result=int(MathRound(StringToDouble(StringSubstr(text, U, End-U))));
      return(result);
   }
   return(0);
}

En quoi est-il différent de celui-ci ?

int GetStep(string text){
   string Right;
   int U = StringFind(text, "Step ");
   int End;
   if(U>=0){
      U=U+5;
      Right = StringSubstr(text, U);
      End = StringFind(Right, ".");
      return(int(MathRound(StringToDouble(StringSubstr(text, U, End-U)))));
   }
   return(0);
}

La deuxième causera des problèmes de compilation, mais pas la première.