Möchte eine abstrakte Basisklasse haben, die aber nicht leer ist (wie ein Java Interface), sondern durchaus schon eine gewisse Logik mitbringt. Die abgeleiteten Klassen sollen dann nur 2 entsprechende Methoden überschreiben und implementieren.

Nun ist es so, dass ich den Copy Ctor normalerweise für den operator= verwende. Spart Zeit und vor allem ist alles leichter wartbar weil alles zentral an einer Stelle geschieht.
Bei der abstrakten Klasse kann ich aber nichts als Objekt sondern nur als Referenz übergeben. Folglich muss ich im operator= den ganzen Code nochmal runterschreiben.

//COPY CTOR
    ImageAbstract::ImageAbstract(ImageAbstract& original)
    :m_dataMatrix(0),m_width(original.m_width),m_height(original.m_height),
     m_channels(original.m_channels)
    {
        std::cout<<"base copy ctor\n";

        createDataMatrix();

        for(coordinates_t x=0;x<m_width;x++)
        {
            for(coordinates_t y=0;y<m_height;y++)
            {
                m_dataMatrix[x][y]=original.m_dataMatrix[x][y];
            }
        }
    }

    //OPERATOR= : wieder das gleiche wie oben...
    ImageAbstract& ImageAbstract::operator=(ImageAbstract& rhs)
    {
        std::cout<<"base =\n";

        clearDataMatrix();
        m_width=rhs.m_width;
        m_height=rhs.m_height;
        m_channels=rhs.m_channels;

        createDataMatrix();
        for(coordinates_t x=0;x<m_width;x++)
        {
            for(coordinates_t y=0;y<m_height;y++)
            {
                m_dataMatrix[x][y]=rhs.m_dataMatrix[x][y];
            }
        }

        return *this;
    }

Das einzige was mir einfällt ist eine Hilfsfunktion zu definieren die in beiden Fällen aufgerufen wird und somit der Code nur noch an einer Stelle zu finden ist.

Sonst irgendwelche Möglichkeiten?

1. hab den copy ctor auf const ImageAbstract& original geändert
2. Wenn ich bei operator= statt Referenz ein Objekt übergebe kommt folgende Meldung: error: cannot declare parameter ‘rhs’ to be of abstract type ‘lalala::ImageAbstract’

(PS: Man nimmt per const-reference, das da ist z.B. gar kein Kopierkonstruktor.)

oO Natürlich ist das einKopie-Konstruktor. Ein Kopie-Konstruktor ist ein Konstruktor, der eine Referenz erwartet, alles andere ist nur eine zusätzliche Option.

Das sind alle Kopie-Konstruktoren

X(const          X& copy_from_me);
X(               X& copy_from_me);
X(      volatile X& copy_from_me);
X(const volatile X& copy_from_me);
X(               X& copy_from_me, int = 0);
X(const          X& copy_from_me, double = 1.0, int = 42);