Erros, bugs, perguntas - página 96

[Mykola Demko]

Estou confuso, por favor aconselhem-me.

Eu criei uma estrutura, preenchi-a com dados, criei uma série de estruturas.

Como posso agora passar uma matriz para uma função, mas apenas num elemento da estrutura ??????????????

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]

Sugestão aos desenvolvedores, se possível seria bom realizar operações padrão com estruturas

não é assim:

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

mas assim:

void OnStart()
  {
   x+=y;     
  }

Copiar estruturas é uma coisa do passado.

[[Excluído]]

Urain:

Estou confuso, por favor aconselhem-me.

Eu criei uma estrutura, preenchi-a com dados, criei uma série de estruturas.

Como passar uma matriz para uma função, mas apenas para um elemento da estrutura ??????????????

Não pode. E não é necessário.

Porque - quem impede a função de soma de resumir apenas esse elemento?

E assim o código foi corrigido para o tornar "kosher":

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

Apenas algo como ArraySize() deve ser usado na realidade em vez de 10 na função de loop dentro da função OnStr(). E em vez de y em "soma+=x[i].y" soma o campo de dados real definido na estrutura (a ou b, por exemplo).

[[Excluído]]

Urain:

Sugestão aos desenvolvedores, se possível seria bom realizar operações padrão com estruturas

não é assim:

mas assim:

A cópia de estruturas é uma coisa do passado.

Há uma coisa assim em C++. Chama-se "sobrecarga do operador". É o programador que define como deve funcionar utilizando a função correspondente.

Mas esta função Renat disse "não". Má sorte, eh?

[Mykola Demko]

simpleton:

Não posso. E não há necessidade disso.

Porque quem o impede de somar exactamente esse elemento na função de somatório?

Assim, o código foi corrigido para "kosher":

Apenas algo como ArraySize() deve ser usado em vez de 10 na função de loop dentro da função OnStr(). E em vez de y em "soma+=x[i].y" soma o campo de dados real definido na estrutura (a ou b, por exemplo).

Como sempre quando dou exemplos, o ponto voou para longe, mas não me surpreende que seja provavelmente por causa do meu falatório ósseo.

E a essência é esta: escrever uma função da média aritmética e depois, simplesmente passando uma série de estruturas para esta função, obter a estrutura da média aritmética para cada um dos membros da estrutura.

O exemplo é dado por simplicidade, mas provavelmente sem sucesso. Mas, em princípio, obrigado pelos esclarecimentos.

Acho que devíamos mesmo bater com os programadores para permitir "sobrecarga do operador".

[Mykola Demko]

sim tive de escrever um monte de métodos apenas para acrescentar, multiplicar, dividir, duas estruturas,

o mais irritante é que teremos de escrever tudo novamente sobre outras estruturas.

PS Além disso, os métodos dão tipo de estrutura à mesma estrutura com que operamos, pelo que a chamada aninhada não funciona ????

o resultado precisa primeiro de ser guardado numa estrutura temporária e depois passado para o processamento subsequente ?? não é claro porque é que é feito assim.

PPS Embora todos os parâmetros sejam constantes, não há possibilidade de alterar a variável inexistente.

PPPS E desculpe, as estruturas são passadas por referência, como se pode referir a uma estrutura inexistente (aparentemente, é tempo de descansar).

[Evgeniy Trofimov]

int sl_pips = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);

Observação errónea"possível perda de dados devido à conversão do tipo"? (Construir: 305)

[[Excluído]]

Urain:

Estou confuso, por favor aconselhem-me.

Eu criei uma estrutura, preenchi-a com dados, criei uma série de estruturas.

Como passar uma matriz para uma função, mas apenas para um elemento da estrutura ??????????????

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

simplório:

Não pode. E não é necessário.

Porque - quem impede a função de soma de resumir apenas esse elemento?

Assim, o código é ajustado para "kosher":

Apenas algo como ArraySize() deve ser realmente utilizado, e não 10 no laço dentro do OnStr(). E em vez de y em "soma+=x[i].y" soma o campo de dados real definido na estrutura (a ou b, por exemplo).

Há duas maneiras (tanto quanto sei):

1. Passar a matriz em si, especificando o índice do registo com o qual vamos trabalhar como parâmetro adicional.

Neste caso, precisamos de controlo sobre a dimensionalidade da matriz, e a declaração da função pareceria algo assim...

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

2. Passar a matriz secundária com a dimensão de um registo, respectivamente todo o trabalho de controlo e processamento dos resultados da função é realizado no ponto de chamada da função.

A declaração de função terá então um aspecto semelhante ao seguinte

OnStr(const Str &x[1])

[[Excluído]]

EvgeTrofi:
Observação errónea"possível perda de dados devido à conversão do tipo"? (Construir: 305)

É necessário converter explicitamente o resultado para o tipo int.

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

PS

Pode ver um exemplo de trabalho aqui - OrderSend()

Mas, tanto quanto sei, este aviso pode ser ignorado em princípio.

[Evgeniy Trofimov]

Se o retorno tem muitos parênteses - começa a ficar confuso!?

Aqui, por exemplo, é uma função que devolve um número de uma cadeia como "klsfd Passo 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);
}

Qual é a sua diferença em relação a este?

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

O segundo causará problemas de tempo de compilação, mas o primeiro não.