如何在C++11中基于命令行参数创建动态数组（不使用malloc/calloc）

当然有合适的办法！先给你理清楚原代码报错的核心原因：C++里new int[SIZE][SIZE*4]这种二维数组的分配语法，要求第二个维度必须是编译期常量，而你的SIZE是从命令行参数计算出来的运行时变量，所以编译器直接拒绝了这种写法。

下面给你三种C++11风格的解决方案，按推荐程度排序：

方案一：使用std::vector嵌套（最推荐） #

std::vector是C标准库提供的动态容器，会自动管理内存分配和释放，完全不需要手动调用delete，代码简洁又安全，是C里处理动态数组的首选方式：

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

int main(int argc, char** argv) {
    if(argc < 2) exit(1);
    float input = strtof(argv[1], NULL);
    int SIZE = static_cast<int>(input / 8);
    // 创建二维vector，所有元素初始化为0
    vector<vector<int>> arr(SIZE, vector<int>(SIZE * 4, 0));
    
    // 遍历输出（用法和原生二维数组完全一致）
    for(int i = 0; i < SIZE; i++) {
        for(int j = 0; j < SIZE*4; j++) {
            cout << arr[i][j];
        }
    }
    return 0;
}

方案二：手动创建指针数组+逐行分配 #

如果你更习惯原生指针的写法，可以先分配一个指针数组，再为每个指针分配对应的一维数组，模拟二维数组的结构：

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

int main(int argc, char** argv) {
    if(argc < 2) exit(1);
    float input = strtof(argv[1], NULL);
    int SIZE = static_cast<int>(input / 8);
    // 先分配存储行指针的数组
    int** arr = new int*[SIZE];
    // 为每一行分配对应的数组，初始化为0
    for(int i = 0; i < SIZE; i++) {
        arr[i] = new int[SIZE * 4]();
    }
    
    // 遍历输出
    for(int i = 0; i < SIZE; i++) {
        for(int j = 0; j < SIZE*4; j++) {
            cout << arr[i][j];
        }
    }
    
    // 注意：必须手动释放内存，避免泄漏！
    // 先释放每一行的数组
    for(int i = 0; i < SIZE; i++) {
        delete[] arr[i];
    }
    // 再释放指针数组
    delete[] arr;
    return 0;
}

⚠️ 注意：这种方式一定要按顺序释放内存，先释放每一行，再释放指针数组，否则会造成内存泄漏。

方案三：用一维数组模拟二维数组（内存连续） #

如果追求内存的连续性（可能提升缓存性能），可以直接分配一个一维数组，然后通过索引计算来模拟二维访问：

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

int main(int argc, char** argv) {
    if(argc < 2) exit(1);
    float input = strtof(argv[1], NULL);
    int SIZE = static_cast<int>(input / 8);
    int col_count = SIZE * 4;
    int total_elements = SIZE * col_count;
    // 分配连续的一维数组，初始化为0
    int* arr = new int[total_elements]();
    
    // 模拟二维访问：arr[i * col_count + j] 等价于原代码的arr[i][j]
    for(int i = 0; i < SIZE; i++) {
        for(int j = 0; j < col_count; j++) {
            cout << arr[i * col_count + j];
        }
    }
    
    // 只需要一次释放操作
    delete[] arr;
    return 0;
}

这种方式的优势是内存是连续的，对于大规模数组来说，缓存命中率更高，访问速度可能更快，而且内存释放只需要一次delete[]。

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