Клонировать экземпляр класса, затем клонировать клон, затем клонировать клон ...?

Question

У меня есть потребность клонировать класс из экземпляра другого класса, чтобы клон наследовал характеристики исходного класса с определенными некоторыми новыми / измененными атрибутами, затем клонировал клон, клонировал клон и т. Д. Надеемся, что приведенный ниже код шоу хочу я хочу добиться. Я пробовал варианты нескольких ответов от stackoverflow относительно классов клонирования, но я не смог заставить его работать. Кто-нибудь может помочь?

Это (неполный) код:

#include <cstdio>

class BASE {

    private:

        int x = 1;
        int y = 2;
        int z = 3;

    public:

        void id() { printf("BASE\n"); }

        void f1() { printf("BASE f1\n" }
        void f2() { printf("BASE f2\n" }
        void f3() { printf("BASE f3\n" }

        void x() { printf("x = %d\n", x);
        void y() { printf("y = %d\n", y);
        void z() { printf("z = %d\n", z);

        void x(int v) { x = v);
        void y(int v) { y = v);
        void z(int v) { z = v);
}

class A {

    public:

        void id() { printf("A\n"); }

        void f1() { printf("A f1\n" }

        void x() { printf("x = %d\n", x);
        void y() { printf("y = %d\n", y);
        void z() { printf("z = %d\n", z);

        void x(int v) { x = v);
        void y(int v) { y = v);
        void z(int v) { z = v);
}

class B {

    public:

        void id() { printf("B\n"); }

        void f1() { printf("B f1\n" }

        void x() { printf("x = %d\n", x);
        void y() { printf("y = %d\n", y);
        void z() { printf("z = %d\n", z);

        void x(int v) { x = v);
        void y(int v) { y = v);
        void z(int v) { z = v);
}

class C {

    public:

        void id() { printf("C\n"); }

        void f1() { printf("C f1\n" }

        void x() { printf("x = %d\n", x);
        void y() { printf("y = %d\n", y);
        void z() { printf("z = %d\n", z);

        void x(int v) { x = v);
        void y(int v) { y = v);
        void z(int v) { z = v);
}

int main() {

    BASE *ptr = new BASE();

    ptr->id();
    ptr->f1();
    ptr->f2();
    ptr->f3();
    ptr->x();
    ptr->y();
    ptr->z();

    printf("\n\n");

    A *a = base->clone();

    delete ptr;
    A *ptr = a;

    ptr->id();
    ptr->f1();
    ptr->f2();
    ptr->f3();
    ptr->x(7);  // change member x to 7
    ptr->x();
    ptr->y();
    ptr->z();

    printf("\n\n");

    B *b = a->clone();

    delete ptr;
    B *ptr = b;

    ptr->id();
    ptr->f1();
    ptr->f2();
    ptr->f3();
    ptr->x();
    ptr->y(9);  // change member y to 9
    ptr->y();
    ptr->z();

    printf("\n\n");

    C *c = b->clone();

    delete ptr;
    C *ptr = c;

    ptr->id();
    ptr->f1();
    ptr->f2();
    ptr->f3();
    ptr->x();
    ptr->y();
    ptr->z(5);  // change member z to 5
    ptr->z();

}

Код не завершен - в частности, функция "clone ()" не написана. Это бит, который я не знаю, как сделать.

При запуске программы должен появиться вывод:

BASE
BASE f1
BASE f2
BASE f3
x = 1
y = 2
z = 3


A
A f1
BASE f2
BASE f3
x = 7
y = 2
z = 3


B
B f1
BASE f2
BASE f3
x = 7
y = 9
z = 3


C
C f1
BASE f2
BASE f3
x = 7
y = 9
z = 5

Может ли это быть достигнуто? Если да, то как?

Answer 1

Звучит так, будто вы хотите, чтобы A, B и C наследовали от BASE и могли быть сконструированы из одного.

#include <cstdio>

class BASE {
private:

    int m_x = 1;
    int m_y = 2;
    int m_z = 3;

public:

    virtual void id() { printf("BASE\n"); }

    virtual void f1() { printf("BASE f1\n"); }
    void f2() { printf("BASE f2\n"); } /* virtual ? */ 
    void f3() { printf("BASE f3\n"); } /* virtual ? */ 

    void x() { printf("x = %d\n", m_x); }
    void y() { printf("y = %d\n", m_y); }
    void z() { printf("z = %d\n", m_z); }

    void x(int v) { m_x = v; }
    void y(int v) { m_y = v; }
    void z(int v) { m_z = v; }
};

class A : public BASE {
public:
    A(const BASE & base) : BASE(base) {}
    A& operator = (const BASE & base) { static_cast<BASE&>(*this) = base; return *this; }

    void id() override { printf("A\n"); };
    void f1() override { printf("A f1\n"); };
};

class B : public BASE {
public:
    B(const BASE & base) : BASE(base) {}
    B& operator = (const BASE & base) { static_cast<BASE&>(*this) = base; return *this; }

    void id() override { printf("B\n"); };
    void f1() override { printf("B f1\n"); };
};

class C : public BASE {
public:
    C(const BASE & base) : BASE(base) {}
    C& operator = (const BASE & base) { static_cast<BASE&>(*this) = base; return *this; }
    void id() override { printf("C\n"); };
    void f1() override { printf("C f1\n"); };
};

int main() {

    BASE base;

    base.id();
    base.f1();
    base.f2();
    base.f3();
    base.x();
    base.y();
    base.z();

    printf("\n\n");

    A a = base;

    a.id();
    a.f1();
    a.f2();
    a.f3();
    a.x(7);  // change member x to 7
    a.x();
    a.y();
    a.z();

    printf("\n\n");

    B b = a;

    b.id();
    b.f1();
    b.f2();
    b.f3();
    b.x();
    b.y(9);  // change member y to 9
    b.y();
    b.z();

    printf("\n\n");

    C c = b;

    c.id();
    c.f1();
    c.f2();
    c.f3();
    c.x();
    c.y();
    c.z(5);  // change member z to 5
    c.z();

}

Здесь вам действительно не нужно наследование, поскольку существует разница в данных между BASE, A, B и C.