MQL's OOP notes: Introduction

I have just asked a special question here. I just repeat the code and you can tell what is wrong?

class CQ;  // forward declaration
class CI : public CObject {
   public:
      CI::CI(CQ* &q[], const int id); // contructor
...

} 

CI::CI(CQ* &q[], const int id) {  //  constructor
   ...
   int n = ArraySize(q);  // start to create another (new) instance of CQ
   ArrayResize(q,n+1);    // one more
   q[n] = new CQ(i);      // <= 'CQ' - struct undefined CI.mqh  ERROR??
}

I just want to create a new instance of CQ in the constructor of CI.

A question of understanding.

I need or in OOP is needed a virtual method because this allows to use the same method name with either a different setup or the same parameter setup (and a different body)?

If all methods with the same name do have different parameter setups (and different bodies) I wouldn't need a virtual method as the principle of overloading would be able to handle that.

Is that correct?

Not exactly. Virtual methods should have the same signature in base and derived class. If you have different signatures this will be function overloading (no virtual keyword needed and even allowed), while virtual "replacement" is called overriding. If a function is marked by virtual keyword in a base class, you can't redefine it with the same name but different signature in derived class (compiler error). The difference between overloading and overriding is in that overloading happens at compile time (a function of specific class is chosen based on variable type), whereas overriding is resolved at runtime (a function is chosen based on specific type of value stored in a variable - this can be any derived class).

You should use virtual if you needed to adjust behaviour in derived class.

Hmm - it means simply that a method with the same name in the base class and the derived class and

• with the same parameters handed over (signature?) and a different body needs virtual in its declaration in the base class
• with different parameters handed over (signature?) and a different body must not have virtual in its declaration in the base class.

Why should it be of any importance for me as programmer when a method is resolved? How does this might change the behaviour of the executed derived class?

PS.: I hope you don't mind me being so nasty, but I don't really speak 'OOP' yet.

Add. question acc. to my cross referencing classes. What if I define it like here:

// file CQI.mqh

class CQ;  // forward declaration
class CI //: public CObject
{
   public:
      CI(CQ* &q[], const int id); // contructor
      virtual int calc() { return(-1); }
}; 

//file CQ.mqh
class CQ
{
  public:
    CQ(int i){};
};

//#####   library of methods for both    ######//
// ....
CI::CI(CQ* &q[], const int id)
{
  int i = 0;
  int n = ArraySize(q);  // start to create another (new) instance of CQ
  ArrayResize(q,n+1);    // one more
  q[n] = new CQ(i);      // and now??
}

Now I want to write a derived class of CI, especially the method calc()... So I tried to create a new class in a new TestDervCI.mqh and got quite some compiler errors :(

#include <CQI.mqh>
class TestDervCI : public CI {
public:
         virtual int calc(void);
};
int TestDervCI::calc(void) {
   return( 2+4 );
}

No compiler error so far :)

But this means:

1. I don't need another constructor/destructor - but what if a I would need another constructor?
2. "virtual" is needed only within the class definition, not where I define the body of the method: int TestDervCI::calc(void) { ...
3. I get no compiler error I write: class TestDervCI : public CI {  public:  int calc(void); };  - without virtual ??? Despite the base class CI owns this method, same name same parameters, ..?
4. Even if I remove "virtual" in the base class CI and in the derived class TestDervCI I don't get any compiler complains ??
   

But trying to enter a constructor - I fail :(   So here I am with constructor and errors

#include <CQI.mqh>
class TestDervCI : public CI {
public:
         TestDervCI() : CI(){};  // contructor ??
         virtual int calc(void);
};
int TestDervCI::calc(void) {
   return( 2+4 );
}

No matter what I try to enter in the ()-brackets the compiler complains. How to do it correctly?

Your approach for understanding OOP is wrong in the sense, that your requirements should go first, and the keywords go second. You try to do vice versa.

You can have methods with the same signatures in base and derived class with or without virtual keyword - according to your requirements (I described the difference in their behaviour in my previous comment). If parameters differ, then - in the first place - you have no need in virtual keyword (because methods are overloaded), and - in the second place - you can't do this because compiler can not override methods with different signatures.

Well if you don't feel when you need a virtual method which is resolved dynamically, then it's probably not required for your task, because otherwise it should become obvious. Virtual methods are chosen against actual type of stored object (not a type of variable), so your question about changing behaviour of a derived class is incorrect - there will be different methods from different derived classes, so not a method is changed but algorithm is changed by switching between different methods.

As for your specific problems with your code, please post details on the forum. It's still not clear what you want to achieve, whether you have errors or not, and which errors exactly. You're trying to ask too many questions at once. I don't understand.

If you don't have a default constructor in base class, then in a derived class constructor you need to call some of non-default existing base constructors.

The keyword "virtual" can be omitted in a derived class, yet the method declared in base class as virtual will remain virtual, but good programming style requires to specify virtual in all cases - in base class and all its descendants. This eliminates accidental errors which may arise if you think you override a  virtual method, but actually made a mistake (say, in parameters) and define another overloaded method instead. If you remove virtual keyword in base and derived methods this is still correct, because you define 2 different method implementations - each in its class. They will be resolved statically - at compile time - according to a variable type (used to access the method) or explicit namespace specification. For example, you can call Base::method() from a code of a method in derived class.

There is an important remark on compiling many of MQL examples, presented here, on builds 1860+.