Fehler, Irrtümer, Fragen - Seite 96

[Mykola Demko]

Ich bin verwirrt, bitte beraten Sie mich.

Ich habe eine Struktur erstellt, sie mit Daten gefüllt und ein Array von Strukturen erstellt.

Wie kann ich nun ein Array an eine Funktion übergeben, aber nur für ein Element der Struktur ??????????????

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]

Vorschlag an die Entwickler: Wenn möglich, wäre es gut, Standardoperationen mit Strukturen durchzuführen

nicht so:

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;   
  }

sondern so:

void OnStart()
  {
   x+=y;     
  }

Das Kopieren von Strukturen gehört der Vergangenheit an.

[[Gelöscht]]

Urain:

Ich bin verwirrt, bitte beraten Sie mich.

Ich habe eine Struktur erstellt, sie mit Daten gefüllt und ein Array von Strukturen erstellt.

Wie kann man ein Array an eine Funktion übergeben, aber nur für ein Element der Struktur ??????????????

Das können Sie nicht. Und das müssen Sie auch nicht.

Denn - wer hindert die Summierfunktion daran, genau dieses Element zu summieren?

Und so wurde der Code korrigiert, um ihn "koscher" zu machen:

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);
  }

Nur etwas wie ArraySize() sollte in der Realität anstelle von 10 in der for-Schleife innerhalb der Funktion OnStr() verwendet werden. Und anstelle von y in "sum+=x[i].y" summieren Sie das in der Struktur definierte echte Datenfeld (z. B. a oder b).

[[Gelöscht]]

Urain:

Vorschlag an die Entwickler: Wenn möglich, wäre es gut, Standardoperationen mit Strukturen durchzuführen

nicht so:

sondern so:

Das Kopieren von Strukturen gehört der Vergangenheit an.

So etwas gibt es in C++. Das nennt man "Operatorüberladung". Es ist der Programmierer, der mit der entsprechenden Funktion definiert, wie sie funktionieren soll.

Aber diese Funktion sagte Renat "nein". Pech gehabt, was?

[Mykola Demko]

simpleton:

Das kann ich nicht. Und das ist auch nicht nötig.

Denn wer hindert Sie daran, genau dieses Element in der Summationsfunktion zu summieren?

Der Code wurde daher auf "koscher" korrigiert:

Es sollte nur etwas wie ArraySize() anstelle von 10 in der for-Schleife innerhalb der Funktion OnStr() verwendet werden. Und anstelle von y in "sum+=x[i].y" summieren Sie das in der Struktur definierte echte Datenfeld (z. B. a oder b).

Wie immer, wenn ich Beispiele anführe, ist der Punkt weggeflogen, aber es überrascht mich nicht, dass es wahrscheinlich an meiner Knochensprache liegt.

Und das Wesentliche ist: Schreiben Sie eine Funktion des arithmetischen Mittels und dann einfach durch die Übergabe eines Arrays von Strukturen an diese Funktion, erhalten die Struktur des arithmetischen Mittels für jedes der Mitglieder der Struktur.

Das Beispiel ist der Einfachheit halber gegeben, aber wahrscheinlich nicht erfolgreich. Aber danke für die grundsätzliche Klarstellung.

Ich denke, wir sollten den Entwicklern wirklich einen Schlag versetzen, damit sie das "Operator Overloading" erlauben.

[Mykola Demko]

Ja, ich musste eine Reihe von Methoden schreiben, nur um zwei Strukturen zu addieren, zu multiplizieren und zu dividieren,

Am ärgerlichsten ist, dass wir das Ganze noch einmal für andere Strukturen schreiben müssen.

PS Außerdem, Methoden geben Struktur-Typ, um die gleiche Struktur, die wir mit, so dass die verschachtelten Aufruf nicht funktionieren?

Das Ergebnis muss zunächst in einer temporären Struktur gespeichert und dann an die nachfolgende Verarbeitung weitergegeben werden ? es ist nicht klar, warum das so gemacht wird.

PPS Obwohl alle Parameter konstant sind, gibt es keine Möglichkeit, nicht vorhandene Variablen zu ändern.

PPPS Und sorry, Strukturen werden per Referenz übergeben, wie kann man sich auf eine nicht existierende Struktur beziehen (anscheinend ist es Zeit für eine Pause).

[Evgeniy Trofimov]

int sl_pips = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);

Fehlerhafte Bemerkung"möglicher Datenverlust aufgrund der Typkonvertierung"? (Baujahr: 305)

[[Gelöscht]]

Urain:

Ich bin verwirrt, bitte beraten Sie mich.

Ich habe eine Struktur erstellt, sie mit Daten gefüllt und ein Array von Strukturen erstellt.

Wie kann man ein Array an eine Funktion übergeben, aber nur für ein Element der Struktur ??????????????

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);
  }

Einfaltspinsel:

Das können Sie nicht. Und das müssen Sie auch nicht.

Denn - wer hindert die Summierfunktion daran, genau dieses Element zu summieren?

Der Code wird also auf "koscher" eingestellt:

Nur etwas wie ArraySize() sollte tatsächlich verwendet werden, nicht 10 in der for-Schleife innerhalb von OnStr(). Und anstelle von y in "sum+=x[i].y" summieren Sie das in der Struktur definierte echte Datenfeld (z. B. a oder b).

Es gibt zwei Möglichkeiten (soweit ich weiß):

1. Übergeben Sie das Array selbst und geben Sie den Index des Datensatzes, mit dem wir arbeiten wollen, als zusätzlichen Parameter an.

In diesem Fall benötigen wir die Kontrolle über die Dimensionalität des Arrays, und die Funktionsdeklaration würde etwa so aussehen...

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

2. Übergeben Sie das sekundäre Array mit der Dimension eines Datensatzes, bzw. wird die gesamte Arbeit zur Kontrolle und Verarbeitung der Funktionsergebnisse am Funktionsaufrufpunkt gehalten.

Die Funktionsdeklaration sieht dann etwa so aus

OnStr(const Str &x[1])

[[Gelöscht]]

EvgeTrofi:
Fehlerhafte Bemerkung"möglicher Datenverlust aufgrund der Typkonvertierung"? (Baujahr: 305)

Sie müssen das Ergebnis explizit in den Typ int konvertieren.

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

PS

Ein funktionierendes Beispiel können Sie hier sehen - OrderSend()

Aber soweit ich weiß, kann diese Warnung im Prinzip ignoriert werden...

[Evgeniy Trofimov]

Wenn die Rückgabe viele Klammern hat, kommt sie durcheinander!?

Hier ist zum Beispiel eine Funktion, die eine Zahl aus einer Zeichenkette wie "klsfd Schritt 2" zurückgibt:

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);
}

Wie unterscheidet sie sich von dieser?

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);
}

Der zweite Fall führt zu Problemen bei der Kompilierung, der erste jedoch nicht.