Concise (yet still expressive) C++ syntax to invoke base class methods
-
19-09-2019 - |
Question
I want to specifically invoke the base class method; what's the most concise way to do this? For example:
class Base
{
public:
bool operator != (Base&);
};
class Child : public Base
{
public:
bool operator != (Child& child_)
{
if(Base::operator!=(child_)) // Is there a more concise syntax than this?
return true;
// ... Some other comparisons that Base does not know about ...
return false;
}
};
Solution
No, that is as concise as it gets. Base::operator!=
is the name of the method.
And yes, what you are doing is standard.
However, in your example (unless you have removed some code), you do not need Child::operator!=
at all. It does the same thing as Base::operator!=
will.
OTHER TIPS
1
if ( *((Base*)this) != child_ ) return true;
2
if ( *(static_cast<Base*>(this)) != child_ ) return true;
3
class Base
{
public:
bool operator != (Base&);
Base & getBase() { return *this;}
Base const & getBase() const { return *this;}
};
if ( getBase() != child_ ) return true;
What you're doing is the most concise and "standard" way to do it, but some people prefer this:
class SomeBase
{
public:
bool operator!=(const SomeBaseClass& other);
};
class SomeObject: public SomeBase
{
typedef SomeBase base; // Define alias for base class
public:
bool operator!=(const SomeObject &other)
{
// Use alias
if (base::operator!=(other))
return true;
// ...
return false;
}
};
The benefits of this method is that it clarifies intention, it gives you a standard abbreviation for what could be a long base-class name, and if your base class changes, you don't have to change every use of the base.
See Using "super" in C++ for additional discussion.
(Personally, I don't care for this, and I don't recommend it, but I think it is one valid answer to the question.)
if (condition) return true;
return false;
can be abbreviated to
return condition;
I'd get rid of the if/then control structure and just return the return value of the base class operator, but otherwise what you're doing is fine.
It can be a bit more concise, though: return ((Base&)*this) != child_;