清理 C++ 中的动态对象数组

Question

我对在 C++ 中处理对象数组感到有点困惑，因为我似乎无法找到有关它们如何传递（引用或值）以及它们如何存储在数组中的信息。

我希望对象数组是指向该对象类型的指针数组，但我没有在任何地方找到这样的写法。它们是指针，还是对象本身以数组的形式放置在内存中？

在下面的示例中，自定义类 myClass 保存一个字符串（这会使其大小可变，还是字符串对象保存指向字符串的指针，因此占用一致的空间量。我尝试创建一个动态数组myContainer 中的 myClass 对象。在 myContainer.addObject() 方法中，我尝试创建一个更大的数组，将所有对象与新对象一起复制到其中，然后删除旧对象，我一点也不相信我'。我正在使用析构函数正确清理我的内存 - 我可以在这方面做出哪些改进？

class myClass
{
    private:
          string myName;
          unsigned short myAmount;

    public:
        myClass(string name, unsigned short amount)
        {
            myName = name;
        myAmount = amount;
        }

    //Do I need a destructor here? I don't think so because I don't do any
    // dynamic memory allocation within this class
};



class myContainer
{
    int numObjects;
    myClass * myObjects;

   public:
    myContainer()
    {
        numObjects = 0;
    }   

    ~myContainer()
    {
        //Is this sufficient?
        //Or do I need to iterate through myObjects and delete each
        // individually?
        delete [] myObjects;
    }


    void addObject(string name, unsigned short amount)
    {
        myClass newObject = new myClass(name, amount);

        myClass * tempObjects;
        tempObjects = new myClass[numObjects+1];
        for (int i=0; i<numObjects; i++)
            tempObjects[i] = myObjects[i]);
        tempObjects[numObjects] = newObject;
        numObjects++;
        delete newObject;

        //Will this delete all my objects? I think it won't.
        //I'm just trying to delete the old array, and have the new array hold
        // all the objects plus the new object.
        delete [] myObjects;
        myObjects = tempObjects;
    }
};

Answer 1

C++ 中的数组是放置在内存中的对象数组。
例如：

struct pair {
   int x; int y;
};
...
pair array[10];

数组中的每个项目的大小都是两个整数。
如果您想要一个指针数组，您可以简单地声明一个：

pair* array_of_pointers[10];

字符串对象具有指向字符串的可变大小部分的指针。所以他们很安全。
事实上，它们是这里重要的一课。与使用字符串类避免过多的内存处理相同，您可以使用向量类来避免处理动态数组的所有麻烦。

对于这种情况，您将这样做作为练习。这里有几个问题：
newObject需要本地分配，没有new。这将使代码正确（因为 newObject 不是指针，而 new 返回指针），并且还可以省去显式处理内存的麻烦。 （更高级地说，这使得代码异常在另一个位置变得安全）
myObject 从未初始化。并且您不在构造函数中使用初始化列表。构造函数应该如下所示：

myContainer() : numObjects(0), myObjects(NULL)
{

}  

代码中的析构函数完全符合其应有的样子。

Answer 2

不，动态数组不是指向该类型的指针数组 - 它是指向第一个元素的指针。这些元素在内存中连续排列，并在数组被delete[]编辑时被销毁。

因此，您的释放看起来很好 - 您创建了 myClass 对象的动态数组，因此您不必单独删除它们。仅当您有一个指向（动态分配的）对象的指针数组时，您才需要执行此操作。

不过，有两个明确的错误：

tempObjects[numObjects] = newObject; // assign a myClass pointer to a myClass instance?

这应该是例如：

tempObjects[numObjects] = myClass(name, amount);

此外，myObjects从未初始化，这意味着它包含垃圾，取消引用/使用它会导致未定义的行为。

最后，除非您这样做是为了学习目的，否则只需使用像 std::vector 这样的容器即可为您完成所有工作。

Answer 3

我希望对象数组是指向该对象类型的指针数组，但我没有在任何地方找到这样的写法。它们是指针，还是对象本身以数组的形式放置在内存中？

数组将由对象本身组成。如果你想要一个指针数组，你必须声明：

myClass ** tempObjects;  
tempObjects = new myClass*[numObjects+1];  

我假设你习惯 C# 或 Java？在这些语言中，对象只能在堆上分配，并且始终通过引用来访问。在 C++ 中这是可能的，但在 C++ 中你也可以将对象直接放入堆栈中，或者直接构造对象本身的数组。

在下面的示例中，自定义类 myClass 保存一个字符串（这会使其大小可变，还是该字符串对象保存指向字符串的指针，因此占用一致的空间量？

二：字符串对象本身的大小是恒定的，但有一个指向从堆分配的动态大小的缓冲区的指针，

我认为可以通过多种方式编写代码更有效，但它看起来是正确的。

Answer 4

尝试测试它，看看会发生什么（是的，这可能是特定于编译器的，但仍然）......
您可以尝试向 myClass 添加一个自定义析构函数（即使您不需要），该析构函数在调用时会增加一个“全局”计数器，然后在删除数组后打印该计数器。

我希望调用每个对象的析构函数。请注意，对象通常“按指针”存储，以允许将继承的对象放入数组中（避免“切片”）。