Domanda sulla digitazione - pagina 2

Nuovo commento
 
Ilya Malev:

Bene, in altre parole avete ripetuto quello che ho scritto. La domanda non era se può o non può, ma perché non può e come possiamo elegantemente lavorare intorno a questo

scrivere solo funzioni per le conversioni e non preoccuparsi degli switch all'interno dei metodi?

doppio Double(CParameter<double>)

stringa String(CParameter<double>)

e usare :

PrintFormat("%s %s %f",String(param1),String(param2),Double(param1));

Qual è la differenza tra usare un operatore unario o una funzione nominata? Una funzione è meglio - un operatore ha già un carico semantico e non si vuole cambiarlo a piacimento.

 
fxsaber:

Il controllo del tipo è perso. Guarda le risorse C++ per le risposte a queste domande. Penso che vengano chiesti abbastanza spesso.

Bene, almeno è chiaro che questa non è una limitazione di mql, ma una caratteristica del C++ in generale, e grazie per questo :)

 
L'incapacità di sovraccaricare gli operatori senza collegare l'lparam dell'operatore sovraccaricato a un oggetto o una struttura specifica è anche una caratteristica del C++?
 
Ilya Malev:

Con l'overloading esplicito e le azioni aritmetiche tutto è chiaro. Sì, overloaded = è chiaramente meglio in questo caso, hai ragione, stavo solo costruendo frettolosamente un esempio per una domanda e non ci ho pensato veramente (anche se il numero non è solo int, ma anche char, uchar, short, ushort, uint, bool e color, quindi non tutto è univoco )))))))


Il problema qui è che il tipo di valore di ritornodel metodo sovraccaricato dipende dal contenuto dell'oggetto.

Per esempio, abbiamo un array multi-tipo (non citerò esempi, perché ci sono molti libri). E naturalmente, qualsiasi array deve avere l'operazione di indicizzazione [] che restituisce il valore di una variabile con un indice appropriato.

Ma le variabili hanno tipi diversi. Potrebbe essere datetime o stringa o anche qualche tipo definito dall'utente sotto questo indice. E idealmente, vorrei che il tipo di valore di ritorno generasse automaticamente il tipo appropriato quando si indicizza [], senza doverlo parametrizzare esplicitamente. Risolvevo questo "problema" in questo modo: var[(char)1], var[(short)1], var[(uint)1], etc., ma queste stampelle sono inutili.

Usare un array di strutture come mqlparam.

 
Dmitry Fedoseev:

Un array di strutture come mqlparam.

Non può essere equiparato al doppio, alla stringa o al lungo allo stesso modo.

MqlParam par;

par.double_value = Ask;

double d = par; // '=' - operazione illegale uso

 
Ilya Malev:

Non si può equiparare allo stesso modo a un doppio, a una stringa o a un lungo.

MqlParam par;

par.double_value = Ask;

double d = par; // '=' - operazione illegale uso

Si vede che tipo è e lo si assegna al campo appropriato. Sembra un approccio storto e si sta ancora cercando una soluzione perfetta. Un tale compito non dovrebbe presentarsi affatto.

 
Ilya Malev:
L'impossibilità di sovraccaricare gli operatori senza collegare l'operatore sovraccaricato a un oggetto o una struttura specifica è anche una caratteristica del C++?

Questo è quello che dice internet su questo:

L'overloading di funzioni non è possibile se differiscono solo per il tipo di valore di ritorno.

C++14 standard 13.1/2:

 

Ho trovato questo in rete nelle risposte a una domanda simile:

template<typename T> T f();
template<> int f() { return 2; }
template<> double f() { return 2.7; }

//...
struct F {
    F() {}
    template<typename T> operator T() { return f<T>(); }
};

int x2 = F();
double y2 = F();


Per come la vedo io, l'operatore operatore è sovraccaricato qui al tipo "operatore T()" - significa che in C++ è almeno possibile. Ma in mql come ho capito non lo è ancora.

 
Ilya Malev:
una domanda simile: perché quando si sovraccarica un metodo (nella firma del metodo sovraccaricato) il tipo di ritorno non appare, ma solo i tipi di parametro. cioè non si possono definire due metodi identici con diversi tipi di valore di ritorno. perché è fatta questa restrizione? qual è il punto in questo, perché non si può sovraccaricare un metodo dal tipo di valore di ritorno con parametri identici

Questo è probabilmente il motivo:

int f() {
   call_something();
   return 0;
}

double f() {
   call_something_other();
   return 0;
}

void start() {
   f();
}

Quale funzione dovrebbe essere chiamata esattamente?

 
pavlick_:

Probabilmente è questo il motivo:

Quale funzione dovrebbe essere chiamata esattamente?

Un errore di template mismatch dovrebbe probabilmente verificarsi in fase di compilazione.


Ma nella situazione in cui c'è un oggetto array

class Array{

public:

Array *operator[] (int i){ id = i; return GetPointer( this ); }

double operator[]( int i){ id = i; return data[i]; }

Array *operator=(double d){ data[id]=d; return GetPointer( this ); }

private:

double data[10];

int id;

};



int OnStart(){

  Array array;

  double d=123.456;

  array[5]=d;

  d=array[5];

}

tale errore non dovrebbe verificarsi perché nel primo caso la chiamata dell'operazione Array[int] è usata come parametro sinistro = e non è variabile doppia, ma nel secondo caso è quello destro, e il parametro sinistro è variabile di tipo doppio.

Quindi, tutto sommato si tratta di voler introdurre in mql la possibilità di sovraccaricare l'operazione di digitazione (anche implicita), cioè definire il contesto per la chiamata del metodo e a seconda del tipo previsto in questo contesto di valore restituito, chiamare il codice richiesto. E se il contesto non è definito esplicitamente, genererà un errore.

12345678910
Nuovo commento
Motivazione: