如何在C语言中通过函数修改可变大小二维数组？能否传递可变行列二维数组至函数并修改？

Great question! Let's tackle this step by step—handling variable-size 2D arrays in C can seem confusing if you've only worked with fixed-dimension examples before, but there are solid ways to both pass and modify them.

1. Use Variable-Length Arrays (VLAs, C99+) #

This is the most straightforward approach if your compiler supports C99 or later (most modern compilers like GCC, Clang do; note MSVC has limited support). VLAs let you use variables to define array dimensions in function parameters, so you can work with dynamic row/column counts directly.

#include <stdio.h>

// Modify a variable-size 2D array using VLA syntax
void double_elements(int rows, int cols, int arr[rows][cols]) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            arr[i][j] *= 2; // Double each element in-place
        }
    }
}

int main() {
    int user_rows = 3, user_cols = 4;
    int my_array[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    
    double_elements(user_rows, user_cols, my_array);
    
    // Print modified array
    for (int i = 0; i < user_rows; i++) {
        for (int j = 0; j < user_cols; j++) {
            printf("%d ", my_array[i][j]);
        }
        printf("\n");
    }
    return 0;
}

The compiler calculates memory offsets using the passed rows and cols values, so you can access the array just like a fixed-size one. Changes made inside the function affect the original array since we're passing it by reference (arrays decay to pointers in function calls).

2. Use Pointer-to-Pointer (Dynamically Allocated Arrays) #

If you need maximum compatibility (works with all C standards) or your array is allocated dynamically at runtime, use int** to represent the 2D array. This is ideal when row/column counts are only known at runtime.

#include <stdio.h>
#include <stdlib.h>

// Modify a dynamically allocated 2D array
void add_five(int rows, int cols, int** arr) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            arr[i][j] += 5; // Add 5 to each element
        }
    }
}

int main() {
    int rows = 2, cols = 3;
    // Allocate memory for rows
    int** dynamic_array = malloc(rows * sizeof(int*));
    // Allocate memory for each column in a row
    for (int i = 0; i < rows; i++) {
        dynamic_array[i] = malloc(cols * sizeof(int));
    }
    
    // Initialize the array
    dynamic_array[0][0] = 1; dynamic_array[0][1] = 2; dynamic_array[0][2] = 3;
    dynamic_array[1][0] = 4; dynamic_array[1][1] = 5; dynamic_array[1][2] = 6;
    
    add_five(rows, cols, dynamic_array);
    
    // Print results
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", dynamic_array[i][j]);
        }
        printf("\n");
    }
    
    // Don't forget to free allocated memory!
    for (int i = 0; i < rows; i++) {
        free(dynamic_array[i]);
    }
    free(dynamic_array);
    return 0;
}

Each arr[i] points to the start of a row, so you can use the familiar arr[i][j] syntax to modify elements. Just remember to free the memory in reverse order to avoid leaks.

3. Simulate 2D Array with a Single Flat 1D Array #

Another approach is to store all elements in a single contiguous block of memory and calculate indices manually. This is cache-friendly (since memory is contiguous) and works with any C standard.

#include <stdio.h>
#include <stdlib.h>

// Modify a flat array as if it were 2D
void set_to_sum(int rows, int cols, int* flat_arr) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            flat_arr[i * cols + j] = i + j; // Set element to row + column index
        }
    }
}

int main() {
    int rows = 4, cols = 2;
    int* flat_array = malloc(rows * cols * sizeof(int));
    
    set_to_sum(rows, cols, flat_array);
    
    // Print as a 2D array
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", flat_array[i * cols + j]);
        }
        printf("\n");
    }
    
    free(flat_array);
    return 0;
}

Here, i * cols + j converts the 2D (row, column) index to a 1D position in the array. The function receives a simple int*, and modifications affect the original array directly.

Why Did Your Research Mention Fixed Dimensions? #

The resources you found likely refer to the C89 standard, which didn't support VLAs. Back then, you could only pass fixed-dimension arrays (e.g., int arr[3][4]) or use workarounds like pointer-to-pointer. But modern C standards (C99 and later) have eliminated that limitation, and the methods above work perfectly for variable-size arrays.

Quick Summary #

• VLAs: Best for statically allocated arrays with dynamic dimensions (C99+ only).
• Pointer-to-Pointer: Best for dynamically allocated arrays, maximum compatibility.
• Flat 1D Array: Cache-friendly, works with all C standards, great for performance-sensitive code.

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