Is there a way in C++ to write a concrete class which when another class is derived from it, has a method which must be overriden. An abstract class allows the forcing of the derived class to create concrete versions of any abstract methods but what I want is a base class that enforces this but can also be used in its own right. I know an abstract method can also specify a default functionality but this still remains an abstract class which cannot be instantiated.
I also looked at the template method pattern but this doesn't seem to be quite what I am looking for either.
The concrete method definition in the abstract class provides a default implementation that is generally acceptable by many child class implementations but can also be overridden in case a different implementation is required. But the abstract method must always be overridden by all the child classes.
A concrete method means, the method has complete definition but it can be overridden in the inherited class. If we make this method "final" then it can not be overriden. Declaring a method or class "final" means its implementation is complete.
An overriding property declaration must specify exactly the same access modifier, type, and name as the inherited property. Beginning with C# 9.0, read-only overriding properties support covariant return types. The overridden property must be virtual , abstract , or override .
No, it is not possible. If you want to enforce (in compile time) a derived class to define a virtual function then its base class needs to be abstract, or in other words the base class needs to have a pure virtual function. Abstract class (with pure virtual function(s)) cannot be concrete, i.e. you cannot instantiate it.
I will assume you are looking for a compile-time enforcing of this condition (thank you @Chad for pointing it out)
There is no direct language-mechanism in C++ that I know of. I mean, there is not a reserved keyword to put in front of your method declaration that would achieve your desired goal.
I think that what you say is pointing to a design problem in your software. Let's say you want to force the foo() method to be reimplemented by all inherirhing classes in the following snippet
class BaseButConcrete
{
... //Common stuff
... //
virtual void foo()
{ /*implementation that you do not want to be inherited, but will be...*/ }
}
class DerivedOtherConcrete : public BaseButConcrete
{
void foo()
{ /*different implementation,
but no obligation from compiler point of view*/ }
}
I can see no good design reason why all the common stuff could not be moved in an abstract base class. From what you describe, you do not want to inherit the foo implementation in Derived, so do not inherit that part ! Thus the very classic design should do the trick :
class AbstractBase
{
... //Common stuff has moved here
... //
virtual void foo() =0;
}
class NotAnymoreBaseButStillConcrete : public AbstractBase
{
void foo()
{ /*implementation that should not be inherited,
and that will not by design*/ }
}
class DerivedOtherConcrete : public AbstractBase
{
void foo()
{ /*different implementation,
now mandatory compiler-wise for the class to be concrete*/ }
}
This way, the common stuff is still shared among all your derived classes, and you keep what you do not want to inherit (i.e. the foo implementation) separated in classes not on the same inheritance path.
One option is to put all the implementation of the class into an abstract superclass, and inherit from that instead.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With