Using a pointer to dynamically allocate array

Question

I am trying to use a dynamically allocate an array using a pointer in my tic tac toe game. I am a little confused on how exactly pointers work. We are using the cplusplus.com website as our textbook, and I think the section on pointers is a little confusing for me. Would it be possible to get a explanation of it and possibly help do that to my tic tac toe game? Here is my code:

//Sophia Ali
// TicTacToe (CS-509 Assignment 5)

#include<iostream>
#include<cstdlib>
using namespace std;

enum Status { WIN, DRAW, CONTINUE, QUIT };

void showBoard( const char board[], int boardSize );
// show current state of board
Status checkGameState( const char board[] );
// returns WIN or CONTINUE
int getHumanSquare( const char board[] );
int getComputerSquare( const char board[] );
bool checkBadSquare( const char board[], int squareNum );
// checks to see if a chosen square is already taken; returns true if
// already taken; used by get*Square functions above.
int getrandint( int min, int max );


int main()
{
    char board[] = "123456789";   // 10 element char board
    const int boardSize = 10;
    Status gameState = CONTINUE;
    int gametype, squareChoice, turnNum = 0;
    char currentSymbol;           // 'o' or 'x'


    cout << "\n This is a Tic Tac Toe program. Choose the type of game: "
         << "\n (1) human o vs. human x    (2) human o vs. dumb computer x"
         << "\n\n -> ";
    cin  >> gametype;

    /* Show the current state of Tic Tac Toe board. */
    showBoard( board, boardSize );

    /*
       Main game loop
     */
    while ( gameState == CONTINUE )
    {
        /* Increment turnNum by 1. */
        turnNum++;


        /* If turnNum equal to 10
              Set gameState to DRAW.
              Break out of while loop. */
        if ( turnNum == 10 )
        {
            gameState = DRAW;
            break;
        }


        /* If we are on an odd-numbered turn
              Print "It's o's turn."
              Set currentSymbol to 'o'.
              Call getHumanSquare function to get squareChoice.
           Else (we are on an even-numbered turn)
              Print "It's x's turn."
              Set currentSymbol to 'x'.
              If the gametype is 1 (human vs. human)
                 Call getHumanSquare function to get squareChoice.
              Else (gametype is 2 (human vs. computer))
                 Call getComputerSquare function to get squareChoice.*/

        // Get current player's square choice and insert into board
        if ( turnNum%2 != 0)
        {
            cout << "\n It's o's turn.";
            currentSymbol = 'o';
            squareChoice = getHumanSquare( board );
        }
        else
        {
            cout << "\n It's x's turn.";
            currentSymbol = 'x';
            if ( gametype == 1 )
                squareChoice = getHumanSquare( board );
            else
                squareChoice = getComputerSquare( board );
        }
        /* If squareChoice is -1 (human player quit)
              Set gameState to QUIT.
           Else
              Insert currentSymbol into board at (squareChoice - 1).
              Show the current state of the Tic Tac Toe board.
              Call checkGameState function to determine the gameState. */
        if ( squareChoice == -1 )
            gameState = QUIT;
        else
        {
            board[ squareChoice - 1 ] = currentSymbol;
            showBoard( board, boardSize );
            gameState = checkGameState( board );
        }

    }     // end while



    /* If gameState is WIN
              print "Player " currentSymbol " is the winner." */
    /* If gameState is DRAW
              print "It's a draw." */
    if ( gameState == WIN )
        cout << "Player " <<currentSymbol << " is the winner.";
    if ( gameState == DRAW )
        cout << "It's a draw.";

    return 0;

} // end main





/////////////////////////////////////////////////////////////////////

void showBoard( const char board [], int size )
{
    cout << endl;

    for ( int i = 0; i < size ; i++ )
    {
        cout << board[ i ] << " ";
        if ( ( i + 1 ) % 3 == 0 )
            cout << endl;
    }

    cout << endl;
}

/////////////////////////////////////////////////////////////////////

Status checkGameState( const char board[] )
{
    // Board       Array
    //
    // 1 2 3       0 1 2
    // 4 5 6  -->  3 4 5
    // 7 8 9       6 7 8
    //
    // Diagonal winners
    if ( board[ 0 ] == board[ 4 ] && board[ 0 ] == board[ 8 ] )
        return WIN;
    else if ( board[ 2 ] == board[ 4 ] && board[ 4 ] == board[ 6 ] )
        return WIN;
    // Horizontal winners
    else if ( board[ 0 ] == board[ 1 ] && board[ 1 ] == board[ 2 ] )
        return WIN;
    else if ( board[ 3 ] == board[ 4 ] && board[ 4 ] == board[ 5 ] )
        return WIN;
    else if ( board[ 6 ] == board[ 7 ] && board[ 7 ] == board[ 8 ] )
        return WIN;
    // Vertical winners
    else if ( board[ 0 ] == board[ 3 ] && board[ 3 ] == board[ 6 ] )
        return WIN;
    else if ( board[ 1 ] == board[ 4 ] && board[ 4 ] == board[ 7 ] )
        return WIN;
    else if ( board[ 2 ] == board[ 5 ] && board[ 5 ] == board[ 8 ] )
        return WIN;
    else
        return CONTINUE;
}

/////////////////////////////////////////////////////////////////////

int getHumanSquare( const char board[] )
{
    int squareNum;

    cout << "\n Input the number of an empty square: (-1 to quit) ";
    cin  >> squareNum;

    while ( checkBadSquare( board, squareNum ) == true )
    {
        cout << "\n Bad input. Choose another square: ";
        cin >> squareNum;
    }

    return squareNum;
}

/////////////////////////////////////////////////////////////////////

int getComputerSquare( const char board[] )
{
    int squareNum;

    squareNum = getrandint( 1, 9 );

    while ( checkBadSquare( board, squareNum ) == true )
    {
        squareNum = getrandint( 1, 9 );
    }

    return squareNum;
}

/////////////////////////////////////////////////////////////////////

bool checkBadSquare( const char board[], int squareNum )
{
    int realSquareNum = squareNum - 1; // count from 0

    if ( squareNum == -1 )
        return false;  // Let quit code pass as a valid square
    else if ( squareNum > 9 )
        return true;   // Square numbers out of range are invalid
    else if ( board[ realSquareNum ] == 'o' || board[ realSquareNum ] == 'x' )
        return true;   // Occupied squares are invalid
    else
        return false;  // Valid square number
}

/////////////////////////////////////////////////////////////////////

int getrandint( int min, int max )
{
    int scale, shift;
    scale = max - min + 1;
    shift = min;
    return rand() % scale + shift;
}

Answer 1

This is a statically allocated array, the compiler knows the size from the "123456789" initializer. The size of the array is 10 because the compiler will add an extra space for the '\0' terminator that C strings have.

char board[] = "123456789";

This does the same thing with dynamic allocation

char* board = new char[10];
strcpy(board, "123456789");

With dynamic allocation you get to decide how big the array should be when the program runs (that's why it's dynamic). But in this program the size is always ten. The next line (strcpy) copies the same string into the dynamically allocated array that you had in the old code.

What's the advantage of doing this? Absolutely nothing. In fact the version with dynamic allocation is worse and would get a lower mark from me if I were marking your work. But you've been told to do it so I suppose you must.