C++ Abstract Base Class with pure virtual operator+ function - c++

Question

Let's say I am creating an Abstract Base Class for the purpose of defining a public interface. I want operator+ to be a part of this public interface. It would seem that this is not possible in C++ or that I am missing something.
For example, suppose the code below is a .h file declaring the public interface for an abstract base class named IAbstract. This code does not compile because I cannot declare a function that returns an instance of an abstract base class. This compile error makes sense, but what I don't understand is this: Is there any way to guarantee operator+ will exist in the public interface of IAbstract?
#include <iostream>
// An abstract base class
class IAbstract
{
public:
IAbstract(int value);
virtual ~IAbstract() {}
virtual int SomeOtherFunction() =0;
//This is ok
virtual IAbstract& operator++() =0;
//This will not compile
virtual const IAbstract operator+(const IAbstract& rhs) =0;
//Xcode5 says "Semantic Issue: Return type 'IAbstract' is an abstract class"
};

Answer 1

In addition to the return by value problem, the really problem with your dessign is the way that the C++ language works.
Object oriented languages like Java defines and transmit functionality through class hierarchies, interfaces, and polymorphism. Your code is the typical example of that.
C++ does not work in that way. C++ defines functionality through abstract concepts, and classes only need to fulfill this concepts to be usable in a certain way. How/if a class follows or implements a certain concept depends on its behavior, the implementation of certain functions (Like overloaded operators), etc.
So the C++ way to do what you are trying to achieve is to overload the required operators in a generic way, to ensure all classes that would implement the concept works with it.
In other words, if you are trying to make an addable concept, that is, represent things that could be added with others, a class only have to overload operator+. If a class overloads operator+ its addable. Just simple.
Here is another example: The classic implementation of std::copy():
template<typename IT , typename DEST_IT>
void copy( IT begin , IT end , DEST_IT dest_begin )
{
while( begin != end )
*dest_begin++ = *begin++;
}
In that implementation, whats the type of begin and end? Simple answer: We don't know. Could be anything. But could be anything that must fulfill the requirements of our function, that is: Is dereferenciable, incrementable, and comparable. In other words: Its an iterable type. A type that works (And seems like) an iterator.
So std::copy() works with any ranges represented by iterable things. Could be arrays:
int main()
{
int a[] = { 1,2,3 };
int b[3];
int* begin_a = &a[0];
int* end_a = &a[2];
int* begin_b = &b[0];
//Pointers are an iterable thing, right?:
std::copy( begin_a , end_a , begin_b );
//Or just the common generic way (Which does exactly the same):
std::copy( std::begin( a ) , std::end( a ) , std::begin( a ) );
}
Vectors, lists, etc:
int main()
{
std::vector<int> a = { 1,2,3 };
std::vector<int> b;
//Wooh, the code is exactly the same! Thats why templates are cool.
std::copy( std::begin( a ) , std::end( a ) , std::begin( a ) );
}
More freaking things, like iterators to walk through an stream:
int main()
{
std::vector<int> a = { 1,2,3 };
//Copy a vector to the standard output? Yes we can!
std::copy( std::begin( a ) , std::end( a ) , std::ostream_iterator<int>( std::cout , "\n" ) );
}
1
2
3
And your own classes:
struct numeric_iterator
{
int value;
numeric_iterator( int initial_value = 0 ) : value( initial_value ) {}
//numeric_iterator is an iterable thing because...
//... its dereferenciable
int operator*() const
{
return value;
}
//... its incrementable
numeric_iterator& operator++()
{
++value;
return *this;
}
numeric_iterator operator++(int)
{
numeric_iterator copy( *this );
++(*this);
return copy;
}
//... and its comparable
friend bool operator==( const numeric_iterator& lhs , const numeric_iterator& lhs )
{
return lhs.value == rhs.value;
}
friend bool operator!=( const numeric_iterator& lhs , const numeric_iterator& lhs )
{
return !( lhs == rhs );
}
};
int main()
{
//Tah dah!
std::copy( numeric_iterator( -4 ) ,
numeric_iterator( 5 ) ,
std::ostream_iterator<int>( std::cout , " " )
);
}
-4 -3 -2 -1 0 1 2 3 4

Answer 2

The offending line is:
virtual const IAbstract operator+(const IAbstract& rhs) =0;
That method returns by value, thus copying and creating an object of type IAbstract, which is not allowed. You should change to:
virtual const IAbstract& operator+(const IAbstract& rhs) =0;
That seems to be your intent but an easy oversight.

Answer 3

Somewhere you have: IAbstract variable and you can never actually have an IAbstract, only pointers to it (or references).
It is annoyed because somewhere you try and deal with a IAbstract.
It wants IAbstract* or IAbstract& or IAbstract&& which are all fine (in some form (const and volatile, so forth)).
There you go, you are returning IAbstract from operator++, which makes no sense, because you can never have a IAbstract, just look at something as one.

Answer 4

No, it is not possible guarantee operator+ will exist in the public interface of IAbstract-derived classes because you cannot properly declare operator+ as a pure virtual function.

Answer 5

The trick is to encapsulate the abstract base class, inside a regular type. The solution requires that there is a clone method
class AbstractNumericType
{
public:
virtual AbstractNumericType& operator+=(AbstractNumericType const& other) = 0;
virtual std::unique_ptr<AbstractNumeric> clone() = 0;
virtual ~AbstractNumericType() = default;
};
class NumericType
{
public:
template<class Something>
NumericType(Something value):m_obj{createNumber(value)}
{}
NumericType(NumericType const& other): m_obj{other.m_obj->clone()}
{}
NumericType operator+(NumericType const& other) const
{
auto ret = *this;
(*ret.m_obj) += (*other.m_obj);
return ret;
}
private:
std::unique_ptr<AbstractNumericType> m_obj;
};
Demo: https://gcc.godbolt.org/z/e4v1Tr
The real problem here is how you can implement operator+= when you do not have the concrete type available. You could add multiple overloads (like visitor pattern), or you could use a type switch based on rtti. None of these solutions is really good.