动态分配矩阵删除行时触发Access Violation错误求助

Hey there! Let's dig into why you're hitting that annoying access violation error. First, let's break down the clues from the error message:

• The code 0xC0000005 means your program is trying to access memory that's either unallocated, already been freed, or out of valid bounds.
• The address 0xFDFDFDFD is a special marker used by Microsoft's heap manager to label memory that's already been deleted/released. So your code is definitely trying to read from memory that's no longer valid.

Why Your Line matrix[indexLin][indexCol] = matrix[indexLin + 1][indexCol]; Is Failing #

This line is supposed to copy data from the next row into the current one, but two common issues are causing the crash:

1. You're accessing beyond the last row
   If indexLin is the index of your matrix's final row (e.g., your matrix has 5 rows, indexes 0-4, and indexLin is 4), then indexLin + 1 becomes 5—an invalid index. Accessing this out-of-bounds memory might hit that 0xFDFDFDFD marker if that memory was previously released, or just garbage/unallocated space.

2. The row pointer matrix[indexLin + 1] already points to freed memory
   Maybe you accidentally deleted the memory for the next row before trying to copy from it. For example, if you called delete[] matrix[indexLin + 1] earlier in your code, that pointer now points to the freed memory marker, and trying to read from it triggers the violation.

Fixes to Try #

Let's walk through actionable steps to resolve this:

• Fix your loop boundaries
  When shifting rows up to delete a target row, your outer loop should only run from the row to delete up to totalRows - 2 (not totalRows - 1). This ensures indexLin + 1 never goes beyond the last valid row index. Example:

  // totalRows = current number of rows; rowToDelete = the row you want to remove
  for (int indexLin = rowToDelete; indexLin < totalRows - 1; indexLin++) {
      for (int indexCol = 0; indexCol < totalCols; indexCol++) {
          matrix[indexLin][indexCol] = matrix[indexLin + 1][indexCol];
      }
  }
  

• Reorder your memory operations
  Always copy data first, then free the memory you no longer need. Don't delete the row you're copying from before you've finished using its data. The correct order is:

  1. Shift all rows below the target row up one position.
  2. Free the memory of the now-duplicated last row.
  3. Resize your row pointer array to remove the extra slot.

• Validate your matrix structure
  Double-check that your dynamic matrix was allocated correctly. For a 2D matrix in C++, it should look like this:

  int** matrix = new int*[totalRows];
  for (int i = 0; i < totalRows; i++) {
      matrix[i] = new int[totalCols];
      // Optional: Initialize values to avoid garbage data
      memset(matrix[i], 0, sizeof(int) * totalCols);
  }
  

  Make sure none of the row pointers are null or pointing to invalid memory before modifying the matrix.

• Add debug checks
  Insert quick print statements right before the error line to confirm your indices are valid:

  // Print these values immediately before the problematic line
  std::cout << "Current row index: " << indexLin 
            << ", Next row index: " << indexLin + 1 
            << ", Total rows: " << totalRows << std::endl;
  

  This will instantly tell you if indexLin + 1 is going out of bounds.

Example of a Working Row Deletion Function #

Here's a complete, safe example of how to delete a row from a dynamically allocated 2D matrix in C++:

#include <iostream>
#include <cstring>

void deleteMatrixRow(int**& matrix, int& totalRows, int totalCols, int rowToDelete) {
    // Guard against invalid row indices
    if (rowToDelete < 0 || rowToDelete >= totalRows) {
        std::cerr << "Invalid row index to delete!" << std::endl;
        return;
    }

    // Shift rows up to overwrite the row to delete
    for (int i = rowToDelete; i < totalRows - 1; i++) {
        std::memcpy(matrix[i], matrix[i + 1], sizeof(int) * totalCols);
        // Use a nested loop instead if memcpy isn't suitable:
        // for (int j = 0; j < totalCols; j++) {
        //     matrix[i][j] = matrix[i+1][j];
        // }
    }

    // Free the last row's memory (it's now duplicated in the row above)
    delete[] matrix[totalRows - 1];

    // Resize the row pointer array to remove the extra slot
    int** newMatrix = new int*[totalRows - 1];
    std::memcpy(newMatrix, matrix, sizeof(int*) * (totalRows - 1));
    delete[] matrix;

    // Update the matrix pointer and row count
    matrix = newMatrix;
    totalRows--;
}

Give these fixes a shot—odds are your issue is either an out-of-bounds loop or a misplaced memory free operation.

内容的提问来源于stack exchange，提问作者Robert Sperchez