C++ - "Cannot declare parameter 'anonymous' to be of abstract type"

Question

I have this simple class (Alpha) and his abstract class (Beta). I'm unable to pass Alpha (Beta) objects to overwrite() function, because abstract class can't handle self type objects.

#include <iostream>
using std::cout;
using std::endl;
using std::ostream;

class Beta {
    public:
        virtual int  read() const = 0;
        virtual void write(int) = 0;
        virtual void overwrite(Beta) = 0; // <-- This is the problem
};

class Alpha : public Beta {
    public:
        int  read     () const;
        void write    (int);
        void overwrite(Alpha);
    private:
        int value;
};

int Alpha::read() const {
    return value;
}
void Alpha::write(int v) {
    value = v;
}
void Alpha::overwrite(Alpha A) {
    value = A.value;
}

int main () {
    Alpha A, B;
    A.write(8);
    B.write(6);

    cout << "A: " << A.read() << endl; // 8
    cout << "B: " << B.read() << endl; // 6

    A.overwrite(B);

    cout << endl << "A: " << A.read(); // 6
    return 0;
}

It gives me [Error] cannot declare parameter '<anonymous>' to be of abstract type 'Beta'. How to deal with it? It's a small code sample, but I need to solve this because I can't overload operators and declaring that type of functions correctly.

Answer 1

The Beta class is abstract and cannot be instantiated.

Your function signature wants an instantiation of an abstract class.

Try passing by reference or pointer:

void overwrite(Beta& b);
void overwrite(Beta * b);

Answer 2

The problem is your overwrite method is pure-virtual and not being overridden. This method has the following signature in Beta

virtual void overwrite(Beta) = 0;

In Alpha it is

void overwrite(Alpha);

These are not the same function signature. What you can do is pass a reference and cast it, for example

class Beta {
    public:
        virtual int  read() const = 0;
        virtual void write(int) = 0;
        virtual void overwrite(Beta&) = 0;
};

class Alpha : public Beta {
    public:
        int  read     () const;
        void write    (int);
        void overwrite(Beta&) override;  // Note the override
    private:
        int value;
};

void Alpha::overwrite(Beta& A){
    value = static_cast<Alpha&>(A).value;
}

This will produce the output (live demo):

A: 8
B: 6

A: 6 

Note that I added the keyword override after the function declaration in Alpha. If you would have done this while the argument was still an Alpha, your code would not have compiled for this reason.