Question

我遇到了正确构建容器的问题，该容器存储了不同类型的类标本，这些类标记都是单个抽象类的继承者。寄存器（容器）存储指向这些样本数组的指针，该指针具有抽象类的类型。每当我尝试访问样本中包含的数据时，我只能成功检索可在基类中找到的部分。例如，重载＆lt;＆lt;在包含所有三个继承者的元素的寄存器上使用，只会在屏幕上写出抽象类部分，并且会忽略那里不存在的任何东西。现在我真的不知道问题是打印出正确存储的元素，还是存储已经以不适当的形式完成，所以这就是我的问题：如何正确地完成？这是代码：

class Register{
private:
int elementNum;
type * pData;
friend std::ostream &operator<<(std::ostream & os,const Register &v);
};
class type{
int a;
int b;
};
class type2: public type{
int c;
int d;
};

其他两个继承者的行为方式与type2相同。这是主要的一部分：

    int main ()
    {
        type2 A1(1,2,3,4);
        type3 D1(4,5,6,7,8);
        type4 H1(9,10,11,12,13);
        std::cout<<A1<<D1<<H1<<endl;
        Register R1;
        R1.Add(0,A1);
        R1.Add(1,D1);
        R1.Add(2,H1);
        R1.Display();
        R1.MaxLength();
        std::cout<<R1;
        return 0;
    }

运营商＆lt;＆lt;登记册上：

std::ostream &operator<<(std::ostream & os,const Register &v){
    for(int i=0;i<v.elementNum;i++)
    {
        os<<v.pData[i]<<endl;
    }
    return os;
}

仅使用＆lt;＆lt;操作员或寄存器中的功能在此问题中结束。编辑：添加功能的实现：

void Register::Add(int position,type& T){
    if(position<0||position>elementNum+1)
        return;
    type *pTemp = new type[elementNum+1];
    if(elementNum==0)
    {
        pTemp[0]=T;
        delete[]pData;
        pData=pTemp;
    }
    else
    {
        for(int i=0,j=0;j<elementNum+1;i++,j++)
        {
            if(position!=j)
                pTemp[j]=pData[i];
            else
            {
                i--;
                pTemp[j]=a;
            }
        }
        delete[]pData;
        pData=pTemp;
    }
    elementNum++;
}

Answer 1

您只能以多态方式访问基类公共成员或基础可用的虚拟方法。

此外，您只能通过指针/引用访问虚拟方法，并且通常不能像尝试使用pData那样连续存储不同的类实例。

如果您使用virtual std::ostream &type::dump(std::ostream &os)成员方法并且覆盖位于type2等，则可以使每个覆盖方法显示特定于其子类型的内容。

struct type {
  virtual ostream &dump(ostream &os) {
    os << a << " " << b << " ";
    return os;
  }
  int a;
  int b;
};

struct type2 : type {
  // Can use parent implementation AND use subtype-specific members:
  ostream &dump(ostream &os) override {
    type::dump(os);
    os << c << " " << d << " ";
    return os;
  }
  int c;
  int d;
};

// This class needs new "void Add(int pos, type &)" logic.
struct Register {
  int   elementNum;
  type *pData; // next hint: this is almost definitely not what you want.
  type **pda;  // probably better (need to use new/delete to make types)
};

ostream &operator<<(ostream &os, Register const &v) {
  for (int i = 0; i < v.elementNum; ++i) {
    // Calls proper virtual method for each instance.
    v.pData[i].dump(os); // XXX probably broken too
    v.pda[i]->dump(os); // should look more like this
    os << endl;
  }
}

Answer 2

type *pTemp = new type[elementNum+1];

这将分配类型为type的对象数组。对象永远不能更改其类型，并且您不能替换数组的元素，只能修改它。因此，您的Register对象根本不包含任何派生类的对象，只包含具有基类类型的对象。

要想获得一系列异构对象，你需要一个指针数组：

type **pTemp = new (type*[elementNum+1]);

要以正确的方式执行，您应该避开数组和原始指针，而是使用容器和智能指针：

class Register {
public:
    const type& get(int pos) const;
    type& get(int pos);

    void Add(int pos, const type& obj);
    void Add(int pos, std::unique_ptr<type>&& ptr);

    // ...
private:
    std::vector<std::unique_ptr<type>> m_data;
};

但无论如何，你从函数Add中添加了哪些指针？

void Register::Add(int position,type& T);

可能不是传递的引用的地址&T。谁知道该物体什么时候会被毁坏。并且new type(T)也不好 - 它只是创建了一个基类型的对象，忽略了T的实际类型。所以你可能想要一个clone()方法，有时称为＆＃34;虚拟拷贝构造函数＆＃34;：

class type {
public:
    using pointer = std::unique_ptr<type>;
    virtual ~type();
    virtual pointer clone() const;
};

type::pointer type::clone() const {
    return pointer(new type(*this));
}

type::pointer type2::clone() const {
    return pointer(new type2(*this));
}

上面我输入了Add()的两个重载。对象传递版本如下：

void Register::Add(int pos, const type& obj) {
    if (pos<0)
        return;
    if (pos >= m_data.size())
        m_data.resize(pos+1);
    m_data[pos] = obj.clone();
}

如果您恰好拥有type::pointer，而不仅仅是一个对象，那么另一个版本可能会很有用。有了这个重载，您只需将其移到Register，而无需clone()任何内容。

void Register::Add(int pos, type::pointer&& ptr) {
    if (pos<0)
        return;
    if (pos >= m_data.size())
        m_data.resize(pos+1);
    m_data[pos] = std::move(ptr);
}

创建/管理异构容器（c ++）

2 个答案: