如何创建以可变维度二维数组为参数的C++函数？

Hey there! Let's work through your problem together. I see you're trying to create a function that handles a 2D array with a variable size you can set at runtime—great question, this is a common hurdle when starting out with C++.

First, let's break down why your original code is throwing errors:

1. "array bound is not an integer constant": In standard C++, the size of an array (including in function parameter declarations) needs to be a compile-time constant. Your global size is a runtime variable, so the compiler can't know its value when processing the function declaration. Even if you use a compiler that supports C99-style Variable Length Arrays (VLAs) as an extension, relying on a global variable for the dimension won't work because the function needs to know the size at call time, not just at compile time.
2. Trying to modify a const variable: When you declare a variable as const, you're telling the compiler it's read-only. Casting away that const to modify it is undefined behavior (meaning the program could crash, behave unpredictably, or just fail to work), and most compilers will block this conversion outright to protect you.

Now, here are two solid, standard-compliant solutions:

Solution 1: Use std::vector (Recommended) #

std::vector is the standard C++ way to handle dynamic-sized arrays—no compiler extensions needed, and it manages memory automatically so you don't have to worry about leaks. Here's how to adapt your code:

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

// Function takes a const reference to a 2D vector to avoid unnecessary copying
void function(const vector<vector<int>>& array) {
    int size = array.size();
    // Example operation: print the array
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            cout << array[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int size;
    cout << "Enter size: ";
    cin >> size;

    // Create a 2D vector with 'size' rows and 'size' columns
    vector<vector<int>> array(size, vector<int>(size));

    // Optional: Fill the array with sample values
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            array[i][j] = i * size + j;
        }
    }

    function(array);
    return 0;
}

This approach is clean, safe, and works across all modern C++ compilers.

Solution 2: Use Dynamic Allocation (with new/delete) #

If you prefer to use raw pointers (though vectors are better for most cases), you can manually allocate a 2D array at runtime. Just remember to free the memory when you're done to avoid leaks:

#include <iostream>
using namespace std;

void function(int size, int** array) {
    // Example operation: print the array
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            cout << array[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int size;
    cout << "Enter size: ";
    cin >> size;

    // Allocate an array of pointers (one per row)
    int** array = new int*[size];
    // Allocate each individual row
    for (int i = 0; i < size; ++i) {
        array[i] = new int[size];
    }

    // Optional: Fill the array with sample values
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            array[i][j] = i * size + j;
        }
    }

    function(size, array);

    // Free memory: first delete each row, then the array of pointers
    for (int i = 0; i < size; ++i) {
        delete[] array[i];
    }
    delete[] array;

    return 0;
}

Bonus: Compiler Extension (VLAs) #

If you're using a compiler that supports C99 VLAs (like GCC or Clang), you can pass the size as a function parameter before the array, which lets the compiler know the dimension at call time. Note this isn't standard C++, so it won't work with all compilers (like MSVC without special flags):

#include <iostream>
using namespace std;

// Pass size first, then the array so the compiler knows its dimension
void function(int size, int array[][size]) {
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            cout << array[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int size;
    cout << "Enter size: ";
    cin >> size;

    // VLA: array size determined at runtime
    int array[size][size];

    // Optional: Fill the array with sample values
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            array[i][j] = i * size + j;
        }
    }

    function(size, array);
    return 0;
}

To recap:

• Avoid using global variables for array dimensions—they don't play nice with function declarations in standard C++.
• Never try to modify a const variable—it's undefined behavior and the compiler will block it anyway.
• Stick with std::vector for the most portable, safe solution.

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