C++类中实现堆上二维数组：避免多级指针与STL，支持下标访问

Got it, let's break down what's wrong with your original code and fix it properly.

Your current code tries to initialize a static 2D array member (int arr[1000][2]) with a heap-allocated array pointer from new int[1000][2]—these are incompatible types. The static array is a fixed-size, stack-allocated (unless marked static) type, while new returns a pointer to the first element of the heap array. That's why you get the type mismatch error.

To use array syntax (arr[row][col]) with heap-allocated memory, here are two robust solutions that avoid STL and multi-level pointers:

Option 1: Fixed Columns, Dynamic Rows (Your Original Use Case) #

If the number of columns is fixed (like 2 in your example), declare a pointer to an array of that column size. This lets you use natural 2D array syntax directly.

Complete Code: #

class MyClass {
public:
    // Constructor: Allocate 1000 rows, each with 2 integers
    MyClass() : arr(new int[1000][2]) {}
    
    // Destructor: Clean up the heap-allocated array
    ~MyClass() {
        delete[] arr;
    }
    
    // Disable default copy/assignment to avoid shallow copy bugs
    MyClass(const MyClass&) = delete;
    MyClass& operator=(const MyClass&) = delete;
    
    // Example: Access elements with array syntax
    void setValue(int row, int col, int val) {
        if (row >= 0 && row < 1000 && col >= 0 && col < 2) {
            arr[row][col] = val; // Exactly the syntax you want!
        }
    }
    
    int getValue(int row, int col) const {
        if (row >= 0 && row < 1000 && col >= 0 && col < 2) {
            return arr[row][col];
        }
        return -1; // Handle out-of-bounds as needed
    }

private:
    // Member variable: Pointer to an array of 2 integers
    int (*arr)[2];
};

Why This Works: #

• int (*arr)[2] is a pointer to a single row (an array of 2 ints). When you allocate new int[1000][2], it returns exactly this type—a pointer to the first row of your 1000-row array.
• arr[row][col] translates to pointer arithmetic under the hood: it offsets the pointer by row rows (each row is 2 * sizeof(int) bytes), then accesses the col-th element in that row. No messy pointer dereferencing needed.

Option 2: Fully Dynamic Rows and Columns #

If you need both rows and columns to be dynamic (not fixed at compile time), you can simulate a 2D array with a single heap-allocated 1D array, then overload the operator[] to enable array syntax.

Complete Code: #

class MyClass {
public:
    // Constructor: Allocate rows x cols integers
    MyClass(int rows, int cols) : rows(rows), cols(cols), arr(new int[rows * cols]) {}
    
    // Destructor: Clean up the heap memory
    ~MyClass() {
        delete[] arr;
    }
    
    // Disable default copy/assignment
    MyClass(const MyClass&) = delete;
    MyClass& operator=(const MyClass&) = delete;
    
    // Overload [] to return a pointer to the start of a row
    int* operator[](int row) {
        return arr + (row * cols); // Point to the first element of the row
    }
    
    // Const version for read-only access
    const int* operator[](int row) const {
        return arr + (row * cols);
    }

private:
    int rows;
    int cols;
    int* arr; // Single 1D array holding all elements
};

Usage Example: #

int main() {
    MyClass obj(5, 3); // 5 rows, 3 columns
    obj[2][1] = 42; // Set element at row 2, column 1
    std::cout << obj[2][1]; // Outputs 42
    return 0;
}

Both solutions let you use the clean arr[row][col] syntax, avoid STL, and skip multi-level pointers. Pick the first option if your column count is fixed, or the second if you need full dynamic sizing.

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