Is it possible to override a function in C++ child

Question

class Parent {
public:
    void func1(); // Complete meaningful definition in parent given.

    virtual HRESULT func2()=0;  // Bcoz of this function Parent class is abstract. 
};


class Child: public Parent {
public:
    void func1(); // Different definition in child.
};

Is this possible in C++ ? I am overriding func1() which is NOT virtual and it already has a definition in parent abstract class.

Answer 1

Most has been said.

Your expectations would be right if you talk about java. In java any non-private, non-final method could be overridden. Maybe you are more familiar with an other programming language than C++

By the way, two things are wrong in your code

• "class" must be written lower case
• the default access of members in class is "private". It is NOT allowed nor useful to override private members which are non-pure

Answer 2

You can overload it, if they have distinct argument types.

You can hide it, in the sense shown here, so that Child::func1 will be called instead of Parent::func1 in code that knows it's looking at a child instance. However, as amit points out, you don't get dynamic dispatch.

---

struct StaticParent {
  void foo();
};
struct StaticChild : public StaticParent {
  void foo();
}

StaticChild sc;
sc.foo(); // calls StaticChild::foo

StaticParent &sp = sc;
sp.foo(); // calls StaticParent::foo

---

struct VirtualParent {
  virtual void foo();
};
struct VirtualChild : public VirtualParent {
  virtual void foo();
}

VirtualChild vc;
vc.foo(); // calls VirtualChild::foo

VirtualParent &vp = vc;
vp.foo(); // calls VirtualChild::foo

Answer 3

No, it's not possible to actually override the definition in the parent (at least when talking about C++, "override" is normally reserved specifically to referring to virtual functions). Instead, defining a function with the same name in the child class simply hides the function in the parent that has the same name (i.e., in the context of a child object, looking for that name will only find the function in the child, not the one in the parent).

If you want to (and the functions have different signatures) you can also get the functions in both the parent and the child treated as overloaded, so a call will try to call whichever matches better:

struct parent {
    void func1(char) {}
};

struct child : public parent { 
    void func1(long) { }

    using parent::func1;
};

Now, you get:

child c;
c.func1('a'); // calls parent::func1
c.func1(123L); // calls child::func1

This is yet a third type of behavior though, different from having a virtual function or having a function in the child that hides the one in the parent.

With a virtual function, the selection of which function is called is based on the dynamic type, so if you have a pointer/reference to the base class, the function called depends on whether that refers to an object of the base or derived class.

When you hide the function, the function that's called is based on the static type, so if you call it via a pointer/reference to the base, it calls the base function, even if that actually refers to an object of the derived class. If, however, you use a pointer or reference to (or directly use an instance of) the derived class, it'll invoke the function in the derived class.

With the using statement, you get function overloading, so when you call the function (in the context of the derived class) the function that's called is based on which function's signature is the best match for the parameter(s) you pass.

Answer 4

Yes, this is valid C++ syntax and will define a Child::func1 which hides Parent::func1 in Child.

However, this does not mean that it fully replaces Child::Parent::func1. This function can still be called explicitly on an element of child.

Child c;
c.Parent::func1();

Also, this function will not be virtual. Thus, the following..

Child c;
Parent& p = c;
p.func1();

will call Parent::func1 and not Child::func1.

Answer 5

[assuming here Child extends Parent, unlike what the code snap shows]

Yes it is possible [it is called hiding] - but you will not get a dynamic dispatch behavior.

The static type will define which method will be invoked, and not the dynamic type.

For example:

Parent* p = new Child;
p->func1();

Will invoke Parent::func1()
while:

Child* c = new Child;
c->func1();

Will invoke Child::func1()