Errores, fallos, preguntas - página 1438

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

Y cuando se resuelva la cuestión del tamaño del array, sigo pensando que hay que ver qué valores tienen pr_open y pr_close cuando se llaman por primera vez.


P./S.: Aquí no se inicializan:

...
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++];

........
}

y no se puede ver en el código que se les asigne nada.

Aunque tal vez su inicialización esté escondida en algún lugar de estos:

.........

líneas de código que ha ocultado.

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

Exactamente ))) No hay ningún problema con ellos.

En general, es un poco incómodo estar pendiente de la dimensionalidad de un array dinámico todo el tiempo... Necesitas saber cuánto pesa. ¿Qué sentido tiene entonces? ....

La cuestión es que si no se sabe de antemano cuántos elementos se pondrán en él, no hay necesidad de declarar un array estático de un tamaño mayor garantizado (con mucho margen, para que quepa en todos los casos) y desperdiciar memoria. Simplemente, a medida que se añaden nuevos datos a la matriz, se aumenta dinámicamente su tamaño.
 
Сергей Таболин:

En principio, esto es comprensible. Lo único que no entiendo es por qué esta matriz no puede incrementarse automáticamente.

¿Por qué no se puede hacer así? No es mi idea )))) Así es exactamente como intenté usar un array dinámico...

Además tengo que guardar adicionalmente el índice... No es bueno...

¿Quién dice que no se puede ampliar dinámicamente?

Aquí para ayudarte

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 физических перераспределения памяти и это замедлит выполнение программы.

Deberíamos hacer una ayuda sobre cómo utilizar la ayuda )))))))))))))))))))))

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

En principio, esto es comprensible. Lo único que no entiendo es por qué esta matriz no puede incrementarse automáticamente.

int arr[];

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

¿Por qué no se puede hacer así? No es mi idea )))) Así es exactamente como intenté usar un array dinámico...

Además tengo que guardar adicionalmente el índice... No es bueno...

No entiendo lo que intentabas hacer en este código.

A continuación, se ha esbozado un pequeño ejemplo que muestra para qué sirven las matrices dinámicas y cómo utilizarlas.

   // динамический массив строк, в который поместим считанные из файла "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]);
 
Сергей Таболин:

No entiendo por qué esta matriz no puede incrementarse automáticamente.

Porque los desarrolladores del lenguaje fueron educados en Syakh, y esto dificulta enormemente la transición de MQL desde el hardcore SI-like al popsy PHP/JS-like. En el PHP plebeyo uno simplemente asigna un nuevo valor y el array ajusta su tamaño automáticamente. MQL hace que el codificador sienta su importancia. Así que coge una pala y disfruta de formar parte de una selecta casta de profesionales
 
Сергей Таболин:

Este es, en principio, un ejemplo sencillo de cómo debería llenarse normalmente un array dinámico. ¡Hace mucho que no escribo en C, no lo recuerdo, pero así es como se llenan los arrays en php! Todo es lógico y comprensible. Si añado un elemento a un array (arr[] = x), el array se expande automáticamente y el elemento se añade al final del array. Y no tenemos que estirarlo por nosotros mismos, y no tenemos que especificar el índice del elemento por nosotros mismos. Pero aquí tenemos que hacer movimientos absolutamente innecesarios:

la diferencia es evidente...

En mi opinión, es extraño, por decir lo menos ))))

Bueno, pues coge una pala y escribe tu propia implementación de arrays dinámicos, que funcionará exactamente así, ¿qué te lo impide? )) Aunque, para sobrecargar [] para la asignación MKL no permite, no es lo suficientemente duro. ))
 
Сергей Таболин:

Este es, en principio, un ejemplo sencillo de cómo debería llenarse normalmente un array dinámico. ¡Hace mucho que no escribo en C, no lo recuerdo, pero así es como se llenan los arrays en php! Todo es lógico y comprensible. Si añado un elemento a un array (arr[] = x), el array se expande automáticamente y el elemento se añade al final del array. Y no tenemos que estirarlo por nosotros mismos, y no tenemos que especificar el índice del elemento por nosotros mismos. Pero aquí tenemos que hacer movimientos absolutamente innecesarios:

la diferencia es evidente...

Lo encuentro extraño, por decir lo menos ))))

¿Quién nos impide utilizar la POO y aplicar una sintaxis similar?

#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:
Debido a que los desarrolladores del lenguaje fueron criados en Syakh, esto dificulta severamente la transición de MQL de un duro SI-like a un popsy PHP/JS-like. En el PHP plebeyo uno simplemente asigna un nuevo valor y el array ajusta su tamaño automáticamente. MQL hace que el codificador sienta su importancia. Así que coge una pala y disfruta de ser un miembro de los pocos profesionales selectos.
En mi opinión, un simple array no debería "ajustar su tamaño" sin que el programador sea consciente de ello. Si este comportamiento es necesario, hay que escribir la clase correspondiente. Y entonces puedes utilizar una matriz "inteligente" sin problemas. Y las estructuras simples, a las que el array pertenece inicialmente, no deben tener "derechos de decisión independientes".
 
Ya te lo han dicho cuatro personas: coge una pala y escribe tu clase, ya que lo deseas tanto. ))
 
Сергей Таболин:

"sin el conocimiento del programador" no funciona. Es el programador quien da la orden "añadir un elemento al final del array" (arr[] = x). Y el conjunto no tiene "derechos de decisión independientes". Sólo al ejecutar la orden del programador aumenta su tamaño, lo que libera al programador de llevar la cuenta de ese mismo tamaño. )))

Según mi experiencia, si el programador escribe algo en un array que contiene 10 elementos con índice 20, lo más probable es que haya cometido un error, y el programa debería generar un error, pero no aumentar el tamaño del array, ocultando así una acción sospechosa.

Todas estas "matrices que ajustan el tamaño" tienen muchos más problemas a la hora de ocultar posibles errores que a la hora de la comodidad. Además, no tener que llevar la cuenta del tamaño de la matriz es también una práctica potencialmente peligrosa, que conduce a errores difíciles de solucionar.