使用realloc调整C中2D数组的大小

Question

Assignment: we have a canvas which the user can "paint" on - they can draw lines, add or delete rows/columns, etc. One of the commands we have to implement is resizing the canvas. Per the assignment specs, new rows are added to the top of the canvas, and new columns on the right. These new rows/columns are filled with blank spaces, which are denoted by '*'. The user inputs r numRows numCols .

The part where I'm struggling is using realloc. If I have a 5x5 canvas to start with, and the user decides to resize to be 7x5, how would I do that? Where does realloc put the new rows/columns, and does it automatically shift the existing rows downwards? I have a function implementResize that is called when the user inputs ar:

void implementResize(BoardState* boardState, int newRows, int newCols) {
  if (newRows > boardState->board.numRows) {
    printf("add rows\n");
    addRow(boardState, newRows);
  }
  else if (newCols < boardState->board.numRows) {
    printf("delete rows\n");
    //deleteRow();
  }
  else {
    printf("same\n");
    boardState->board.numRows = newRows;
  }
  if (newCols > boardState->board.numCols) {
    printf("add columns\n");
    //addCol();
  }
  else if (newCols < boardState->board.numCols) {
    printf("delete columns\n");
    //deleteCol();
  }
  else {
    printf("same\n");
    boardState->board.numCols = newCols;
  }
}

Right now I'm focusing on how to add rows to the top of the canvas. My code for the function addRow right now is:

void addRow(BoardState *boardState, int newRows) {
  boardState->board.numRows = newRows;
  boardState->board.theBoard = (char**) realloc(boardState->board.theBoard, boardState->board.numRows * sizeof(char*));
}

I'm trying to figure out how to realloc space for the rows. I know I need to use a nested for loop based on the number of newRows and the number of columns, but I'm not sure where these new rows go. If anyone could clear my confusion up I would appreciate it.

Answer 1

This code cannot be directly put into your program because it does not use addColumn or addRow . This instead gives you an idea how you could approach the problem.

Comments have been added at lines where there is a catch. There are also some suggestions.

    int  resizeBoard(BoardState *boardState, size_t newRows, size_t newCols) {
    //verify before you dereference
    if(boardState == NULL)
        return 0;

    if(boardState->board.theBoard == NULL)
        return 0;

    const size_t oldRows = boardState->board.numRows; //more readbale

    /*
    ** if the number of rows decreased, free the excess
    ** we have to do it now because it becomes inaccessible after realloc of boardState.board.theBoard
    */
    for(int i = newRows; i < oldRows; i++)
        free(boardState->board.theBoard[i]);

    /* set these to the new values so that freeBoard gets the correct data in case of failure */
    boardState->board.numRows = newRows;
    boardState->board.numCols = newCols;

    //it is important to use a different pointer to store the value returned by realloc because if the reallocation fails, realloc will return NULL and we will lose access to the original board
    void *ptr = realloc(boardState->board.theBoard, izeof(char*)*newRows);
    if(ptr == NULL) { 
        //realloc failed
        freeBoard(boardState);
        return 0;
    }
    boardState->board.theBoard = ptr;

    //As realloc copies the previous data to the new memory location, theBoard is still pointing to the old rows (from row 0 to row [newRows - 1])
    for(int i = 0; i < min(newRows, oldRows); i++) {
        void *ptr = realloc(boardState->board.theBoard[i], sizeof(char)*newCols);
        if(ptr == NULL) {
            //realloc failed
            freeBoard(boardState);
            return 0;
        }
        boardState->board.theBoard[i] = ptr;
    }

    //we cannot use realloc for first time memory allocation; doing so causes undefined behaviour
    //we must separately allocate memory for the new rows
    for(int i = oldRows; i < newRows; i++)
    {
        boardState->board.theBoard[i] = malloc(sizeof(char)*newCols);
        if(boardState->board.theBoard[i] == NULL) {
            //perform cleanup
            return 0;
        }
    }
    return 1;
}