Erros, bugs, perguntas - página 1438

Novo comentário
 
Сергей Таболин:

E quando a questão com o tamanho da matriz for resolvida, continuo a pensar que deve ver quais os valores pr_open e pr_close quando são chamados pela primeira vez.


P./S.: Não são rubricados aqui:

...
int            buf_lup[], buf_ldn[];
...
void OnTick()
{
   int      lup, ldn, sup, sdn;
   int      sum_up, sum_dn;
   double   pr_open, pr_close;

.........

      ldn = 0;
      sup = 0;
      sdn = 0;
      sum_up = 0;
      sum_dn = 0;

.........

               buf_ldn[ldn] = (int)((pr_open - pr_close) / Point()); // ОШИБКА тут
               sum_dn += buf_ldn[ldn++];

........
}

e não se pode ver no código que nada lhes é atribuído.

Embora talvez a sua iniciação esteja escondida algures neles:

.........

linhas de código que tem escondidas.

 
Сергей Таболин:

Exactamente )))) Não há qualquer problema com eles.

De um modo geral, é um pouco inconveniente manter sempre um registo do tamanho de uma matriz dinâmica... É preciso saber quanto pesa. Qual é então o objectivo? ....

A questão é que se não souber antecipadamente quantos elementos serão colocados, não há necessidade de declarar um conjunto estático de um tamanho maior garantido (com bastante margem, para que dure para todas as ocasiões) e desperdiçar memória. Simplesmente, como novos dados precisam de ser adicionados à matriz, aumenta-se dinamicamente o seu tamanho.
 
Сергей Таболин:

Em princípio, isto é compreensível. A única coisa que não compreendo é porque é que esta matriz não pode ser incrementada automaticamente.

Porque não pôde ser feito dessa forma? A ideia não é minha )))) Foi exactamente assim que tentei usar uma matriz dinâmica.

Além disso, tenho de salvar o índice... Não é bom...

Quem diz que não se pode aumentá-lo dinamicamente?

Aqui para o ajudar

ArrayResize

Устанавливает новый размер в первом измерении массива



int  ArrayResize( 
   void&  array[],              // массив, переданный по ссылке 
   int    new_size,             // новый размер массива 
   int    reserve_size=0        // резервное значение размера (избыточное) 
   );
 

Параметры

array[]

[out]  Массив для изменения размеров.

new_size

[in]  Новый размер для первого измерения.

reserve_size=0

[in]  Необязательный параметр. Размер для дополнительного резерва.

Возвращаемое значение

При успешном выполнении функция возвращает количество всех элементов, содержащихся в массиве после изменения размера; в противном случае возвращает -1 и массив не меняет размеры.

Примечание

Функция может быть применена только к динамическим массивам. При этом необходимо иметь ввиду, что нельзя изменять размер для динамических массивов, назначенных в качестве индикаторных буферов функцией SetIndexBuffer(). Для индикаторных буферов все операции по изменению размера производит исполняющая подсистема терминала.

Общее число элементов в массиве не может превышать 2147483647.

При частом распределении памяти рекомендуется использовать третий параметр, задающий резерв для уменьшения количества физического распределения памяти. Все последующие вызовы функции ArrayResize не приводят к физическому перераспределению памяти, а только меняется размер первого измерения массива в пределах зарезервированной памяти. Следует помнить, что третий параметр будет использоваться только тогда, когда будет происходить физическое распределение памяти, например:



ArrayResize(arr,1000,1000); 
for(int i=1;i<3000;i++) 
   ArrayResize(arr,i,1000);
 

В данном случае произойдёт 2 перераспределения памяти, один раз до входа в цикл на 2000 элементов, при этом размерность массива будет установлена в 1000 и второй при i равной 2000. Если третий параметр опустить, то произойдёт 2000 физических перераспределения памяти и это замедлит выполнение программы.

Devemos fazer uma ajuda sobre como utilizar a ajuda )))))))))))))))))))))

 
Сергей Таболин:

Em princípio, isto é compreensível. A única coisa que não compreendo é porque é que esta matriz não pode ser incrementada automaticamente.

int arr[];

arr[] = 1;
arr[] = 9;
arr[] = 3;
....

Porque não pôde ser feito dessa forma? A ideia não é minha )))) Foi exactamente assim que tentei usar uma matriz dinâmica.

Além disso, tenho de salvar o índice... Não é bom...

Não compreendo o que estava a tentar fazer neste código.

Aqui, esboçámos um pequeno exemplo mostrando para que servem as matrizes dinâmicas e como utilizá-las.

   // динамический массив строк, в который поместим считанные из файла "FileName.txt" строки,
   // количество строк в файле нам неизвестно
   string Strings[];
   ArrayResize(Strings, 0, 20);   // сейчас это массив нулевой длины
   
   // открываем текстовый файл для чтения
   int hFile = FileOpen("FileName.txt", FILE_READ|FILE_TXT);
   
   if(hFile != INVALID_HANDLE)
   {
      // каретку в начало файла
      FileSeek(hFile, 0, SEEK_SET);
      
      // вспомагательные переменные
      string sString;
      int nTotalStrings = 0;
      
      // читаем файл построчно
      while(!FileIsEnding(hFile) && !IsStopped())
      {
         // считываем очередную строку
         sString = FileReadString(hFile);
         
         // добавляем считанную строку в массив, предварительно увеличив его размер на 1
         if(sString != "")
         {
            nTotalStrings++;
            ArrayResize(Strings, nTotalStrings, 20);
            Strings[nTotalStrings-1] = sString;
         }
      }
      
      // уходя, гасите свет
      FileClose(hFile);
   }
   
   // выведем считанные строки в журнал для проверки
   for(int i = 0; i < ArraySize(Strings); i++)
      Print(Strings[i]);
 
Сергей Таболин:

Não compreendo porque é que esta matriz não pode ser incrementada automaticamente.

Porque os criadores de linguagens foram educados em Syakh, e isto dificulta seriamente a transição do MQL do tipo hardcore SI para o tipo popsy PHP/JS. No PHP plebeu atribui-se simplesmente um novo valor e a matriz ajusta o seu tamanho automaticamente. MQL faz o codificador sentir a sua importância. Portanto, pegue numa pá e desfrute de fazer parte de uma casta seleccionada de profissionais
 
Сергей Таболин:

Este é, em princípio, um exemplo simples de como uma matriz dinâmica deve ser normalmente preenchida. Já não escrevo em C há muito tempo, não me lembro, mas é assim que as matrizes são preenchidas em php! Tudo é lógico e compreensível. Se eu adicionar um elemento a um array (arr[] = x), o array é automaticamente expandido, e o elemento é adicionado ao fim do array. E não temos de o esticar sozinhos, e não temos de especificar o índice do elemento por nós próprios. Mas aqui temos de fazer movimentos absolutamente desnecessários:

a diferença é óbvia...

Na minha opinião, é estranho, para dizer o mínimo ))))

Bem, então pegue numa pá e escreva a sua própria implementação de matrizes dinâmicas, que funcionarão exactamente dessa forma, o que o impede? )) Embora, para sobrecarregar [] a MKL não o permita, não é suficientemente difícil. ))
 
Сергей Таболин:

Este é, em princípio, um exemplo simples de como uma matriz dinâmica deve ser normalmente preenchida. Já não escrevo em C há muito tempo, não me lembro, mas é assim que as matrizes são preenchidas em php! Tudo é lógico e compreensível. Se eu adicionar um elemento a um array (arr[] = x), o array é automaticamente expandido, e o elemento é adicionado ao fim do array. E não temos de o esticar sozinhos, e não temos de especificar o índice do elemento por nós próprios. Mas aqui temos de fazer movimentos absolutamente desnecessários:

a diferença é óbvia...

Acho estranho, para dizer o mínimo ))))

Quem nos impede de utilizar o OOP e de implementar uma sintaxe semelhante?

#property strict

/*
enum TestEnum
{
  zero,
  one,
  two,
  three,
  four,
  five,
  six,
  seven,
  eight,
  nine,
  ten,
  eleven,
  twelve,
  thirteen,
  fourteen,
  fitteen
};
*/

template <typename T>
class RubbArray
{
  private:
    T data[];
    
  protected:
    void add(T d)
    {
      int n = ArraySize(data);
      ArrayResize(data, n + 1);
      data[n] = d;
    }
    
  public:
    
    T operator[](int i) const
    {
      return data[i];
    }
    
    RubbArray *operator<<(T d)
    {
      add(d);
      return GetPointer(this);
    }

    T operator=(T d)
    {
      add(d);
      return d;
    }

    void operator=(const RubbArray &d)
    {
      int i, n = d.size();
      ArrayResize(data, n);
      for(i = 0; i < n; i++)
      {
        data[i] = d[i];
      }
    }

    T operator>>(int i)
    {
      T d = this[i];
      ArrayCopy(data, data, i, i + 1);
      ArrayResize(data, ArraySize(data) - 1);
      return d;
    }
    
    int size() const
    {
      return ArraySize(data);
    }
    
    void print() const
    {
      int i, n = ArraySize(data);
      string s;
      for(i = 0; i < n; i++)
      {
        s += (string)data[i] + ",";
      }
      Print(s);
    }
};

void OnStart()
{
  //RubbArray<TestEnum> d;
  RubbArray<double> d, d2;
  d << 5 << 7;
  d = 10;
  d << 15;
  d.print();
  Print(d[1]);
  double x = d >> 1;
  d2 = d;
  d2.print();
}
 
Alexander Puzanov:
Porque os criadores de linguagens foram educados em Syakh, isso dificulta seriamente a transição do MQL do tipo hardcore SI para o tipo popsy PHP/JS. No PHP plebeu atribui-se simplesmente um novo valor e a matriz ajusta o seu tamanho automaticamente. MQL faz o codificador sentir a sua importância. Por isso, pegue numa pá e desfrute de ser um membro dos poucos profissionais seleccionados.
Na minha opinião, uma simples matriz não deve "ajustar o seu tamanho" sem que o programador esteja ciente disso. Se tal comportamento for necessário, uma classe correspondente deve ser escrita. E depois pode utilizar um conjunto "inteligente" sem qualquer problema. E estruturas simples, às quais a matriz inicialmente pertence, não devem ter "direitos de decisão independentes".
 
Quatro pessoas já lhe disseram - arranje uma pá e escreva a sua aula, já que a quer tanto. ))
 
Сергей Таболин:

"sem o conhecimento do programador" não funciona. É o programador que dá o comando "adicionar um elemento ao fim da matriz" (arr[] = x). E a matriz não tem "direitos de decisão independentes". Só executando o comando do programador é que este aumenta o seu tamanho, aliviando assim o programador de se manter a par desse mesmo tamanho. )))

Como a minha experiência mostra, se o programador escreve algo num array contendo 10 itens com índice 20, muito provavelmente significa que cometeu um erro, e o programa deve gerar um erro, mas não aumentar o tamanho do array, escondendo assim uma acção suspeita.

Todas estas "matrizes que afinam o tamanho" têm muito mais problemas em esconder potenciais erros do que em esconder a conveniência. Além disso, e não ter de controlar o tamanho da matriz é também uma prática potencialmente perigosa, levando a bugs difíceis de corrigir.

1...143114321433143414351436143714381439144014411442144314441445...3184
Novo comentário