OOP, modelli e macro in mql5, sottigliezze e usi - pagina 8

[Vasiliy Sokolov]

Alexey Navoykov:
Ti riferisci alla loro libreria standard? )

No, voglio dire che in MQL non si può dichiarare un metodo virtuale astratto senza implementazione. In MQL, i metodi virtuali di una classe base devono sempre avere un'implementazione, il che è irto dei problemi che hai menzionato.

[Vasiliy Sokolov]

Ilya Malev:

Non ci sono molte interfacce di base in C#

In realtà ce ne sono molti.

Ilya Malev:

Non è tutto negativo, secondo me. Non ci sono così tante interfacce principali di base in C#, secondo me (non sono uno specialista di C#), che non puoi ridurre i loro metodi a una superclasse di base e poi ereditare quello che ti serve.

P.S. Implementare qualcosa di multiplo attraverso costruzioni come <<<<>>>> è un po' una rottura di palle. Meglio fare le funzioni attraverso gli operatori, per esempio a==b chiama a.compareto( b ), a[comparer]==b chiama comparer.compare(a,b) ecc.

Imho, sarebbe un'accozzaglia terribile.

+ La chiamata di metodi virtuali non è libera.

[Alexey Navoykov]

Vasiliy Sokolov:

No, voglio dire che in MQL non si può dichiarare un metodo virtuale astratto senza implementazione. In MQL, i metodi virtuali di una classe base devono sempre avere un'implementazione, il che è irto dei problemi che hai menzionato.

Non sono sicuro del perché non si possa dichiarare senza implementazione? I metodi delle classi astratte sono stati supportati in MQL per anni.

[Ilya Malev]

Vasiliy Sokolov:

1. In effetti, ce ne sono molti.

2. imho, sarebbe un'accozzaglia terribile.

+ La chiamata di metodi virtuali non è gratuita.

1. Lo saprò.

2. Vediamo cosa succede, se riesco a fare bene quello che sto facendo ora, lo posterò sul forum).

Non gratis, sì. Qualsiasi soluzione OOP universale risulta essere costosa, ma se il tuo scopo è quello di costruire facilmente e meravigliosamente semplici Expert Advisor e indicatori (senza caratteristiche speciali), allora ne vale la pena, imho.

[Ilya Malev]

Alexey Navoykov:

Non capisco davvero perché non si può dichiarare senza implementazione? I metodi delle classi astratte sono stati supportati in MQL per anni.

Perché una voce come questa causerà un errore di compilazione:

class A
 {
public:
  virtual int f1() = 0;
  virtual int f2() = 0;
 };
 
class B: public A
 {
public:
  virtual int f1(){ return 1; } 
 };
 
void OnStart()
 {
   B b;
 }

[Alexey Navoykov]

Ilya Malev:

Perché una voce come questa causerà un errore di compilazione:

E la persona ha pensato che è impossibile dichiarare un tale metodo in MQL, per quanto ho capito dal suo post.

[Ilyas]

Poche persone lo sanno (ancora meno quelle che lo sanno e lo usano), ma lefunzioni virtuali pure possono avere un corpo

class A
 {
public:
  virtual int f1() = 0;
  virtual int f2() = 0 { return(0); }
 };

Devono anche essere sovraccaricati nella classe discendente

[Ilya Malev]

Ilyas:

Poche persone lo sanno (ancora meno lo sanno e lo usano), ma lefunzioni puramente virtuali possono avere un corpo

Devono anche essere sovraccaricati nella classe discendente

Quindi le interfacce possono ancora avere il proprio codice di metodo? Si può chiamare in qualche modo? )

Mi sono imbattuto in questo di recente...

[Alexey Navoykov]

Hmm, caratteristica interessante... Immagino che questa sia un'implementazione predefinita, che può essere chiamata nei discendenti come A::f2(). cioè:

class B : public A
{
  virtual int f2() { return A::f2(); }
};

p.s. Ho provato ora però... Anche se A::f2() non ha corpo, il compilatore non reagisce a tale chiamata. Cioè devo catturare un errore più tardi nel runtime. Niente da fare.

[Ilya Malev]

Alexey Navoykov:
Hmm, caratteristica interessante... Immagino sia un metodo predefinito, solo per essere chiamato nei discendenti di A::f2().

Testato - hai ragione in generale =)

Alexey Navoykov:
p.s. Anche se ho provato ora... Anche se A::f2() non ha corpo, il compilatore non reagisce a tale chiamata.

Ho reagito con "stack overflow" )

A quanto pare è uno scarafaggio dopo tutto...

class A
 {
public:
  virtual int f1() = 0 { return 1; }
  virtual int f2() = 0;
 };
 
class B: public A
 {
public:
  virtual int f1(){ return A::f1(); } 
  virtual int f2(){ return A::f2(); } 
 };
 
void OnStart()
 {
   A*a=new B;
   Print(a.f1());
   Print(a.f2());
 }