Question

我带着一个愚蠢的问题回来了...... :)

在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;
};

意思是，我有两个包含数据的类，然后是两个类加载每个列表和一个母类列出列表类的数据。

我的解释非常糟糕，但我不知道如何解释它......

如果我致电GetName，我的数据就没问题了。如果我拨打GetComment，程序会崩溃。我试过做类似的事情：

dataproject * listproject::GetById(unsigned int id)
{
    return  (dataproject*) listdata::GetById(id);
}

但它也崩溃了。

我相信有办法做我想做的事，访问子类的功能。

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

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

list<Mother> datalist

datalist->function_of_child_B

Answer 1

您必须使用list<Mother>而不是list<Mother*>。当您使用list<Mother>时，列表中的项目必须只是Mother，除了Mother之外别无其他，因为list<>只为Mother对象留出足够的空间（ sizeof(Mother)）。如果您尝试在从Mother list<>派生的对象中“填充”，则会剪切该对象，有效地使其成为Mother，但使用原始对象的虚拟表，这是未定义的行为。当您使用list<Mother*>时，您可以拥有从Mother派生的任何对象，因为list<>仅为指针（sizeof(Mother*)）腾出空间，并且指针的大小对于所有人都相同类。

Answer 2

你不能那样做

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，B

的对象

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类有一个名为functionA()的函数，而B有一个名为functionB()的函数，你想在{{1}的成员v[i]中调用这两个函数中的一个矢量。在这种情况下，您可以使用Mother*来执行仅存在于dynamic_cast类

的子类中的函数

Mother

C ++类掩码和遗产

2 个答案: