Errori, bug, domande - pagina 216

[Alexey Da]

Vigor:

Ho incontrato un problema di overflow dello stack di chiamata (così penso).

Dopo aver chiamato un metodo di uno degli oggetti, vedi esempio qui sotto. Il codice è semplificato, solo il succo. La classe CClass1 è una classe base e list1 ha diversi oggetti che sono discendenti di questa classe e le loro funzioni init sono implementate in modo diverso. Così, in una classe in cui la funzione init recupera una tale lista (per dirla semplicemente, inizializza un'interfaccia annidata, un pannello nel pannello) dopo il ritorno da init nella linea

c'è un errore

2010.12.02 00:21:00 test1 (EURUSD,H1) Accesso al puntatore non valido in 'Container.mqh' (74,10)

Cioè il puntatore t è morto.

Quando si esegue il debug, non c'è questo errore, dopo la chiamata del metodo il puntatore è "vivo", le interfacce annidate sono create e Expert Advisor funziona ulteriormente.

Questo è l'unico modo per aggirare l'errore:

#proprietà stacksize puntatore non ha ottenuto nulla.

È difficile dire qualcosa di sicuro. Avete bisogno del codice sorgente.

Prova a scrivere una richiesta a servicedesk.

[Aleksandr Chugunov]

Sono tornato dalle vacanze, ho iniziato i terminali, ho aggiornato alla build 360 e un indicatore ha smesso di funzionare...

Ho letto le modifiche: 6. MQL5: Corretta l'elaborazione dell'evento click su un grafico.

Ora quando si clicca su un oggetto grafico vengono generati due eventi contemporaneamente: CHARTEVENT_OBJECT_CLICK + CHARTEVENT_CLICK, mentre prima c'era solo un CHARTEVENT_OBJECT_CLICK, che permette di simulare un doppio clic

Sarà sempre così o è un bug?

[Alexey Da]

AlexSTAL:

Tornato dalle vacanze, avviato i terminali, aggiornato alla build 360 e un indicatore ha smesso di funzionare...

lettura in cambiamenti: 6. MQL5: Corretta l'elaborazione dell'evento click su un grafico.

Ora quando si clicca su un oggetto grafico vengono generati due eventi contemporaneamente: CHARTEVENT_OBJECT_CLICK + CHARTEVENT_CLICK, mentre prima c'era solo un CHARTEVENT_OBJECT_CLICK, che permette di simulare un doppio clic

Sarà sempre così o è un bug?

Questo è stato fatto intenzionalmente.

[Mykola Demko]

Ancora una volta ho colpito il muro dell'impossibilità,

Ho bisogno di passare un parametro al costruttore, in modo che la classe sia inizializzata con certi parametri,

come posso aggirare questo problema, cosa mi consigliate?

[Aleksey Sergan]

Urain:

Ancora una volta ho colpito il muro dell'impossibilità,

Ho bisogno di passare un parametro al costruttore perché la classe sia inizializzata con certi parametri,

Come posso aggirare questo problema?

к

Beh, non vedo altra via d'uscita

class test{
  private:
    bool inited;
    int value;  
  public:
    void test(){
      inited = false;
    }
    
  bool Set( int passed ){
    value = passed;
    return(true);
  }
  bool Init( int passed ){
    if ( Set( passed ) ){
      inited = true;
      return(true);
    }
    return(false);
  }
  int Get( ){
    if( !inited ){
      Print("Объект неинициализирован");
      return(-1);
    }
    return(value);
  }
};

void OnStart()
  {
  
  
  test var;
  if( !var.Init(1)){
    Print("Ошибка инициализации объекта");
    return;
}
  Print(var.Get());
  
  test var2;
  Print( var2.Get() );
  }

e, naturalmente, dovete mettere gli Init nel giusto ordine nel caso di classi ereditate

Vorrei che scrivessero un articolo sulla gestione degli errori in progetti complessi,Print and return come qui non è la soluzione.

[Mykola Demko]

gdtt:

Beh, non vedo altre vie d'uscita.

E, naturalmente, dovete mettere gli Init nel giusto ordine nel caso di classi ereditate

In generale, vorrei che scrivessero un articolo sulla gestione degli errori in progetti complessi, Stampa e restituzione come qui non è la soluzione.

Cioè, per creare un pre-costruttore che completerebbe il processo di costruzione, e che a sua volta visualizza un flag di inizializzazione.

In generale, è una buona soluzione, ma ci sono alcuni inconvenienti. Dobbiamo interrogare ogni funzione con il flag di inizializzazione, e con un gran numero di funzioni di classe, non è conveniente.

E se dovessimo cambiare qualcosa, tutte le funzioni dovrebbero essere riscritte.

SZ Ho modificato il codice, ho corretto il refuso.

class test
  {
private:
   bool              inited;
   int               value;
public:
                     test(void){inited=false;};
   bool Set(int passed){value=passed;return(true);};
   bool Init(int passed)
     {
      if(Set(passed))inited=true;    
      return(inited);
     };
   int Get()
     {
      if(!inited)
        {
         Print("Объект неинициализирован");
         return(-1);
        }        
      return(value);
     };
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {

   test var;
   var.Init(1);
   Print(var.Get());

   test var2;
   Print(var2.Get());
  }

[Aleksey Sergan]

Urain:

Cioè creare un pre-costruttore che completerebbe il processo di costruzione, e che a sua volta imposta un flag di inizializzazione.

In generale, è bello, ma ci sono alcuni inconvenienti. Dovremo interrogare ogni funzione per il flag di inizializzazione, e con un gran numero di funzioni di classe, questo non è conveniente.

Il codice per la prima volta è stato aggiornato come per la seconda volta.

SZ Ho modificato il codice, ho corretto la svista.

Beh, se ci fosse un costruttore, non significherebbe che l'inizializzazione sia avvenuta con successo. in ogni caso, è necessario verificare il fatto dell'inizializzazione

Naturalmente si può controllare una volta:

void OnStart()
  {

   test var;
   if( ! var.Init(1)){
     // здесь какято обрабтка
     return;
   };
   Print(var.Get());

   test var2;
   Print(var2.Get());
  }

Ma se usate il vostro codice, potete fare una regola per controllare il fatto dell'inizializzazione al momento della chiamata, e se sarà usato da altri, non potete scrivere nelle istruzioni: "dovete usare solo questa costruzione, altrimenti non posso garantire per le conseguenze". No, dovete comunque controllare l'inizializzazione nei metodi di classe.

[[Eliminato]]

Agli sviluppatori.

Subito dopo il riavvio della nuova costruzione

PS

L'aggiornamento del terminale installato in un'altra cartella ha avuto successo, i simboli sono nella lista (ma non c'erano grafici aperti prima dell'aggiornamento)...

[Sergey Gritsay]

Ditemi se questo è un bug o se non è permesso.

ENUM_ORDER_TYPE Signal[21];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   ArrayInitialize(Signal,WRONG_VALUE);
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Dà un errore

'ArrayInitialize' - no one of the overloads can be applied to the function call 

[[Eliminato]]

sergey1294:

Per favore, ditemi se questo è un bug o non è permesso.

Si otterrà un errore

Molto probabilmente, il punto è che ArrayInitialize() è destinato a riempire solo gli array di un certo tipo, numerico per essere esatti (molto probabilmente int o double).

Poiché l'array ha il tipo ENUM_ORDER_TYPE, la chiamata di ArrayInitialize causerà un errore, dicendo che questo metodo di chiamata non è permesso.

Secondo me, ci sono due opzioni in questo caso:

1. cambiare il tipo di array ENUM_ORDER_TYPE in int, tenendone conto nel codice (almeno i tipi di ordine possono essere facilmente rappresentati come int);

2. Implementare indipendentemente l'"inizializzazione" dell'array.