C++ C++；阶级面具与传统

我带着一个愚蠢的问题回来了：）

在C++中，我想做如下：

class dataproject : public data
{
    public:
        dataproject();
        ~dataproject();

        virtual wxString GetComment(void);

    private:
        wxString m_comment;
};

class listproject : public listdata
{
    public:
        listproject();
        ~listproject();
        bool Load();       
};

(one of the function of listproject)
{
    dataproject data;
    data.SetComment("blablabla");
    m_list.push_front(data);    
}

class dataclient : public data
{
    public:
        dataclient();
        ~dataclient();
};

class listclient  : public listdata
{
    public:
        listclient();
        ~listclient();
        bool Load();
};

class data
{
    public:
        data();
        virtual ~data();
        wxString GetName(void);

    protected:
        wxString  m_name;
};


class listdata
{
    public:
        data * GetById(unsigned int id);

    protected:
        std::list<data> m_list;
};

但它也崩溃了

我相信有一种方法可以实现我想要的，访问子类的函数

编辑： 为了更清楚，我将异构数据存储在一个列表中，这些数据是链接到一个母类的两个子类。当我回到列表中的一个条目时，我希望能够访问位于子类上的函数。

class child A : Mother
class child B : Mother
class Mother

list<Mother> datalist

datalist->function_of_child_B

A类儿童：母亲
B班孩子：母亲
班主任
列表数据列表
数据列表->子函数的函数

你不能那样做

class child A : Mother
class child B : Mother
class Mother

list<Mother> datalist

datalist->function_of_child_B

---

必须使用

list

而不是

list

。当您使用

list

时，列表中的项必须是

Mother

，而除了

Mother

，没有其他内容，因为

list

仅为

Mother

对象（

sizeof（Mother）

）留出足够的空间。如果您试图“填充”从

母亲

列表派生的对象

将剪裁该对象，有效地使其成为

母亲

，但使用原始对象的虚拟表，这是未定义的行为。当您使用

list

时，您可以从

Mother

派生任何对象，因为

list

只为指针（

sizeof（Mother*）

）腾出空间，指针的大小对于所有类都是相同的。

我真的不明白您的问题！也许您可以发布一个完整的可编译示例来演示这个问题？（请参阅）您的类

listclient

和

listproject

除了名称之外是相同的，并且您的类

dataclient

似乎没有用处。这真的是你想要的吗？我已经截断了代码，因为它太长了，不能发布在这里。很明显我的问题不清楚，我会认真地重新格式化，你应该继续你的问题。对代码的解释没有多大意义，无序添加不同的代码位也没有帮助，因为这会使读取变得更加困难。是的，实际上使用指针不会“破坏结构”。然后可以将类设置回原来的位置。

class child A : Mother
class child B : Mother
class Mother

list<Mother> datalist

datalist->function_of_child_B

class Mother{
public:
   Mother();
   virtual function1() = 0; // It could be pure virtual
   virtual function2() {std::cout << "Mother Function 2";}     // or just virtual
}

class A : public Mother {
public:
   function1() {std::cout << "A function 1";}
   function2() {std::cout << "A function 2";}
}

class B : public Mother {
public:
   function1() {std::cout << "B function 1";}
}

A* a = new A;
B* b = new B;

// Add them to a vector of Mother* (or list if you prefer it)
std::vector<Mother*> v;
v.push_back((Mother*)a);
v.push_back((Mother*)b);

v[0]->function1(); // prints A function 1
v[0]->function2(); // prints A function 2
v[1]->function1(); // prints B function 1
v[1]->function2(); // prints Mother function 2

A* pA = dynamic_cast<A*>(v[i]);
if (pA != NULL)
    pA->functionA();
B* pB = dynamic_cast<B*>(v[i]);
if (pB != NULL)
    pB->functionB();