C++构造函数中赋值char二维数组及使用柔性数组成员的可行性问题

• 第一个核心错误：C++标准不支持C99风格的柔性数组成员，这是C语言特有的语法，部分C++编译器虽然做了扩展支持，但使用逻辑和C一致：柔性数组成员不会占用类的存储空间，定义类对象时需要手动额外申请对应大小的内存来存储柔性数组的内容，你之前直接定义A(states)相当于没有给_x分配内存，strcpy操作写入的是非法内存地址，自然不会生效甚至会触发内存访问异常。
• 第二个常见错误：数组作为函数形参时会自动退化为指针，你写的A(char b[][20])实际等效于A(char (*b)[20])，形参b是一个指向长度为20的char数组的指针，sizeof(b)得到的是指针本身的字节长度（32位系统为4，64位系统为8），和传入的数组实际长度完全无关，你用sizeof(b)/sizeof(b[0])计算循环次数得到的结果恒为0，循环根本不会执行，自然不会有赋值效果。
• 第三个错误：你第二种写法里的char* _x[20]数组成员是未初始化的野指针，直接调用strcpy向野指针指向的地址写入内容属于非法内存操作，会产生未定义行为。你之前单个char*赋值能成功，是因为你直接拷贝的是指针的指向（浅拷贝，指向外部定义的字符串常量地址），没有做内存拷贝操作，自然不会触发野指针问题。

方案1：固定大小数组方案（最稳妥，无兼容性问题） #

该方案无动态内存分配，是嵌入式场景的首选实现
如果你可以提前确定二维数组的第一维最大长度，直接用固定大小数组，注意把数组长度作为参数传入构造函数，不要依赖sizeof计算形参数组长度：

#include <string.h>
class A{
public:
    // 传入数组指针+实际元素个数
    A(char b[][20], int count);
private:
    // 提前定义最大长度，按需调整即可
    static const int MAX_STATE_COUNT = 16;
    char _x[MAX_STATE_COUNT][20];
    int _count; // 存储实际存入的元素个数
};

A::A(char b[][20], int count) {
    // 边界检查，避免越界
    if(count > MAX_STATE_COUNT) count = MAX_STATE_COUNT;
    _count = count;
    for(int i = 0; i < count; i++) {
        strncpy(_x[i], b[i], 19); // 用strncpy避免溢出，留1位存储结束符
        _x[i][19] = '\0';
    }
}

// 调用示例
char states[][20] = {"State1","State2","State3","State4"};
// 手动传入元素个数
A a(states, sizeof(states)/sizeof(states[0]));

方案2：编译器扩展柔性数组方案（需要动态长度时使用） #

如果你的编译器支持C++下的柔性数组扩展（比如GCC），需要配合动态内存申请使用，嵌入式场景下可以替换为自定义的内存分配函数：

#include <stdlib.h>
#include <string.h>
class A{
public:
    // 工厂函数创建对象，构造函数无法直接申请柔性数组需要的额外内存
    static A* createInstance(char b[][20], int count);
private:
    // 构造函数私有，仅允许通过工厂函数创建实例
    A(int count) : _count(count) {}
    int _count;
    char _x[][20]; // 柔性数组成员必须放在类定义的最后
};

A* A::createInstance(char b[][20], int count) {
    // 申请内存：类本身的大小 + 柔性数组需要的内存大小
    A* obj = (A*)malloc(sizeof(A) + count * sizeof(char[20]));
    if(!obj) return nullptr;
    // 手动调用构造函数完成初始化
    new (obj) A(count);
    // 拷贝内容
    for(int i = 0; i < count; i++) {
        strncpy(obj->_x[i], b[i], 19);
        obj->_x[i][19] = '\0';
    }
    return obj;
}

// 调用示例
char states[][20] = {"State1","State2","State3","State4"};
int count = sizeof(states)/sizeof(states[0]);
A* a = A::createInstance(states, count);
// 使用完后释放内存：如果有自定义析构逻辑需要先手动调用析构函数，再释放内存
// a->~A(); free(a);

方案3：浅拷贝方案（外部字符串生命周期和类对象一致时使用） #

如果你的外部states数组是全局/静态变量，生命周期和类对象完全一致，可以直接拷贝指针，不需要内存拷贝，和你之前单个char*赋值的逻辑一致：

#include <string.h>
class A{
public:
    A(const char* b[], int count);
private:
    static const int MAX_STATE_COUNT = 16;
    const char* _x[MAX_STATE_COUNT];
    int _count;
};

A::A(const char* b[], int count) {
    if(count > MAX_STATE_COUNT) count = MAX_STATE_COUNT;
    _count = count;
    for(int i = 0; i < count; i++) {
        _x[i] = b[i]; // 直接拷贝指针，仅做浅拷贝
    }
}

// 调用示例
const char* states[] = {"State1","State2","State3","State4"};
A a(states, sizeof(states)/sizeof(states[0]));

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