C++ C++；，Can'；如果我不使用数组或向量，我如何使用指针来解决这个问题？

我需要指针和内存管理方面的帮助

我需要存储不同的对象，它们都来自同一个基类，并且一直在使用数组来实现这一点，但是当数组中填充了不同的对象时，它会导致分段错误

当数组中充满相同派生类型的对象时，我的程序工作正常。当数组中填充了不同的对象时，它通过存储在第一个位置的对象按预期的方式工作，但当它切换到输出第二个对象时，会出现分段错误。我知道这是一个内存访问问题，但我不清楚如何管理依赖于用户输入的可变数量的对象

thx，

---

nmr

确保正在堆栈上推送的指针是动态分配的。以下操作将失败：

std::vector<Base*> objects;

void make_one(void)
{
    Derived d;

    objects.push_back(&d);
}

完成后，请记住遍历向量，并对其调用

delete

：

struct deleter
{
    template <typename T>    
    void operator()(T* pObject) const
    {
        delete pObject;
    }

}

std::for_each(objects.begin(), objects.end(), deleter());

---

如果不是，则对基类调用

delete

将仅运行基类构造函数，从而泄漏派生类可能拥有的任何资源。通过使其虚拟化，编译器可以跳转到正确的析构函数。

我不会发布完整的解决方案，因为您已将该问题确定为家庭作业，但我希望我可以帮助您解决该问题：

阵列设计用于容纳许多大小相同的对象。在数组中存储不同对象（即使它们是从同一基类派生的）的问题是，这些对象可能具有不同的大小

通过思考指针，你肯定走在了正确的轨道上

编辑（回应评论）：

你会看到这样的情况：

BaseClass * array[size];
array[0] = new DerivedClass(...);
array[1] = new OtherDerivedClass(...);
...

这种方法的一个缺陷是数组中没有内置的对象删除。您必须循环并手动调用

delete

：

for (int index = 0; index < size; index++) { delete array[index]; }

for（int index=0；index

它看起来与此处提到的问题非常相似：。您是否正在创建一个派生对象数组，并试图像访问基对象数组一样进行访问

您可以像这样使用基指针数组，但请注意，最好使用

std:：vector

而不是原始数组：

class Base
{
public:
    virtual ~Base(){}
    virtual void f() {std::cout<<"Base::f()\n";}
};


class Derived1: public Base
{
public:
    ~Derived1(){}
    void f(){std::cout<<"Derived1::f()\n";}
};

class Derived2: public Base
{
public:
    ~Derived2(){}
    void f(){std::cout<<"Derived2::f()\n";}
};


void print(Base** p, int count)
{
    for(int i = 0; i < count; ++i)
    {
        (*p)->f();
        ++p;
    }
}

int main()
{
    Base b;
    Derived1 d1;
    Derived2 d2;

    Base* arr[3];
    arr[0] = &b;
    arr[1] = &d1;
    arr[2] = &d2;

    print(arr, 3);


    return 0;
};

类基
{
公众：
虚拟~Base（）{}
虚空f（）{std:：cout请添加一些代码片段以更好地理解您的问题。您能发布一小部分代码吗，即基类a、派生类B、派生类C，以及您试图如何处理它们吗？std:：list objects；如果我使用一个基类指针数组，每个指针指向不同的派生对象，这会起作用吗？我想我没有ried迭代没有用。或者我必须将每个指向派生对象的指针的地址存储在所说的基指针数组中吗？这是一个绕口令。它的语法是什么样子的？我很有信心我的大脑现在已经崩溃了，我无法解出语法。它只是：Class*Cptr；Class*Cptr吗[size]；Cptr=new-Derived（something，something）；std:：cout-DerivedFunc（）；诸如此类？有点。请看我上面的回答。另外，睡一觉：）早上看起来真的很好。你不允许使用vector吗？这将极大地简化一切。相反，我创建了一个基本对象数组，并试图将其作为一个大小可变的派生对象数组访问。我后来意识到ed这将不起作用，我正在尝试解决执行基类指针数组的语法。我将查看您发布的链接，它看起来很有用。在这种情况下，会发生对象切片（假设您将其作为数组中的对象存储）数组中的所有对象实际上都是基类对象。您不能将其强制转换为派生类对象并尝试使用它。“将仅运行基类构造函数”…产生未定义的行为，IIRC。更好的是：直接使用正确的容器，如果您可以>>
boost:：ptr_vector
at澄清一下，我们必须动态分配，因为我们存储指针，对吗？我们可以将常规对象存储在向量中，而不必担心函数末尾的取消分配？您必须动态分配e，因为容器比它所指向的对象寿命长。如果可以保证指针在对象超出范围之前从容器中删除，则不必动态分配。存储动态分配的指针可以免除责任，并将其置于容器的保留状态。
for (int index = 0; index < size; index++) { delete array[index]; }

class Base
{
public:
    virtual ~Base(){}
    virtual void f() {std::cout<<"Base::f()\n";}
};


class Derived1: public Base
{
public:
    ~Derived1(){}
    void f(){std::cout<<"Derived1::f()\n";}
};

class Derived2: public Base
{
public:
    ~Derived2(){}
    void f(){std::cout<<"Derived2::f()\n";}
};


void print(Base** p, int count)
{
    for(int i = 0; i < count; ++i)
    {
        (*p)->f();
        ++p;
    }
}

int main()
{
    Base b;
    Derived1 d1;
    Derived2 d2;

    Base* arr[3];
    arr[0] = &b;
    arr[1] = &d1;
    arr[2] = &d2;

    print(arr, 3);


    return 0;
};