C++ virtual method overriding only one - c++

Question

This is Parent Class Foo, and It is abstract(virtual).
And Foo class' methods are declared in Foo.cpp.
[Foo.h]
class Foo
{
public:
Foo();
~Foo();
virtual void methodA(int no, const char* path) = 0;
virtual void methodB(const char* name, const char* path) = 0;
virtual void methodC(const char* name, const char* path) = 0;
// ... more 20 virtual methods
}
[Foo.cpp]
Foo::Foo(){}
Foo::~Foo(){}
Foo::methodA(int no, const char* path)
{
// do something
}
Foo::methodB(const char* name, const char* path)
{
// do something
}
Foo::methodC(const char* name, const char* path)
{
// do something
}
// ... more 20 methods
In Foo class, methodA must be called with parameter no.
And Also parameter no must increase sequentially from 0.
It is very uncomfortable. So I want to override methodA in child class Bar.
Bar class has a memeber variable m_no and methodA without parameter no.
And m_no will increase when methodA called.
This is my code.
[Bar.h]
class Bar : public Foo
{
public:
Bar();
~Bar();
void methodA(const char* path);
private:
int m_no;
}
[Bar.cpp]
Bar::Bar() : m_no(0) {}
Bar::~Bar() {};
Bar::methodA(const char* path)
{
Foo::methodA(m_no++, path);
}
But class Bar is abstract(virtual), because class Bar isn't declare virtual methods (methodA, methodB, methodC and 20 methods more).
So, I edited.
[Bar.h]
class Bar : public Foo
{
public:
Bar();
~Bar();
void methodA(const char* path);
void methodB(const char* name, const char* path);
void methodC(const char* name, const char* path);
// ... more 20 methods
private:
int m_no;
}
[Bar.cpp]
Bar::Bar() : m_no(0) {}
Bar::~Bar() {};
Bar::methodA(const char* path)
{
methodA(m_no++, path);
}
Bar::methodA(int no, const char* path)
{
Foo::methodA(no, path);
}
Bar::methodB(const char* name, const char* path)
{
Foo::methodB(name, path);
}
Bar::methodC(const char* name, const char* path)
{
Foo::methodC(name, path);
}
// ... more 20 methods
How can I inherit class Foo without declare all virtual methods?

Answer 1

How can I inherit class Foo without declare all virtual methods?
You provide an implementation for them.
(note: this part adds to #TommyA's answer, but it is too long for a comment; see second part, for a different approach)
consider:
class Foo
{
public:
Foo();
virtual ~Foo() = 0; // this is the only pure virtual function
virtual void methodA(int no, const char* path);
virtual void methodB(const char* name, const char* path);
virtual void methodC(const char* name, const char* path);
// ... more 20 virtual methods
}
Foo.cpp:
Foo::~Foo() = default; // unless you need to add some impleemntation
// other methods implemented like you did
Bar:
class Bar : public Foo
{
public:
Bar();
virtual ~Bar();
void methodA(const char* path);
// do not implement anything of Foo here (it is inherited already)
private:
int m_no;
}
Second part
Another approach would be to follow the open-closed principle (decide that if the method must be called with an ever increasing number, then it is the responsibility of Foo to implement that, and add a template method implementation):
class Foo
{
public:
// public interface for methodA, accessible to clients
void methodA(const char* path);
protected:
virtual void methodA_impl(int no, const char* path) = 0;
private:
int m_no; // private: not accesible to specializations
};
void Foo::methodA(const char* path)
{
methodA_impl(m_no++, path);
}
class Bar: public Foo
{
// ...
protected:
void methodA_impl(int no, const char* path) override;
}
void Bar::methodA_impl(int no, const char* path)
{
// Bar-speciffic implementation here
}
This follows the open-closed principle because the "number must be incremented at every call" requirement is fixed and cannot be overriden by
specializations.
Clients of Foo specializations cannot change how methodA_impl is called (it is always called correctly) and you have the virtual method behavior you need.

Answer 2

When a base class is pure virtual the child class that you wish to instantiate needs to fully implement the pure virtual methods before you can instantiate it. But you could make a "middle" layer that default implemented the methods, that you then inherited from.
Note: Remember to use virtual destructors creating non-final classes.

Answer 3

The whole point of that class Foo is that has been defined so all derived classes must override all the pure virtual methods.
The most obvious workaround is to complain bitterly to whoever provided class Foo and get them to provide a sensibly designed base class. It is absolutely lousy design to define a class that way, unless it is obvious that ALL virtual functions MUST be overridden. It is also lousy design (because there are circumstances where the result is undefined behaviour) to have a base class that does not have a virtual destructor.
If this is your design, redesign your entire class hierarchy. Seriously, the design is that bad.
However, it is possible to simply derive another class from Foo and override all member functions necessary. For example;
class FooIntermediary : public Foo
{
virtual void methodA(int no, const char* path);
virtual void methodB(const char* name, const char* path);
virtual void methodC(const char* name, const char* path);
};
void FooIntermediary::methodA(int no, const char *path)
{
Foo::methodA(no, path);
}
void FooIntermediary::methodB(const char *name, const char *path)
{
Foo::methodB(name, path);
}
// etc
Then any classes derived from FooIntermediary will only be forced to override any inherited functions from Foo that FooIntermediary has not overridden.
You could find another class, derived from Foo, that can be instantiated, and has (apart from the particular change you seek) all the behaviour your need. By definition, that class will have overridden all of the inherited abstract functions. So derive a class from it, and override only the virtual function you need to.