得到一个field在结构体（struct type）中的偏移量

宏定义：得到一个field在结构体（struct type）中的偏移量

#define OFFSETOF(type, field) ((size_t)&(((type *)0)->field))

(type *)0：把0地址当成type类型的指针。

((type *)0)->field：对应域的变量。

&((type *)0)->field:取该变量的地址，其实就等于该域相对于0地址的偏移量。

(size_t)&(((type *)0)->field)：将该地址（偏移量）转化为size_t型数据。

下面写了一个简单的测试程序如下：

/*************************************************
/* filename:filedOffsetTest.cpp
/* Author:dongmeiZhao
/* Date:2011-02-15
/* Descript:it justly test the Macro definition about
/* getting the filed of struct.
***************************************************/

#include <iostream>

#define OFFSETOF(type,filed) ((size_t)&(((type*)0)->filed))

typedef struct student
{
    int a; /*占4个字节*/
    char b;/*占1个字节*/
    short c;/*占2个字节*/
}aa;

int main(void)
{
    size_t a_offset = OFFSETOF(aa,a);/*a_offset = 0x00000000*/

    size_t b_offset = OFFSETOF(aa,b);/*b_offset = 0x00000004*/

    size_t c_offset = OFFSETOF(aa,c);/*c_offset = 0x00000006:请参考字节对齐*/

    return 0;
}

ANSI C标准允许任何值为0的常量被强制转换成任何一种类型的指针，并且转换结果是一个NULL指针，因此((s*)0)的结果就是一个类型为s*的NULL指针。如果利用这个NULL指针来访问s的成员当然是非法的，但&(((s*)0)->m)的意图并非想存取s字段内容，而仅仅是计算当结构体实例的首址为((s*)0)时m字段的地址。聪明的编译器根本就不生成访问m的代码，而仅仅是根据s的内存布局和结构体实例首址在编译期计算这个(常量)地址，这样就完全避免了通过NULL指针访问内存的问题。

注：

1. 有人这样表达：

#define OFFSETOF(type, field) ((size_t) \
    ((char *)&((type *)0)->field - (char *)(type *)0))

经验证效果是一样的，多增加的那部分就是0地址，相减后就是偏移量。

2.为什么要增加size_t呢？

首先size_t的定义是什么呢，在文件stddef.h中可以找到答案。

typedef unsigned int size_t; /*mine is 32bit machine*/

可见就是将偏移量转化为无符整型，其实32位机器的地址就是无符号的32位整数。一般情况下，不进行size_t类型转化也是没有问题的（后面的实验可证）。我认为，只有偏移量足够大，当大于0x80000000时才有影响，因为这时候的偏移量最高位是1，机器默认为是负数了。似乎上面宏定义OFFSETOF中更能说明这个问题，因为这个宏定义是一个差值，最高位是1就肯定是负数了。使用printf("%d", &var);打印一个变量的地址就是个负数。这只是我的看法，网上基本没有什么人分析为什么添加size_t的强制类型转化。因为系统对数组长度的大小是有限制的，所以也不能实验得到数据。

插一句数组长度的问题（引述）：（这部分还未搞懂，属于Unix部分）

具体解释可以参考文章：进程资源和系统限制

理论上来说没有限制，但是内核一般配置允许每个进程拥有有限的内存空间，可以用系统调用函数getrlimit(int resource, struct rlimit *rlim)

获得系统的资源限制。系统的资源限制分为软件限制和硬件限制，软件限制最大值不能超过硬件限制。数组静态获得的存储空间是分配在stack，只要知道stack的限制就知道答案了。可以使用如下代码获得：

struct rlimit resource_limit;

getrlimit(RLIMIT_STACK, &resource_limit);

printf("STACK: soft_limit - %ld hard_limit - %ld\n", resource_limit.rlim_cur, resource_limit.rlim_max);

分配大数量的数组，若是系统找不到该大小的一段连续的存储空间，系统就会产生一个SIGSEGV信号，这时调用函数int sigaltstack(const stack_t *ss, stack_t *oss)来处理这个信号。sigaltstack储存信号SIGSEGV到一个alternate stack结构ss中，内核会先于进程运行前检查这个信号。

3.由此，得到一个结构体中field所占用的字节数就很简单了。

#define FIELD_SIZE(type, field) sizeof(((type *)0)->field)

下面是一个简单的测试程序：

/*************************************************
/* filename:filedOffsetTest.cpp
/* Author:dongmeiZhao
/* Date:2011-02-15
/* Descript:it justly test the Macro definition about
/* getting the filed of struct.
***************************************************/

#include <iostream>
#include <windows.h>

/*第一种定义：#define OFFSETOF(type,filed) ((size_t)&(((type*)0)->filed))*/

/*第二种定义：获取filed偏移地址*/
#define OFFSETOF(type, field) ((size_t) \
    ((char *)&((type *)0)->field - (char *)(type *)0))

/*得到一个结构体中field所占用的字节数*/
#define FIELD_SIZE(type, field) sizeof(((type *)0)->field)


typedef struct student
{
    int a; /*占4个字节*/
    char b;/*占1个字节*/
    short c;/*占2个字节*/
}aa;

int main(void)
{
    size_t a_offset = OFFSETOF(aa,a);/*a_offset = 0x00000000*/
    size_t a_size = FIELD_SIZE(aa,a);/*a_size = 0x00000004*/

    size_t b_offset = OFFSETOF(aa,b);/*b_offset = 0x00000004*/
    size_t b_size = FIELD_SIZE(aa,b);/*b_size = 0x00000001*/


    size_t c_offset = OFFSETOF(aa,c);/*c_offset = 0x00000006:请参考字节对齐*/
    size_t c_size = FIELD_SIZE(aa,c);/*c_size = 0x00000002*/

    return 0;
}

4.其实，系统给提供了一个相同的宏定义，在文件stddef.h中：

在嵌入式系统里，不同开发商，不同架构处理器和编译器都有不同的offsetof定义形式:

/* Keil 8051 */

#define offsetof(s,m) (size_t)&(((s *)0)->m)

/* Microsoft x86 */

#define offsetof(s,m) (size_t)(unsigned long)&(((s *)0)->m)

/* Motorola coldfire */

#define offsetof(s,memb) ((size_t)((char *)&((s *)0)->memb-(char *)0))

/* GNU GCC 4.0.2 */

#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER)

/*VC6.0*/

Retrieves the offset of a member from the beginning of its parent structure.

size_t offsetof( structName, memberName );

Routine             Required Header                  Compatibility
offsetof            <stddef.h>                       ANSI, Win 95, Win NT

虽然定义形式不同，但功能都是返回成员在数据结构中的偏移量，都是为了提高代码的可移植性。

5.offsetof虽然同样适用于union结构，但它不能用于计算位域(bitfield)成员在数据结构中的偏移量。

typedef struct

{

  unsigned int a:3;

  unsigned int b:13;

  unsigned int c:16;

}foo;

使用offset(foo,a)计算a在foo中的偏移量，编译器会报错：error C2104: '&' on bit field ignored

6.应用（引述）

offsetof与EEPROM

 我们许多人可能都使用过一些非挥发性的存储器,如常见的EEPROM。我们经常使用它们在存储一些系统的配置参数和设备信息。在所有的EEPROM中，通串过口访问的占了大多数。一般来说，对串口的访问都是按字节进行的，这使得我们不可避免会设计出下面的接口去访问EEPROM的信息:

/*从EEPROM 偏移量offset处读取nBytes到RAM地址dest*/

ee_rd(uint16_t offset, uint16_t nBytes, uint8_t * dest);

然而，这种接口必须要知道偏移量offset和读取字节数nBytes。可能你会采用下面的方法解决方法解决这个问题：

定义一个数据结构和一个指向这个数据结构的指针，并初始化这个指针为EEPROM的起始地址EEPROM_BASE.

#define EEPROM_BASE 0x0000000/*配置信息的起始地址*/

typedef struct

{
   int i;
   float f;
   char c;
} EEPROM;

EEPROM * const pEE = EEPROM_BASE

ee_rd(&(pEE->f), sizeof(pEE->f), dest);

没错，这种方法的确可以达到访问指定地址的信息。不过这种方法也存在下面的问题:

a.容易使代码维护人员人误以为在ee_rd接口内部也存在EEPROM的数据结构。

b.当你编写一些自己感觉良好编译器不报错的代码，比如pEE->f = 3.2，你可能意想不到灾难将要来临。

c.这个接口没有很好地体现EEPROM所隐含的硬件特性。

到这里，有人可能会想到offsetof来解决这个问题：

#define offsetof(type, f) ((size_t) \

    ((char *)&((type *)0)->f - (char *)(type *)0))

typedef struct

{
     int i;
     float f;
     char c;
} EEPROM;

ee_rd(offsetof(EEPROM,f), 4, dest);

如果让编译器来计算nBytes而不是我们自己给出那就更好了。这时，一定有人会马上提到sizeof。可是怎么使用呢，我们不能用sizeof(EEPROM.f)来计算nBytes吧？！因为EEPROM是数据类型，不是对象,没有办法操作f域呀。

/*类似于offsetof的定义*/

#define SIZEOF(s,m) ((size_t) sizeof(((s *)0)->m))

ee_rd(offsetof(EEPROM, f), SIZEOF(EEPROM, f), &dest);

其实还可以精简为下面的最终形式:

#define EE_RD(M,D) ee_rd(offsetof(EEPROM,M), SIZEOF(EEPROM,M), D)

EE_RD(f, &dest);

哈哈，这样我们只用传递两个参数，不用再考虑应该从那里读取数据以及读取多少的问题。

有人会说这种简化都是建立在EEPROM_BASE为0x0000000基础之上的，可能会反问，如果配置信息不是从0地址开始的呢？

其实我们可以通过下面的方法解决。

#define EEPROM_BASE 0x00000a10

typedef struct

{
     char pad[EEPROM_BASE];/*使数据结构的前EEPROM_BASE个字节填"空"*/
     int i;
     float f;
     char c;
} EEPROM;

使用offsetof简化EEPROM的串口访问的确很妙。这里还有一个很好的例子。在嵌入式应用中，我们时常将一些I/O寄存器映射到内存地址空间进行访问。这种映射使原本复杂的寄存器访问变得象访问普通的RAM地址一样方便。PowerPC 8250访问外部的ROM控制器(ROM controller)的寄存器就是通过这种方式实现的。ROM控制器所有的寄存器被映射到从I/O寄存器空间基地址0x10000000(IO_BASE)偏移0x60000(ROMCONOffset)字节的一段内存。每个寄存器占用四个字节，并有一个数据结构与它们对应。比如控制ROM控制器工作状态的寄存器对应数据结构ROMCON_ROM_CONTROL，配置PCI总线A的寄存器对应数据结构ROMCON_CONFIG_A,下面先看看这些数据结构的定义:

#define IO_BASE 0x10000000

#define ROMCONOffset 0x60000

typedef unsigned int NW_UINT32;

typedef struct _ROMCON_CONFIG_A {

    union {

        struct {

            UINT32 pad4:21; /* unused */

            UINT32 pad3:2; /* reserved */

            UINT32 pad2:5; /* unused */

            UINT32 EnablePCIA:1;

            UINT32 pad1:1; /* reserved */

            UINT32 EnableBoot:1;

            UINT32 EnableCpu:1; /*bit to enable cpu*/

        } nlstruct;

        struct {

            UINT32 ConfigA;

        } nlstruct4;

    } nlunion;

} ROMCON_CONFIG_A, *PROMCON_CONFIG_A;

typedef struct _ROMCON_ROM_CONTROL {

    union {

        struct {

            UINT32 TransferComplete:1;

            UINT32 pad3:1; /* unused */

            UINT32 BondPad3To2:2;

            UINT32 Advance:3;

            UINT32 VersaPortDisable:1;

            UINT32 pad2:1; /* unused */

            UINT32 FastClks:1;

            UINT32 pad1:7; /* unused */

            UINT32 CsToFinClks:2;

            UINT32 OeToCsClks:2;

            UINT32 DataToOeClks:2;

            UINT32 OeToDataClks:3;

            UINT32 CsToOeClks:2;

            UINT32 AddrToCsClks:2;

            UINT32 AleWidth:2;

        } nlstruct;

        struct {

            UINT32 RomControl;

        } nlstruct4;

    } nlunion;

} ROMCON_ROM_CONTROL, *PROMCON_ROM_CONTROL;

typedef struct

{

    ROMCON_CONFIG_A ConfigA;

    ROMCON_CONFIG_B ConfigB;

    ROMCON_ROM_CONTROL RomControl;

    ...

}ROMCON, *PROMCON;

---------------------------- <-IO_BASE:0x10000000

| | | | | | |...

----------------------------

| | | | | | |...

...

---------------------------- <-ROMCONOffset(ROMCON):0x60000

| | | | | | |...

---------------------------- <-ROMCON_ROM_CONTROL

...

----------------------------

 

那么如何访问ROMCON_ROM_CONTROL对应寄存器呢，比如ROMCON_ROM_CONTROL对应寄存器的VersaPortDisable位？

估计有人可能会这样做：

事先定义成员RomControl(ROMCON中用ROMCON_ROM_CONTROL定义的实例)相对于ROMCON的偏移量，

#define ROMCONRomControlOffset 0x8

然后设计访问ROM的接口如下：

/*读取ROM控制器位于src位置的寄存器数据到dest*/

typedef unsigned long dword_t;

void rom_read(dword_t* src, uint32_t* dest);

void rom_write(dword_t* src, uint32_t* dest);

最后利用这个偏移量做下面的操作：

ROMCON_ROM_CONTROL tRomCtrl={0};

dword_t* pReg=(dword_t*)(IO_BASE+ROMCONOffset+ROMCONRomControlOffset);

rom_read(pReg,(uint32_t)*(&tRomCtrl));

/*查看寄存器的VersaPortDisable位，如果该位没有启用就启用它*/

if(!tRomCtrl.nlunion.nlstruct.VersaPortDisable)

{

  tRomCtrl.nlunion.nlstruct.VersaPortDisable = 1;

  rom_write(pReg,(uint32_t)*(&tRomCtrl));

}

这样做确实可以达到访问相应寄存器的目的。但是，如果和ROM相关的寄存器很多，那么定义、记忆和管理那么多偏移量不是很不方便吗？到这里，如果你对前面关于offsetof还有印象的话，我想你可能会作下面的优化：

#define ROMCON_ADDR(m) (((size_t)IO_BASE+\

                         (size_t)ROMCONOffset+\

                         (size_t)offsetof(ROMCON,m))

ROMCON_ROM_CONTROL tRomCtrl={0};

dword_t* pReg=(dword_t*)ROMCON_ADDR(ConfigA);

rom_read(pReg,(uint32_t)*(&tRomCtrl));

/*查看寄存器的VersaPortDisable位，如果没有启动就启动它*/

if(!tRomCtrl.nlunion.nlstruct.VersaPortDisable)

{

  tRomCtrl.nlunion.nlstruct.VersaPortDisable = 1;

  rom_write(pReg,(uint32_t)*(&tRomCtrl));

}

7.实验

 

#include "stdio.h"

#define OFFSET(s, m) ((size_t)&(((s *)0)->m))

#define OFFset(s, m) (&(((s *)0)->m))

typedef unsigned int size;

typedef struct node

{

    int aa;

    unsigned char bb;

    unsigned int cc[5];

    unsigned char dd[8];

    unsigned long ee;

    int ff;

    char gg;

    int hh;

}nn;

typedef struct node2

{

    char aa;

    unsigned char bb;

    unsigned char cc[8];

    int dd;

    int ee;

    int ff;

    unsigned int gg[5];

    unsigned long hh;

}mm;

int main(int argc, char * argv[])

{

    printf("OFFSET of aa=%d\n", OFFSET(nn, aa));

    printf("OFFSET of bb=%d\n", OFFSET(nn, bb));

    printf("OFFSET of cc=%d\n", OFFSET(nn, cc));

    printf("OFFset=%d\n", OFFset(nn, cc));

    printf("OFFSET of dd=%d\n", OFFSET(nn, dd));

    printf("OFFSET of ee=%d\n", OFFSET(nn, ee));

    printf("OFFSET of ff=%d\n", OFFSET(nn, ff));

    printf("OFFSET of gg=%d\n", OFFSET(nn, gg));

    printf("OFFSET of hh=%d\n\n", OFFSET(nn, hh));



    printf("OFFSET of aa=%d\n", OFFSET(mm, aa));

    printf("OFFSET of bb=%d\n", OFFSET(mm, bb));

    printf("OFFSET of cc=%d\n", OFFSET(mm, cc));

    printf("OFFset=%d\n", OFFset(mm, cc));

    printf("OFFSET of dd=%d\n", OFFSET(mm, dd));

    printf("OFFSET of ee=%d\n", OFFSET(mm, ee));

    printf("OFFSET of ff=%d\n", OFFSET(mm, ff));

    printf("OFFSET of gg=%d\n", OFFSET(mm, gg));

    printf("OFFSET of hh=%d\n\n", OFFSET(mm, hh));

    return 0;

}

通过VC6.0编译、运行后，答案简略为：

0 4 8（8） 28 36 40 44 48

0 1 2（2） 12 16 20 24 44

结论：

1.在32位机器中，long（long int）型数据占32bit，和short一样。long long是为了支持64位数据而产生的，表示64bit的数据。在64位机器中，long型数据占64bit，short占32bit。

2. 编译器要求对齐，造成了结构体“空洞”。所以相同类型的数据还是靠近吧。空洞问题也可以解释为什么结构体不支持比较（支持==），“空洞”中的随机数据会导致失败。

附（摘录）：

1. 字节对齐（byte alignment）：

现代计算机中内存空间都是按照byte划分的，从理论上讲对于任何类型的变量的访问都可以从任何地址开始。但是实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的牌坊，这就是对齐。

2. 对齐原因：

(1)有些CPU访问没有对齐的变量时候会发生错误。比如Motorola 68000不允许将16位的字存储到奇数地址中， 将一个16位的字写到奇数地址将引发异常。

(2)不对数据进行对齐，会在存取效率上带来损失。比如：有些CPU从偶数地址存储int数据，读取时需要一个机器周期，从偶数地址存储，就需要2个机器周期。

3.对齐规则：

实际上， 对于c中的字节组织， 有这样的对齐规则:   

(1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；

(2) 结构体每个成员相对于结构首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；

(3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

不同CPU的对其规则可能不同， 请参考手册。为什么会有上述的限制呢? 理解了内存组织， 就会清楚了。

CPU通过地址总线来存取内存中的数据，32位的CPU的地址总线宽度既为32位置， 标为A[0:31]。在一个总线周期内，CPU从内存读/写32位。 但是CPU只能在能够被4整除的地址进行内存访问，这是因为: 32位CPU不使用地址总线的A1和A2(比如ARM，它的A[0:1]用于字节选择， 用于逻辑控制， 而不和存储器相连，存储器连接到A[2:31])。访问内存的最小单位是字节(byte)， A0和A1不使用， 那么对于地址来说， 最低两位是无效的，所以它只能识别能被4整除的地址了。 在4字节中，通过A0和A1确定某一个字节。

4. 字节对齐对程序的影响：

（32bit、x86、gcc）（所占字节数char:1, short:2, int:4, long:4, float:4, double:8）

struct A

{
    int a;
    char b;
    short c;
};

struct B
{
    char b;
    int a;
    short c;
};

sizeof(strcut A) == 8
sizeof(struct B) == 12

5.修改默认对齐：

(1)编程时，使用#pragma pack()。

#pragma pack (2) /*指定按2字节对齐*/

struct C

{
    char b;
    int a;
    short c;
};

#pragma pack () /*取消指定对齐，恢复缺省对齐*/

sizeof(strcut C) == 8 == 2(b) + 4(a) + 2(c)

(2)修改编译器的默认对齐方式。

6.编程注意情况：

(1)为了字节对齐，显示声明冗余变量。当然，不冗余声明，编译器也会自动对齐。

struct A

{
    char a;
    char reserved[3]; /*使用空间换时间*/
    int b;
};

(2)带来隐患，尤其是对代码移植的影响。

unsigned int i = 0x12345678;

unsigned char *p=NULL;

unsigned short *p1=NULL;

p=&i;

*p=0x00;

p1=(unsigned short *)(p+1);

*p1=0x0000;

最后两句代码，从奇数边界去访问unsigned short型变量，显然不符合对齐的规定。

在x86上，类似的操作只会影响效率，但是在MIPS或者sparc上，可能就是一个error,因为它们要求必须字节对齐。