c - 为什么在 C 中转换后 int 的值会发生变化

Question

我正在尝试转换一个结构来访问它的第一个成员，但是该结构的第一个成员的值正在发生变化/困惑。

代码如下:

typedef struct ObjectBase
{
    int integer1;
    int integer2;
}ObjectBase;

typedef struct ObjectExtended
{
    ObjectBase* baseObj;
    char* string;
}ObjectExtended;

int main(int argc,char** argv)
{
    void* voidObject = malloc(sizeof(ObjectExtended));
    ObjectExtended* objExtended = voidObject;
    objExtended->string = "TEST_OBJECT";

    objExtended->baseObj = malloc(sizeof(ObjectBase));
    objExtended->baseObj->integer1 = 10;
    objExtended->baseObj->integer2 = 11;

    printf("Extended Object:\n");
    printf("\tString: %s\n",objExtended->string);
    printf("\tInt1: %i\n",objExtended->baseObj->integer1);
    printf("\tInt2: %i\n",objExtended->baseObj->integer2);

    ObjectBase* objBase = voidObject;

    printf("Base Object:\n");
    printf("\tInt1: %i\n",objBase->integer1);
    printf("\tInt2: %i\n",objBase->integer2);

    free(objExtended->baseObj);
    free(objExtended);
    return 0;
}

这是输出:

Extended Object:
    String: TEST_OBJECT
    Int1: 10
    Int2: 11
Base Object:
    Int1: 166544
    Int2: 6

它从哪里得到 166544 和 6？

Answer 1

您正在使用“虚拟继承”，因此 ObjectExtended 不包含一个 ObjectBase 作为它的第一个成员，而是一个指向它的指针。当您将 ObjectExtended * 转换为 ObjectBase * 时，您开始将该指针的高位和低位字节解释为 ObjectBase 的整数(假设 sizeof(int *) == 2 * sizeof(int))。

要解决这个问题，要么使用“非虚拟继承”，即声明 ObjectExtended 为

typedef struct ObjectExtended
{
  ObjectBase baseObj;  /* not a pointer */
  char* string;
} ObjectExtended;

无论如何，这可能首先是更好的设计，或者改变你的类型转换逻辑:

#define UPCAST(EXTPTR) ((EXTPTR)->baseObj)

与 C++ 中的 dynamic_cast(您在编写代码时最终想到的)不同，在 C 中转换指针只是指示编译器将指针指向的任何内存位置重新解释为新类型的对象。如果您的 struct 的第一个成员是基础对象，这很好，因为基础对象和扩展对象都从相同的地址开始。但是在您的原始代码中，您需要的不仅仅是重新解释指针的目的地。基本对象的地址不是扩展对象的地址，而是不同的。即，它是存储在baseObj 指针中的那个。您可以看到它们的地址不能与您使用两个不同的 malloc 调用创建的地址相同。

为了让事情更清楚，这里是你的对象的内存布局:

+----------------+<--+  +                         +
| integer1       |   |  | sizeof (int)            | sizeof
+----------------+   |  +                         | (ObjectBase)
| integer2       |   |  | sizeof (int)            |
+----------------+   |  +                         +
                     |
+----------------+   |  +                         +
| baseObj        |---+  | sizeof (ObjectBase *)   | sizeof
|                |      |                         | (ObjectExtended)
+----------------+      +                         |
| string         |---+  | sizeof (char *)         |
|                |   |  |                         |
+----------------+   |  +                         +
                     V
                    somewhere else ...

两个对象之间的差距当然不是按比例的。 malloc 的两次调用可能会以任何顺序返回任何地址。^*

如果 ObjectExtended 被声明为如上(“非虚拟”)，您将获得以下布局:

+----------------+      +                  + +
| integer1       |      | sizeof (int)     | | sizeof
+----------------+      +                  | | (ObjectBase)
| integer2       |      | sizeof (int)     | |
+----------------+      +                  | +
| string         |---+  | sizeof (char *)  | sizeof
|                |   |  |                  | (ObjectExtended)
+----------------+   |  +                  +
                     V
                    somewhere else ...

在这两张图片中，编译器可能已经向对象添加了额外的填充字节，以使它们按照目标体系结构的要求在内存中对齐。

_{^* 这与 C++ 等内置继承支持的语言形成对比，在 C++ 中使用虚拟继承不会导致为子对象分配动态内存。相反，C++ 编译器会计算出两种内存需求的总和，然后要么保留足够的堆栈空间来容纳整个对象，要么在空闲存储上分配所需的内存量(如果对象是使用 operator 创建的)新的)。您可以通过使用 malloc(sizeof(ObjectExtended) + sizeof(ObjectBase)) 在 C 语言中完成相同的操作，然后自己找出内存布局。但是你必须更加小心，不要违反对齐规则。}