Question

我不理解第300页上的Extreme C这本书的某些主题。它涉及“多重继承”。

typedef struct { ... } a_t;
typedef struct { ... } b_t;

typedef struct {
    a_t a;
    b_t b;
    ...
} c_t;

c_t c_obj;
a_t* a_ptr = (a_ptr*)&c_obj;
b_t* b_ptr = (b_ptr*)&c_obj; //it's the problem
c_t* c_ptr = &c_obj;

为什么我们应该做类似的事情？

c_t c_obj;
a_t* a_ptr = (a_ptr*)&c_obj;
b_t* b_ptr = (b_ptr*)(&c_obj + sizeof(a_t)); //?Is the address a_ptr the same as address c_obj?
c_t* c_ptr = &c_obj;

非常感谢您的帮助。

Answer 1

为什么我们应该做...？

我们不应该这样做！

首先，sizeof a可能无法正确发送地址。如果b_t比a_t具有更大的对齐要求，那么将不会产生正确的偏移量。

第二，表达式是错误的：

(&c_obj + sizeof(a_t))

这将使用类型为c_obj的地址c_t*。然后，它将添加一个sizeof (c_t)的倍数，它再次指向类型为c_t的对象，但其地址是非法的。

第三：您的演员表都错了。您需要使用类型名称，而不是变量。

如果您想获取b的地址，则C lib中有一个可用的offsetof宏：

offsetof(c_t,b)

计算类型b中成员c_t的偏移量（以字节为单位）。然后，您可以将其应用于您的地址：

b_ptr=(b_t*)  ((unsigned char*)&c_obj) + offsetof(c_t,b));

使用字节算术必须先转换为unsigned char。

当然，有一种更简单的方法可以做到这一点：

b_ptr=&c_obj.b;

也许本书的目的是表明您不能仅使用结构的地址并将其强制转换为指向另一个结构的指针，而是必须注意该结构中成员的位置。那是对的。但是肮脏的细节有些偏离。

Answer 2

保持简单：

c_t c_obj;
a_t* a_ptr = &c_obj.a;
b_t* b_ptr = &c_obj.b;
c_t* c_ptr = &c_obj;

问题在于：

b_t* b_ptr = (b_ptr*)&c_obj;//it's the problem

是b_ptr最终指向c_obj.a。

问题：

b_t* b_ptr = (b_ptr*)(&c_obj + sizeof(a_t));//?Is the address a_ptr the same as address c_obj?

是：

您试图将指针调整sizeof(a_t)个字节，但是指针算术是根据指针的取消引用类型的大小来缩放的。在这种情况下，指针类型为c_t*（来自表达式&c_obj），而取消引用的类型为c_t，因此指针实际上是由sizeof(c_t) * sizeof(a_t)个字节调整的。
在c_t的某些成员之后可能会有填充。特别是，在a和b成员之间可能会有填充，因此b成员可能不在您认为的偏移量处。可以使用表达式b确定c_t与offsetof(c_t, b)起始字节之间的偏移量。

Answer 3

结构类型的对象的地址等于该结构类型的第一个成员的地址。

所以用你的例子

typedef struct {
a_t a;
b_t b;
...
} c_t;

c_t c_obj;
a_t* a_ptr = (a_ptr*)&c_obj;

那么确实数据成员a的地址等于对象c_obj的地址。

但是对于数据成员b，此关系已中断，因为数据成员b不是结构c_t的第一个数据成员。

至此声明

b_t* b_ptr = (b_ptr*)(&c_obj + sizeof(a_t));

那么那是完全错误的。对于此子表达式&c_obj + sizeof(a_t)中的启动器，使用了指针算法，并且表达式&c_obj的值增加了值sizeof( c_t ) * sizeof( a_t )。

看来你的意思

b_t* b_ptr = (b_ptr*)(( char * )&c_obj + sizeof(a_t));

但是，在任何情况下，由于可能的对齐方式，通常右侧的表达式都不会产生数据成员b的地址，

请考虑以下演示程序。

#include <stdio.h>

struct A
{
    int x;
};

struct B
{
    double y;
};

struct C
{
    struct A a;
    struct B b;
};

int main(void) 
{
    struct C c = { { 1 }, { 2.2 } };
    
    printf( "&c.a = %p\n( char * )( &c.c ) + sizeof( struct A ) = %p\n&c.b = %p\n",
            ( void * )&c.a, ( void * ) ( ( char * )&c.a + sizeof( struct A ) ), ( void * )&c.b );
    return 0;
}

其输出可能看起来像

&c.a = 0x7ffe5e0697c0
( char * )( &c.c ) + sizeof( struct A ) = 0x7ffe5e0697c4
&c.b = 0x7ffe5e0697c8

如您所见，数据成员a后面附加了字节，以将下一个数据成员b对齐为两倍。

为什么有危险？

3 个答案: