动态分配对象的成员字段顺序是否固定？能否依赖其做类型判断？

Great question—this dives into one of the more low-level aspects of C++ that's often taken for granted, but has important rules you need to follow to avoid undefined behavior. Let's break down each of your scenarios one by one:

1. 结构体成员的内存分配顺序 #

对于你定义的Rectangle结构体：

struct Rectangle { int len; int wid; };
Rectangle* myRect = new Rectangle;
void* vPtr = myRect;

在C++标准中，**标准布局类型（standard-layout type）**的非静态数据成员会严格按照声明的顺序在内存中分配，且第一个成员之前不会有填充字节（padding）。Rectangle完全符合标准布局的要求：没有虚函数、没有基类、所有成员的访问控制一致（默认public）。

所以：

• *(int*)(vPtr) 始终等价于 myRect->len——因为len是第一个成员，它的起始地址和结构体对象的起始地址完全相同。
• *(int*)(vPtr + sizeof(int)) 始终等价于 myRect->wid——两个int类型的成员之间通常没有填充（除非编译器启用了特殊非标准设置，这在常规场景下不会发生）。

不过要注意：如果结构体包含不同类型的成员，或者加入了访问控制符的分隔（比如先public后private），可能会引入填充字节，但成员的声明顺序依然会被严格保留。

2. 类成员的内存分配顺序 #

对于你的Button类：

class Button { Rectangle* frame; char* Text; } *myButton;
void * vButton = myButton;

这个Button类同样是标准布局类型（没有虚函数、没有基类、成员默认public），所以成员会按照声明顺序分配内存。frame作为第一个成员，其起始地址和Button对象的起始地址完全一致。

你的代码里*(int*)((*Rectangle)(vButton))应该是笔误，正确的写法需要先取出frame指针：

// 先获取Button对象的第一个成员frame指针
Rectangle* framePtr = *(Rectangle**)vButton;
// 访问frame的len字段
int lenValue = framePtr->len;
// 或者用指针运算实现：
int lenValue = *(int*)framePtr;

只要Button保持标准布局，这个逻辑就是可靠的。

3. 依赖首字段判断对象类型 #

对于你的Button、Edit类以及类型判断代码：

#define WND_BUTTON 1
#define WND_EDIT 2
class Button { private: BYTE TypeWindow; SMALL_RECT srFrame; /*...*/ };
class Edit { private: BYTE TypeWindow; SMALL_RECT srFrame; /*...*/ };
typedef void* HANDLE;

HANDLE hWindow = Create(...);
if (*(BYTE*)(hWindow) == WND_BUTTON) std::cout << "This is a button." << std::endl;
if (*(BYTE*)(hWindow) == WND_EDIT) std::cout << "This is a text field." << std::endl;

这种做法在特定条件下是可行的，但存在很大风险，绝对不推荐在生产代码中使用：

可行的前提条件： #

• Button和Edit必须是标准布局类型：它们没有虚函数、没有基类、所有非静态成员的访问控制一致（这里都是private），所以第一个成员TypeWindow的起始地址和对象的起始地址完全相同。
• hWindow确实是指向Button或Edit对象的指针转换而来的，不能是其他类型的对象。
• 编译器没有启用破坏标准布局的特殊优化（绝大多数主流编译器默认不会这么做）。
• BYTE是unsigned char或char的typedef：根据C++的严格别名规则，char/unsigned char类型的指针可以用来访问任何对象的字节，所以这种类型转换不会触发未定义行为。

为什么不推荐？ #

这种方式是一种底层“hack”，严重依赖于类的内存布局，一旦类的定义发生变化（比如添加了虚函数、基类，或者调整了成员顺序），代码会立刻出现未定义行为（崩溃、逻辑错误等），而且很难排查。

更符合C++设计理念的做法是使用多态：定义一个基类，包含虚函数来返回类型标识，或者直接使用dynamic_cast（如果有虚函数的话）：

class Window {
public:
    virtual ~Window() = default;
    virtual int getType() const = 0;
};

class Button : public Window {
public:
    int getType() const override { return WND_BUTTON; }
};

class Edit : public Window {
public:
    int getType() const override { return WND_EDIT; }
};

// 使用时：
Window* hWindow = Create(...);
if (hWindow->getType() == WND_BUTTON) {
    std::cout << "This is a button." << std::endl;
}

这种方式更安全、更易维护，也符合面向对象的设计原则。

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