These tutorials are great BTW!

This is asking for trouble. If the user passes in a non-dynamically allocated vertex array, you will end up with the vertex pointer pointing to a local variable that will eventually go out of scope. When it does, and you try to access it, you program will crash.

Instead, it is safer to allocate a new dynamic vertex array inside your constructor and then copy the vertices to it individually (using a for loop). This way you can guarantee that your vertices will persist even if the user passes in vertices that have been non-dynamically allocated.

Second, to see why Add() crashes, simply step through your code when vertices is non-null (which it is when you’ve called the above constructor):

In this case, the if condition is true, so the conditional executes. tmp is set to vertices. Because tmp and vertices are both pointers, this simply does a pointer assignment. It does not copy the vertices! So when you delete vertices, you also delete what tmp is pointing to. Consequently, after the conditional, tmp is pointing to garbage. tmp[numVerts] = newVert tries to write a vertex into unallocated memory. Then later, you delete tmp, which is already pointing to unallocated memory. Trying to delete unallocated memory will always crash your program.

You basically have the right idea, you’ve just assumed that assigning one pointer to another will copy the elements, and it won’t. It’ll just make them point to the same thing.

Your add function should look like this:

void add(Vertex newVert)
{
   Vertex* tmp = new Vertex[numVerts+1];
   if(vertices) {
// copy your old vertices into temp.  This will involve using a for loop
// and copying them individually
      delete[] vertices;
   }
   tmp[numVerts] = newVert;
   vertices = new Vertex[++numVerts]; // you don’t need this
   vertices = tmp;
   delete[] tmp; // or this

// increment numVerts here
}

This way, you allocate a new temp array, copy elements from the old array to the new array, delete the old array, and then set the old array to point to the new one.

class Polygon {

    private:
        Vertex* vertices;
        int numVerts;
    public:

        //Constructors
        Polygon(Vertex vert[], int numVerts){
            vertices = vert;
            this->numVerts = numVerts;
        }

        Polygon() {
            vertices = 0;
            numVerts = 0;
        }
…

The parameterless constructor thus creates an “empty” Polygon. There is however a function add() with which you can add a Vertex to the Polygon. I have written it like this:

void add(Vertex newVert) {

   Vertex* tmp = new Vertex[numVerts+1];
   if(vertices) {
      tmp = vertices;
      delete[] vertices;
   }
   tmp[numVerts] = newVert;
   vertices = new Vertex[++numVerts];
   vertices = tmp;
   delete[] tmp;

}

But if a create a Polygon with the default constructor and then add three Vertices the program crashes. The weird thing though is that the crash doesn’t seem to come until I have come to the last line (delete[] tmp;), but only when I add the third Vertex. The firs two go fine. Any ideas as to why this happens?

Thanks!

/P

2) My understanding is that the program/memory system keeps track of how large your arrays are (I am not sure how this happens behind the scenes). In any case, when you delete the array, it already knows how much to delete. Forcing the programmer to specify that amount would be redundant and lead to overspecification errors (eg. what if the programmer allocated 10 bytes but then tried to delete 8?)

3) Thanks, I’ll get that fixed.

2 int nSize = 12; int *pnArray = new int[nSize]; [4] = 7; delete[] pnArray;

Why is subscript not required in delete?
like
delete[nSize] pnArray;

3 Typo-
This allows “us to us to” do things like conditionally allocate memory:

Thanks,
Renu

[ The Amazon stuff has been temporarily disabled. -Alex ]

What Sergk is talking about is the fact that you can have multiple pointers pointing to the same bit of dynamically allocated memory. Let’s say you do something like this:

int *pnPtr1 = new int;
int *pnPtr2 = pnPtr1;

Now both pointers point to the dynamically allocated memory. However, if you do this:

delete pnPtr1;
pnPtr1 = 0;

pnPtr2 is left pointing to deallocated memory! And thus a call like this:

if (pnPtr2)
    *pnPtr2 = 5;

will cause your program to crash, even though it seems like it should be okay.

There are various technique for getting around this behavior (as mentioned, reference counting and garbage collection), some of which C++ support and some of which it doesn’t. From a coding standpoint, perhaps the best solution is simply to avoid having multiple pointers to the same bit of memory, though this isn’t always reasonable.