Cleaning up a dynamic array of Objects in C++

I'm a bit confused about handling an array of objects in C++, as I can't seem to find information about how they are passed around (reference or value) and how they are stored in an array.

I would expect an array of objects to be an array of pointers to that object type, but I haven't found this written anywhere. Would they be pointers, or would the objects themselves be laid out in memory in an array?

In the example below, a custom class myClass holds a string (would this make it of variable size, or does the string object hold a pointer to a string and therefore take up a consistent amount of space. I try to create a dynamic array of myClass objects within a myContainer. In the myContainer.addObject() method I attempt to make a bigger array, copy all the objects into it along with a new object, then d开发者_开发知识库elete the old one. I'm not at all confident that I'm cleaning up my memory properly with my destructors - what improvements could I make in this area?

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

An array in C++ is an array of objects laid out in memory. So for example in:

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

Each item in the array is going to be with a size of two ints. If you want an array of pointers you can simply declare one:

pair* array_of_pointers[10];

The string objects have pointers to the variable size part of the string. So they're safe. In fact they're the important lesson here. Same way you use the string class to avoid excessive memory handling you can use the vector class to avoid all the troubles of handling a dynamic array.

For the case you're doing this as an exercise. Here are a few problems: newObject needs to be allocated locally, without new. This will make the code correct (as newObject is not a pointer and new returns a pointer) and will also save you the trouble of explicitly handling memory. (On a more advanced note, this makes the code exception safe in one more location) myObject is never initialized. And you don't use initialization lists in the constructor. The constructor should look like this:

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

}  

The destructors in the code are exactly as they should be.

No, a dynamic array is not an array of pointers to that type - its a pointer to the first element. The elements are laid out consecutively in memory and are destroyed when the array is delete[]ed.

Thus your deallocation looks fine - you create dynamic arrays of myClass objects so you don't have to delete them individually. You would only have to do this if you had an array of pointers to (dynamically allocated) objects.

There are two definitive errors though:

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

This should be e.g.:

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

Also, myObjects is never initialized, which means it contains garbage and dereferencing/using it leads to undefined behaviour.

Finally, unless you are doing this for learning purposes, simply use containers like std::vector that do all the work for you already.

I would expect an array of objects to be an array of pointers to that object type, but I haven't found this written anywhere. Would they be pointers, or would the objects themselves be laid out in memory in an array?

The array will consist of the objects themselves. If you want to have an array of pointer you will have to declare that:

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

I assume you are used to C# or Java? In those languages objects can only be allocated on heap and are always accessed by referenced. It is possible in C++, but in C++ you can also put objects directly on the stack, or directly construct an array of the objects themselves.

In the example below, a custom class myClass holds a string (would this make it of variable size, or does the string object hold a pointer to a string and therefore take up a consistent amount of space?

Number two: The string object itself is constant in size, but has a pointer to a dynamically sized buffer allocated from the heap.

I think the deallocation looks fine. The code could be written more efficient in various ways, but it looks correct.

Try to test it, to see what happens (yes, that may be compiler-specific, but still)... You could try to add a custom destructor to myClass (even though you don't need one), that increments a "global" counter when called, Then print the counter after deleting the array.

I would expect the destructor of each object to be called. Note that quite often objects are stored "by-pointers" to allow for inherited objects to be put into the array (avoiding "slicing").