创建/管理异构容器(c++)
我在正确构建一个容器时遇到了问题，该容器存储不同类型的类样本，这些样本都是单个抽象类的继承者。寄存器(容器)存储指向这些样本数组的指针，该数组具有抽象类的类型。每当我试图访问包含在样本中的数据时，我只成功地检索了基类中也可以找到的部分。例如，在寄存器上使用的重载<<包含所有三个继承者的元素，只会在屏幕上写入抽象类部件，而忽略不存在的任何内容。现在我真的不知道问题是打印出原本正确存储的元素，还是存储已经以不适当的形式完成了，这就是我的问题:应该如何正确地完成这一任务？下面是代码：
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相同。以下是main的一部分：
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;
}寄存器上的操作符<<：
std::ostream &operator<<(std::ostream & os,const Register &v){
for(int i=0;i<v.elementNum;i++)
{
os<<v.pData[i]<<endl;
}
return os;
}只有使用<<运算符或寄存器中的函数才能解决此问题。编辑: Add函数的实现：
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++;
}回答 2
Stack Overflow用户
发布于 2014-05-20 21:39:21
您只能访问基类共有的公共成员，或者多形性地访问基类中可用的虚拟方法.。
此外，您只能通过指针/引用访问虚拟方法，通常不能像使用pData**.** 那样连续地存储不同的类实例。
如果您创建了一个virtual std::ostream &type::dump(std::ostream &os)成员方法，并且覆盖了type2等，那么您可以让每个overriddinen方法显示特定于其子类型的内容。
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;
}
}Stack Overflow用户
发布于 2014-05-20 23:03:51
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()方法，有时称为“虚拟复制构造函数”：
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);
}https://stackoverflow.com/questions/23770346
复制相似问题
腾讯云开发者
