C++ 在不更改基类的情况下将一个驱动类强制转换为另一个

我有几个孩子班都有相同的家长。每个子类都可以使用父对象中包含的一些数据来构造。我想使用基本对象中包含的信息（不修改基本对象）将一个子对象强制转换为另一个子对象

目前它的实现如以下示例所示：

#include <iostream>

using namespace std;

class Data {};
class base
{
public:
    base()  {}
    base(Data input) : data(input)  {}
    virtual ~base() {   cout << "Deleting :" << this->name() << endl;   }
    template<class T> static base* CastToDerrived(base* object)
    {
        T* output = new T(object->data);
        delete object;
        return output;
    }
    virtual const char* name()  {return "base";}
    Data data;
};

class derrived1 : public base
{
public:
    derrived1() {}

    derrived1(Data input): base(input){}
    ~derrived1(){cout << "Deleting :" << this->name() << endl;}
    const char* name(){return "derrived1";}
};

class derrived2 : public base
{
public:
    derrived2(){}
    derrived2(Data input): base(input){}
    ~derrived2(){cout << "Deleting :\t" << this->name() << endl;}
    const char* name(){return "derrived2";}
};

int main(int argc, char *argv[])
{
    base* object = new derrived1();
    cout << "Created :\t"<<object->name()<<endl;
    object = base::CastToDerrived<derrived2>(object);
    cout << "Casted to :\t"<<object->name()<<endl;
}

然而，这需要销毁并再次创建基类，这是我想要避免的——我想要销毁derrived1，使用base来构造derrived2，但保持基类完好无损。最好的方法是什么

---

（有几个派生类，基类为所有派生类提供公共接口，稍后将添加一些派生类而不修改基类）。

不能销毁派生类并保留基类，因为它是同一个实例。 我们可以使用下面的代码来演示这一点

#include <iostream>

using namespace std;

class Data {};
class base
{
public:
    base()
    {
        printf("base pointer = %08X\n", this);
    }
};

class derrived1 : public base
{
public:
    derrived1()
    {
        printf("derrived1 pointer = %08X\n", this);
    }
};

int main(int argc, char *argv[])
{
    base* object = new derrived1();
    delete object;
    return 0;
}

#包括
使用名称空间std；
类数据{}；
阶级基础
{
公众：
base（）
{
printf（“基指针=%08X\n”，这是）；
}
};
类derrived1：公共基
{
公众：
Derived1（）
{
printf（“derrived1指针=%08X\n”，this）；
}
};
int main（int argc，char*argv[]）
{
base*object=new-derrived1（）；
删除对象；
返回0；
}

输出将显示derived1的基是同一个指针 另一方面，您使用一些复杂的代码来实现您想要的。 其思想是使用指向数据类的指针而不是变量。 您的代码将如下所示

#include <iostream>

using namespace std;

class Data {};
class base
{
public:
    base(){data = new Data}
    base(Data* input) : data(input)  {}
    virtual ~base() {   cout << "Deleting :" << this->name() << endl;   }
    template<class T> static base* CastToDerrived(base* object)
    {
        T* output = new T(object->data);
        delete object; 
        return output;
    }
    virtual const char* name()  {return "base";}
    Data* data;
};

class derrived1 : public base
{
public:
    derrived1() {}

    derrived1(Data* input): base(input){}
    ~derrived1(){cout << "Deleting :" << this->name() << endl;}
    const char* name(){return "derrived1";}
};

class derrived2 : public base
{
public:
    derrived2(){}
    derrived2(Data* input): base(input){}
    ~derrived2(){cout << "Deleting :\t" << this->name() << endl;}
    const char* name(){return "derrived2";}
};

int main(int argc, char *argv[])
{
    base* object = new derrived1();
    cout << "Created :\t"<<object->name()<<endl;
    object = base::CastToDerrived<derrived2>(object);
    cout << "Casted to :\t"<<object->name()<<endl;
}

#包括
使用名称空间std；
类数据{}；
阶级基础
{
公众：
base（）{data=新数据}
基本（数据*输入）：数据（输入）{
virtual~base（）{那么你想移动基对象吗？是的，没错，我想移动它，但是我需要销毁一个子对象并使用基对象创建另一个子对象。不要使用继承，而是使用组合！你可以在类周围移动指向基类实现的指针，它永远不会被销毁（因为你保留了一个引用计数器）@Adriano，是的，这可能会起作用，但基类为所有子类提供了接口-通过继承，我可以为所有子类及其接口使用指向基类的指针，并在不修改使用它们的代码的情况下添加新的子类，我将如何通过组合实现这一点？@IlyaKobelevskiy，您可以使基类只保留一个p指向一个包含所有“基本”字段的结构。这样可以将该结构的所有权从一个对象转移到另一个对象，而不会失去多态性的好处。
#include <iostream>

using namespace std;

class Data {};
class base
{
public:
    base(){data = new Data}
    base(Data* input) : data(input)  {}
    virtual ~base() {   cout << "Deleting :" << this->name() << endl;   }
    template<class T> static base* CastToDerrived(base* object)
    {
        T* output = new T(object->data);
        delete object; 
        return output;
    }
    virtual const char* name()  {return "base";}
    Data* data;
};

class derrived1 : public base
{
public:
    derrived1() {}

    derrived1(Data* input): base(input){}
    ~derrived1(){cout << "Deleting :" << this->name() << endl;}
    const char* name(){return "derrived1";}
};

class derrived2 : public base
{
public:
    derrived2(){}
    derrived2(Data* input): base(input){}
    ~derrived2(){cout << "Deleting :\t" << this->name() << endl;}
    const char* name(){return "derrived2";}
};

int main(int argc, char *argv[])
{
    base* object = new derrived1();
    cout << "Created :\t"<<object->name()<<endl;
    object = base::CastToDerrived<derrived2>(object);
    cout << "Casted to :\t"<<object->name()<<endl;
}