Thread: Help with pointers/arrays.

There's a particular function in this program that I'm having a hard time understanding. The confusing part has to do with pointers pointing to arrays.

I have some questions but mostly I want to know if my thinking (i.e. understanding of what's happening) is right or not.

Here's the code then my questions and thoughts on what I think is happening. I've included my thoughts and questions in bold as comments in the code - note there are also regular comments that aren't bolded, these are from my book instructions that I copied for reference for myself when I look at the code:

Code:

void Tape(const char theOperator,const int theOperand)
{
    static const int myTapeChunk = 3; // 1.Declares myTapeChunk as a static const int and sets its value to three.

    static char *myOperator = new char[myTapeChunk]; // 2.Declares myOperator as a pointer to char array. Basically it sets myoperator = to element 0 of new myTapeChunk char 

array?
    static int *myOperand = new int[myTapeChunk]; //  3.Same here except with operand.

    static int myTapeSize = myTapeChunk;  4.Declares myTapeSize = to myTapeChunk or in this case 3.
    static int myNumberOfEntries = 0;  5.creates static int and sets it to 0

    switch (theOperator) //  6.the switch starts. Cases being the operators ?, . and default
    {
        case '?': // Displays the tape

            for (int Index = 0; Index < myNumberOfEntries; Index++)
            {
                cout << myOperator[Index] << "," << myOperand[Index] << endl; //  7.Not so sure about this. I'm thinking the pointer myOperator is holding the address of the 

first element of index?
            }
            break;

        case '.': // The program is stopping, delete arrays // 8.sounds simple enough. Entering '.' deletes and frees back up the space taken by myoperator and operand?

            delete [] myOperator;
            delete [] myOperand;

            break;

        default: // Add to the tape and expand if needed // 9.Default kicks in, which is basically anytime the case isn't '?' or '.' 

            if (myNumberOfEntries == myTapeSize) // Expand //10. See last comment on confusion about this
            {
                // Create a destination for the expansion

                char *ExpandedOperator = new char[myNumberOfEntries + myTapeChunk]; //11.This creates the new pointer named ExpandedOperator and it's equal to (or holds) the 

first address (i.e. where the first element is) or the new char array which now has 6 element slots?

                int *ExpandedOperand = new int[myNumberOfEntries + myTapeChunk]; // 12. same here except with the Operand

                // We use pointers to do the array copy,
                // starting at the array start position.

                char *FromOperator = myOperator; // 13.pointer FromOperator is created and now holds the address of the first element of myOperator?
                int *FromOperand = myOperand;    //14. Same as above except with operand   

                char *ToOperator = ExpandedOperator; //15. Pointer ToOperator is created and now holds the address of the first element of ExpandedOperator?
                int *ToOperand = ExpandedOperand;   //16. Same as above except with operand

                // Copy the old arrays to the new - this is supposed to be faster
                // than copying indexes but it is dangerous

                for (int Index = 0; Index < myNumberOfEntries; Index++) //17.myNumberofEntries is equal to three (or four? see below) so the loop will go 0,1,2 or the three 

numbers that I've entered in their elements?
                {
                    *ToOperator++ = *FromOperator++; //18.The way I understand this is since * has a higher precedence, ++ doesn't happen until each of these are copied. So it's 

taking what's in the first element of myOperator (since fromoperator points to it's first element) and copying it to the first element pointed to by ToOperator (which is 

ExpandedOperator)? Then they both move on to copy the next element (the ++ part). Same below 
                    *ToOperand++ = *FromOperand++;
                }

                // Delete old arrays

                delete [] myOperator; 
                delete [] myOperand;

                // Replace the old pointers with the new

                myOperator = ExpandedOperator; //  19.This is something I'm confused by. Didn't I just delete myOperator? So how can we now set it to ExpandedOperator if it's 

just been deleted? Also, why do I even need to do that? Didn't I take care of that with all the above transfers that I just did?
                myOperand = ExpandedOperand;

                // Record how big the array is now

                myTapeSize+= myTapeChunk; 

                // Now it's safe to add a new entry
            }

            myOperator[myNumberOfEntries] = theOperator;
            myOperand[myNumberOfEntries] = theOperand; 
            myNumberOfEntries++;          // 20.I'm a bit confused about this being down here. If I understand correctly, this runs if the case is default. But lets say I've 

already entered two things (two operators and two operands each being held in there 0 and 1 element slot) and I've just entered a third. Does the program wait until the next
time around to run the if statement right below default (since 3 now == to 3) or does it run it as soon as it gets down here and I've entered a third number and operator?  
    }
}

I've numbered my comments in case anyone just wants to address a particular one. I've racked my head over this now for two days now so any help or clarification I can get would be much appreciated.

Thanks in advance.

EDIT: I forgot one question. Say the default switch statement runs and hence the if statement runs (i.e. 3 ==3), what happens the next time it has to run again? After it runs for the first time myTapeSize is increased to 6, and if myNumberOfEntries get to six, does it run again? Basically, how can it even run again? In my comment number 13, FromOperator is being set to myOperator, which I erased... Also, regarding the code next to comment 19. - myOperator=ExpandedOperator - didn't I already do that? Shouldn't it need a new pointer to be created and set to?

It obviously doesn't though because the program runs fine past six, so I guess I'm just not getting it.