asked on

Inheritance issue

- - - - - - - - - - - - - - - - CODE: - - - - - - - - - - - - - - - - - - - -

class CBaseTestClass
{
public:
      CBaseTestClass(){};
      ~CBaseTestClass(){};
      virtual void Overlay(BYTE* pBits, int nWidth, int nHeight)      {};
      virtual void Overlay(BYTE* pBits)      {};
};

class CTestClass : public CBaseTestClass
{
public:
      CTestClass(){};
      ~CTestClass(){};
      virtual void Overlay(BYTE* pBits){};
};

if I then do the following:

      CTestClass test;

      test.Overlay(pBits, 10, 10);

I get:

error C2660: 'Overlay' : function does not take 3 parameters

Why? What must I do to make this possible?

Sys_Prog

A couple of things

First of all, In case of Inheritance, whenevr u declare a function in derived class with the same name as that of the Base class [even with different number/type of arguments], the base class function becomes hidden. in this case, For u to have access to every function available in base class, you would have to declare each base class function [which u need] in the derived class as well

U are expecting overloading to happen but overloading always happens in same context, at same level.
In Inheritance, the context changes, u are operating at two difefrent levels

jhattingh

ASKER

I understood very little of what you explained. Could you give me examples of what you are explaining?

ASKER CERTIFIED SOLUTION

Sys_Prog

membership

This solution is only available to members.

To access this solution, you must be a member of Experts Exchange.

Start Free Trial

_ys_

Due to the presence of CTestClass::Overlay, all base class Overlay functions, effectively, no longer exist - technically it's known as 'hiding'.

You can implictly scope every invocation:
test.CBaseTestClass::Overlay(pBits, 10, 10);

But this is tedious, and easy to forget.

An easier way, and one less likely to forget, is to bring the CBaseTestClass declarations of Overlay back into scope.

class CTestClass : public CBaseTestClass
{
public:
using CBaseTestClass::Overlay;

public:
CTestClass(){};
~CTestClass(){};
virtual void Overlay(BYTE* pBits){};
};

Sys_Prog

In your case, u have also declared the functions as virtual

Actually the virtual feature won't help you in your case

Virtual functions are useful when u need dynamic binding. i.e. the base class pointer invoking the function of derived class.

HTH

Amit

jhattingh

ASKER

ok...

Amit: I can accept your explanation, BUT you rendered an example different to mine. You see, I did not "overwrite/shadow" the 3-arg version.. and yet it STILL wasn't visible..

Why is that?

Ah.... I've just re-read your explanation.. you said:

<< [even with different number/type of arguments], the base class function becomes hidden >>

I see.. Wow.. I can't believe I didn't bump into this issue in the last 8 years of c++ dev .. !!!!!!

I feel like a beginner all of a sudden..

Thanks for the feedback.

ALSO: Thanks to _y_ .. your solution is cool.