C++中用全局变量传递可变大小多维数组报错求助（不使用vector）

Hey there! I get it—sometimes you need to skip vectors and work with raw arrays, especially when dealing with variable sizes and global scope. Let’s walk through a couple of reliable approaches to fix your error and get this working smoothly.

Approach 1: Global Pointer-to-Pointer with Dynamic Allocation #

This is the most portable method (works in both C and C++) since it uses dynamic memory allocation to handle variable dimensions. Here’s how to set it up:

First, declare global variables to track the array and its size:

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

// Global variables to hold the array and its dimensions
int** global_arr;
int global_rows;
int global_cols;

Next, write a function to initialize the array once you know the required size:

void initialize_array(int rows, int cols) {
    global_rows = rows;
    global_cols = cols;
    
    // Allocate memory for rows
    global_arr = (int**)malloc(rows * sizeof(int*));
    if (global_arr == NULL) {
        perror("Failed to allocate rows");
        exit(EXIT_FAILURE);
    }
    
    // Allocate columns for each row
    for (int i = 0; i < rows; i++) {
        global_arr[i] = (int*)malloc(cols * sizeof(int));
        if (global_arr[i] == NULL) {
            perror("Failed to allocate columns");
            // Clean up already allocated memory before exiting
            for (int j = 0; j < i; j++) {
                free(global_arr[j]);
            }
            free(global_arr);
            exit(EXIT_FAILURE);
        }
    }
}

Now you can access and modify this array from any function:

void fill_array() {
    for (int i = 0; i < global_rows; i++) {
        for (int j = 0; j < global_cols; j++) {
            global_arr[i][j] = i * global_cols + j; // Example value assignment
        }
    }
}

void print_array() {
    for (int i = 0; i < global_rows; i++) {
        for (int j = 0; j < global_cols; j++) {
            printf("%d ", global_arr[i][j]);
        }
        printf("\n");
    }
}

Don’t forget to clean up memory to avoid leaks:

void cleanup_array() {
    for (int i = 0; i < global_rows; i++) {
        free(global_arr[i]);
    }
    free(global_arr);
    global_arr = NULL; // Reset pointer to avoid dangling references
}

Approach 2: Global Pointer to a Variable-Length Array (VLA) #

If you’re working in C (and using a compiler that supports VLAs, like GCC), you can declare a VLA inside a function and store its address in a global pointer. Just note that VLAs have automatic storage duration—so make sure the VLA doesn’t go out of scope while you’re using the global pointer:

#include <stdio.h>

// Global pointer to the VLA
int (*global_vla)[];
int global_rows;
int global_cols;

int main() {
    int rows = 5;
    int cols = 3;
    global_rows = rows;
    global_cols = cols;
    
    // Declare VLA (lives until main exits)
    int local_vla[rows][cols];
    global_vla = (int (*)[])local_vla;
    
    // Use the array in other functions
    fill_vla();
    print_vla();
    
    return 0;
}

void fill_vla() {
    // Cast the global pointer to the correct VLA type for proper access
    int (*arr)[global_cols] = (int (*)[global_cols])global_vla;
    for (int i = 0; i < global_rows; i++) {
        for (int j = 0; j < global_cols; j++) {
            arr[i][j] = i + j;
        }
    }
}

void print_vla() {
    int (*arr)[global_cols] = (int (*)[global_cols])global_vla;
    for (int i = 0; i < global_rows; i++) {
        for (int j = 0; j < global_cols; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

Note: VLAs aren’t standard in C++, so this approach only works for C code. Also, if you declare the VLA inside a smaller function, it’ll be destroyed when that function returns—leaving the global pointer dangling and causing undefined behavior.

Approach 3: Struct-Wrapped Global Array #

For cleaner code (to avoid scattered global variables), wrap the array pointer and dimensions in a global struct:

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

typedef struct {
    int** arr;
    int rows;
    int cols;
} MultiArray;

// Global struct instance
MultiArray global_array;

void initialize_struct_array(int rows, int cols) {
    global_array.rows = rows;
    global_array.cols = cols;
    
    global_array.arr = (int**)malloc(rows * sizeof(int*));
    if (global_array.arr == NULL) {
        perror("Allocation failed");
        exit(EXIT_FAILURE);
    }
    
    for (int i = 0; i < rows; i++) {
        global_array.arr[i] = (int*)malloc(cols * sizeof(int));
        if (global_array.arr[i] == NULL) {
            // Cleanup already allocated memory
            for (int j = 0; j < i; j++) free(global_array.arr[j]);
            free(global_array.arr);
            exit(EXIT_FAILURE);
        }
    }
}

// Access functions would use global_array.arr, global_array.rows, etc.

Common Pitfalls to Avoid #

• Directly declaring a global variable-sized array: int global_arr[rows][cols]; won’t work because global variables require compile-time constant sizes.
• Forgetting to free dynamic memory: Always clean up allocated memory to prevent memory leaks.
• Dangling pointers with VLAs: Ensure the VLA’s lifetime matches or exceeds the time you’re using the global pointer.

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