EEPW论坛

一、__attribute__关键字

__attribute__主要是用来在函数或数据声明中设置其属性。给函数赋给属性的主要目的在于让编译器进行优化。__attribute__机制是GNU C的一大特色，__attribute__可以设置函数属性（FunctionAttribute）、变量属性（Variable Attribute）和类型属性（Type Attribute）。其书写特征是：__attribute__前后都有两个下划线，并且后面会紧跟一对括弧，括弧里面是相应的__attribute__参数。

__attribute__语法格式为：­

__attribute__ ((attribute-list))

其位置约束：放于声明的尾部“；”之前。

 GNU CC需要使用 –Wall编译器来击活该功能，这是控制警告信息的一个很好的方式。

1、函数属性（Function Attribute）：

函数属性可以帮助开发者把一些特性添加到函数声明中，从而可以使编译器在错误检查方面的功能更强大。__attribute__机制也很容易同非GNU应用程序做到兼容之功效。

2、变量属性（Variable Attributes）：

关键字__attribute__也可以对变量（variable）或结构体成员（structure field）进行属性设置。在使用__attribute__参数时，你也可以在参数的前后都加上“__”（两个下划线），例如，使用__aligned__而不是aligned，这样，你就可以在相应的头文件里使用它而不用关心头文件里是否有重名的宏定义。

  3、类型属性（Type Attribute）：

关键字__attribute__也可以对结构体（struct）或共用体（union）进行属性设置。大致有六个参数值可以被设定：aligned，packed，transparent_union，unused，deprecated，may_alias

 有关这些属性更详细的介绍见：http://gcc.gnu.org/

下面是一些便捷的连接：

GCC 4.0 Function Attributes 

GCC 4.0 Variable Attributes 

GCC 4.0 Type Attributes 

二、__attribute__属性常用参数介绍

1、packed

 __attribute__((packed)) 的作用就是告诉编译器取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐，是GCC特有的语法。使用该属性可以使得变量或者结构体成员使用最小的对齐方式，即对变量是一字节对齐，对域（field）是位对齐。这个功能是跟操作系统没关系，跟编译器有关，GCC编译器不是紧凑模式的，我在windows下，用VC的编译器也不是紧凑的，用TC的编译器就是紧凑的。例如：

在TC下：

struct my{ char ch; int a;}

sizeof(int)=2;sizeof(my)=3;（紧凑模式）。

在GCC下：

struct my{ char ch; int a;}

sizeof(int)=4;sizeof(my)=8;（非紧凑模式）。

在GCC下：

struct my{ char ch; int a;}__attrubte__((packed)) 

sizeof(int)=4;sizeof(my)=5;  (取消优化对齐)

packed是类型属性（Type Attribute）的一个参数，使用packed可以减小对象占用的空间。需要注意的是，attribute属性的效力与你的连接器也有关，如果你的连接器最大只支持16字节对齐，那么你此时定义32字节对齐也是无济于事的。

使用该属性对struct或者union类型进行定义，设定其类型的每一个变量的内存约束。当用在enum类型定义时，暗示了应该使用最小完整的类型（it indicates that the smallest integral type should beused）。

下面的例子中，my-packed-struct类型的变量数组中的值会紧凑在一起，但内部的成员变量s不会被“pack”，如果希望内部的成员变量也被packed的话，my-unpacked-struct也需要使用packed进行相应的约束。

struct my_unpacked_struct
{
      char c;
      int i;
};
         
struct my_packed_struct
{
      char c;
      int i;
      struct my_unpacked_struct s;
}__attribute__ ((__packed__));

一个__attribute__ ((packed))的简单示例： 

#define __u8    unsigned char
#define __u16   unsigned short


struct str_struct

{
         __u8    a;
          __u8    b;
         __u8    c;
         __u16   d;
} __attribute__ ((packed));


typedef struct 

{
         __u8    a;
         __u8    b;
         __u8    c;
         __u16   d;
} __attribute__ ((packed)) str;

typedef struct 

{
         __u8    a;
         __u8    b;
         __u8    c;
         __u16   d;
}str_temp __attribute__ ((packed));

typedef struct 

{
        __u8    a;
         __u8    b;
         __u8    c;
         __u16   d;
}str_nopacked;

int main(void)
{
         printf("sizeofstr_struct   = %d/n", sizeof(struct str_struct));
          printf("sizeofstr          = %d/n",sizeof(str));
         printf("sizeofstr_temp      = %d/n", sizeof(str_temp));
         printf("sizeofstr_nopacked = %d/n", sizeof(str_nopacked));
         return 0;
}

编译运行结果如下:
sizeof str_struct   = 5 
sizeof str          = 5
sizeof str_temp      = 6
sizeof str_nopacked = 6

 2、 aligned(alignment)

该属性设定一个指定大小的对齐格式（以字节为单位），例如：

struct S { short f[3]; } __attribute__ ( ( aligned (8)) );

typedef  int  more_aligned_int __attribute__( ( aligned (8) ) );

这里，如果sizeof（short）的大小为2（byte），那么，S的大小就为6。取一个2的次方值，使得该值大于等于6，则该值为8，所以编译器将设置S类型的对齐方式为8字节。该声明将强制编译器确保（尽它所能）变量类型为struct S或者more-aligned-int的变量在分配空间时采用8字节对齐方式。

如上所述，你可以手动指定对齐的格式，同样，你也可以使用默认的对齐方式。例如：

struct S { short f[3]; } __attribute__ ( (aligned) );

上面，aligned后面不紧跟一个指定的数字值，编译器将依据你的目标机器情况使用最大最有益的对齐方式。

int  x __attribute__ ( (aligned (16) ) )  = 0;

编译器将以16字节（注意是字节byte不是位bit）对齐的方式分配一个变量。也可以对结构体成员变量设置该属性，例如，创建一个双字对齐的int对，可以这么写：

Struct  foo {  int  x[2] __attribute__( (aligned (8) ) );  };

选择针对目标机器最大的对齐方式，可以提高拷贝操作的效率。

aligned属性使被设置的对象占用更多的空间，相反的，使用packed可以减小对象占用的空间。

需要注意的是，attribute属性的效力与你的连接器也有关，如果你的连接器最大只支持16字节对齐，那么你此时定义32字节对齐也是无济于事的。

3、format

该属性可以使编译器检查函数声明和函数实际调用参数之间的格式化字符串是否匹配。它可以给被声明的函数加上类似printf或者scanf的特征，该功能十分有用，尤其是处理一些很难发现的bug。

format的语法格式为：

format ( archtype,  string-index, first-to-check )

format属性告诉编译器，按照printf，scanf，strftime或strfmon的参数表格式规则对该函数的参数进行检查。

archtype：指定是哪种风格；

string-index：指定传入函数的第几个参数是格式化字符串；

first-to-check：指定从函数的第几个参数开始按上述规则进行检查。

具体使用格式如下：

__attribute__( ( format( printf，m，n ) ) )

__attribute__( ( format( scanf，m，n ) ) )

其中参数m与n的含义为：

m：第几个参数为格式化字符串（format string）；

n：参数集合中的第一个，即参数“…”里的第一个参数在函数参数总数排在第几

注意，有时函数参数里还有“隐身”的呢，后面会提到；

在使用上，__attribute__((format(printf,m,n)))是常用的，而另一种却很少见到。

下面举例说明，其中myprint为自己定义的一个带有可变参数的函数，其功能类似于printf：

//m=1；n=2

extern void  myprint( const char *format，… ) __attribute__( ( format( printf，1，2 ) ) );

//m=2；n=3

extern void  myprint( int l，const char *format，... )__attribute__( ( format( printf，2，3 ) ) );

需要特别注意的是，如果myprint是一个函数的成员函数，那么m和n的值可有点“悬乎”了，例如：

//m=3；n=4

extern void  myprint( int l，const char *format，... )__attribute__( ( format( printf，3，4 ) ) );

其原因是，类成员函数的第一个参数实际上一个“隐身”的“this”指针。
这里给出测试用例：attribute.c，代码如下：

extern void myprint(const char *format,...)__attribute__((format(printf,1,2)));

void test()

{

         myprint("i=%d/n",6);

         myprint("i=%s/n",6);

         myprint("i=%s/n","abc");

       myprint("%s,%d,%d/n",1,2);

}

运行$gcc–Wall –c attribute.c attribute后，输出结果为：

attribute.c: In function `test':

attribute.c:7: warning: format argument is not apointer (arg 2)

attribute.c:9: warning: format argument is not apointer (arg 2)

attribute.c:9: warning: too few arguments for format

如果在attribute.c中的函数声明去掉__attribute__((format(printf,1,2)))，再重新编译，

既运行$gcc–Wall –c attribute.c attribute后，则并不会输出任何警告信息。

注意，默认情况下，编译器是能识别类似printf的“标准”库函数。

4、noreturn

该属性通知编译器函数从不返回值。

当遇到函数需要返回值却还没运行到返回值处就已退出来的情况，该属性可以避免出现错误信息。C库函数中的abort（）和exit（）的声明格式就采用了这种格式：

extern void  exit(int)   __attribute__(( noreturn ) );

extern void  abort(void)  __attribute__( (noreturn ) );

为了方便理解，大家可以参考如下的例子：

//name: noreturn.c     ；测试__attribute__((noreturn))

extern void  myexit();

int  test( int  n )

{

    if ( n > 0 )

    {

           myexit();

           /* 程序不可能到达这里 */

    }

    else

    {

           return 0;

    }

}

编译$gcc–Wall –c noreturn.c  显示的输出信息为：

noreturn.c: In function `test':

noreturn.c:12: warning: control reaches end ofnon-void function

警告信息也很好理解，因为你定义了一个有返回值的函数test却有可能没有返回值，程序当然不知道怎么办了！加上__attribute__((noreturn))则可以很好的处理类似这种问题。把extern void myexit();修改为：

extern void  myexit() __attribute__((noreturn));

之后，编译不会再出现警告信息。

5、const

该属性只能用于带有数值类型参数的函数上，当重复调用带有数值参数的函数时，由于返回值是相同的。所以此时编译器可以进行优化处理，除第一次需要运算外， 其它只需要返回第一次的结果。

该属性主要适用于没有静态状态（static state）和副作用的一些函数，并且返回值仅仅依赖输入的参数。为了说明问题，下面举个非常“糟糕”的例子，该例子将重复调用一个带有相同参数值的函数，具体如下：

extern int  square( int  n ) __attribute__ ((const) );

for (i = 0; i < 100; i++)                 

{      

       total += square(5) +i;            

}

添加__attribute__((const))声明，编译器只调用了函数一次，以后只是直接得到了相同的一个返回值。

事实上，const参数不能用在带有指针类型参数的函数中，因为该属性不但影响函数的参数值，同样也影响到了参数指向的数据，它可能会对代码本身产生严重甚至是不可恢复的严重后果。并且，带有该属性的函数不能有任何副作用或者是静态的状态，类似getchar（）或time（）的函数是不适合使用该属性。

6、finstrument-functions

该参数可以使程序在编译时，在函数的入口和出口处生成instrumentation调用。恰好在函数入口之后并恰好在函数出口之前，将使用当前函数的地址和调用地址来调用下面的profiling函数。（在一些平台上，__builtin_return_address不能在超过当前函数范围之外正常工作，所以调用地址信息可能对profiling函数是无效的）

void  __cyg_profile_func_enter( void *this_fn，void  *call_site );

void  __cyg_profile_func_exit( void *this_fn，void  *call_site );

其中，第一个参数this_fn是当前函数的起始地址，可在符号表中找到；第二个参数call_site是调用处地址。

三、同时使用多个属性

可以在同一个函数声明里使用多个__attribute__，并且实际应用中这种情况是十分常见的。使用方式上，你可以选择两个单独的__attribute__，或者把它们写在一起，可以参考下面的例子：

extern void  die(const char *format， ...)   __attribute__((noreturn))   \

__attribute__((format(printf, 1, 2)) );

或者写成

extern void  die(const char *format，...)    \

__attribute__( (noreturn,  format(printf, 1, 2)));

如果带有该属性的自定义函数追加到库的头文件里，那么所以调用该函数的程序都要做相应的检查。

四、和非GNU编译器的兼容性

__attribute__设计的非常巧妙，很容易作到和其它编译器保持兼容。也就是说，如果工作在其它的非GNU编译器上，可以很容易的忽略该属性。即使__attribute__使用了多个参数，也可以很容易的使用一对圆括弧进行处理，例如：

  /* 如果使用的是非GNUC, 那么就忽略__attribute__ */

#ifndef __GNUC__

      #define     __attribute__(x)     /*NOTHING * /

#endif

需要说明的是，__attribute__适用于函数的声明而不是函数的定义。所以，当需要使用该属性的函数时，必须在同一个文件里进行声明，例如：

/* 函数声明 */

void  die( const char *format， ... ) __attribute__( (noreturn) )   \

__attribute__( ( format(printf，1，2) ) );

void  die( const char *format，... )

{   /* 函数定义 */  }