带有抽象继承的后缀运算符++

Question

I want to implement prefix and postfix operator++ in a struct hierarchy (abstract base A and child B). When only implementing prefix in base class, this works fine. However, when implementing the postfix version in the child class (since it cannot be implemented in an abstract class) it doesn't work.

struct A {
    virtual A& operator++(){std::cout << "A: prefix ++" << std::endl; return *this;}
    virtual void foo() = 0;
};

struct B : A {
    void foo() override {};
    //virtual B& operator++() override {std::cout << "B: prefix ++" << std::endl; return *this;}
    //B operator++(int i) {std::cout << "B: postfix ++" << std::endl; return *this;}
};

int main(int argc, const char * argv[]) {
    B b;
    ++b; // Compile error here if I implement postfix in B
    return 0;
}

The thing is that I want to avoid repeating code and since all derived classes will use operator++ in the same way, it would be best to not implement them all in their respective classes. The whole point of using the abstract class was to avoid this!

My question is: what is the most elegant way to solve this?

EDIT. Error message: cannot increment value of type 'B'

Answer 1

The problem is that the operator++ in the derived class is hiding the name in the base class. Try adding the following to B :

using A::operator++;

You may find it difficult to make the post-increment function behave polymorphically though. Covariant return types will not work.

Live demo.

Answer 2

Since you ask for a more elegant way to do this, my view is that the most elegant way is to hide the details of the polymorphic interface from consumers of your class as much as possible.

One more class to contain your polymorphic concept will do the trick, and allow you to implement post-increment easily and safely:

#include <memory>
#include <iostream>

// this is our non-polymorphic handle class. In this case each handle
// owns a discrete object. We could change this to shared-handle semantics by using shared_ptr if desired.
struct poly_thing
{
    // this is the polymorphic concept (interface)
    struct concept {
        virtual void increment() = 0;
        virtual std::unique_ptr<concept> clone() const = 0;
        virtual ~concept() = default;
    };

    poly_thing(std::unique_ptr<concept> p_concept)
    : _impl(std::move(p_concept))
    {}

    // must override copy constructor because of unique_ptr
    poly_thing(const poly_thing& r)
    : _impl(r._impl->clone())
    {}

    poly_thing(poly_thing&& r) = default;

    // must override copy constructor because of unique_ptr
    poly_thing& operator=(const poly_thing& r)
    {
        _impl = r._impl->clone();
        return *this;
    }

    poly_thing& operator=(poly_thing&& r) = default;

    //
    // here is our sane non-polymorphic interface.
    //        
    poly_thing operator++(int) {
        std::cout << "operator++(int)" << std::endl;
        auto clone_p = _impl->clone();
        _impl->increment();
        return poly_thing { std::move(clone_p) };
    }

    poly_thing& operator++() {
        std::cout << "operator++()" << std::endl;
        _impl->increment();
        return *this;
    }

    std::unique_ptr<concept> _impl;
};

// an implementation (model) of the concept
struct implementation_a : poly_thing::concept {
    std::unique_ptr<poly_thing::concept> clone() const override
    {
        std::cout << "cloning an a" << std::endl;
        return std::make_unique<implementation_a>(*this);
    }

    void increment() override {
        std::cout << "incrementing an a" << std::endl;
        // implementation here
    }
};

// a model derived from a model    
struct implementation_b : implementation_a {
    std::unique_ptr<poly_thing::concept> clone() const override
    {
        std::cout << "cloning a b" << std::endl;
        return std::make_unique<implementation_b>(*this);
    }

    // you can now choose whether to implement this
    void increment() override {
        // implementation here
        std::cout << "incrementing a b" << std::endl;
    }
};

// a small test
auto main() -> int
{
    poly_thing a(std::make_unique<implementation_a>());
    auto aa1 = a++;
    auto aa2 = ++a;

    poly_thing b(std::make_unique<implementation_b>());
    auto bb1 = b++;
    auto bb2 = ++b;

    return 0;
}

expected output:

operator++(int)
cloning an a
incrementing an a
operator++()
incrementing an a
cloning an a
operator++(int)
cloning a b
incrementing a b
operator++()
incrementing a b
cloning a b