__attribute__: GNU C 的一大特色就是__attribute__ 机制

__attribute__: GNU C 的一大特色就是__attribute__ 机制。__attribute__ 可以设置函数属性（Function）,变量属性（Variable）和类型属性（Type）。

__attribute__ 书写特征是：

---- __attribute__ 前后都有两个下划线，并切后面会紧跟一对原括弧，括弧里面是相应的__attribute__ 参数。

__attribute__ 语法格式为：__attribute__ ((attribute-list))

__attribute__关键字主要是用来在函数或数据声明中设置其属性。给函数设置属性的主要目的在于让编译器进行优化。GCC为函数提供了几种类型的属性，其中包含：

1）构造函数(constructors)和析构函数(destructors)。

__attribute__((constructor)): 需要在main函数之前调用的函数，可以设置constructor属性，实现初始化。

2）packed属性：使用该属性可以使得变量或者结构体成员使用最小的对齐方式。

__attribute__((packed))的作用就是告诉编译器取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐，是GCC特有的语法。这个功能和OS没有关系，和编译器有关，gcc的编译器不是紧凑模式的，在windows下，vc的编译器也不是紧凑的，tc的编译器是紧凑的。例如：

在GCC下： 

struct data{
	char ch; 
	int num;
};

sizeof(int) = 4; sizeof(data) = 8; (非紧凑模式)

struct data{
	char ch; 
	int num;
}__attribute__((packed));

sizeof(int) = 4; sizeof(data) = 5;

程序员应当使用类似下面的方式来指定这些属性：

__attribute__((constructor)) static void beforeFunction()
{
    printf("beforeFunctionn");
}

查阅GNU的文档:

constructor ()destructor ()

--- The constructor attribute causes the function to be called automatically before execution enters main().

--- Similarly, the destructor attribute causes the function to be called automatically after main() completes or exit() is called.

--- Functions with these attributes are useful for initializing data that is used implicitly during the execution of the program.You can set an optional integer priority to control the order in which constructor and destructor funcs are run.  A constructorwith a smaller priority number runs before a constructor with a larger priority number;the opposite relationship holds for destructors. 构造函数优先级数字越小，越先执行。析构函数相反。

So, if you have a constructor that allocates a resource and a destructor that deallocates the same resource, both functions typically have the same priority.  

The priorities for constructor and destructor functions are the same as those specified for namespace-scope

C++ objects (see C++ Attributes).These attributes are not currently implemented for Objective-C. 

/* max length */
#define MAX_LEN 16
/*server max number */
#define MAX_SNUM 10
/*port max number*/
#define MAX_PNUM 10
enum server_state{idle = 0,in_use};

//server information
typedef struct server_info{
    char host_name[MAX_LEN];
	int port_id[MAX_PNUM];
	enum server_state st[MAX_PNUM];
	char used_by[MAX_PNUM][MAX_LEN];
	char ip_address[MAX_PNUM][MAX_LEN];
} S_Info;

char pre_host_name[MAX_SNUM][MAX_LEN] = {
                    "eslruntime01",
                    "eslruntime02",
                    "eslruntime03",
                    "eslruntime04",
                    "eslruntime05",
                    "eslruntime06",
                    "eslruntime07",
                    "eslruntime08",
                    "eslruntime09",
                    "eslruntime10"
};

int port_inf[MAX_PNUM] = {10000,10001,10002,10003,10004,10005,10006,10007,10008,10009};
enum server_state sst[MAX_PNUM] = {idle};
//create server table
static S_Info * init_server_info()
{
    S_Info * server_t = (S_Info *)malloc(sizeof(S_Info) * MAX_SNUM);
    int i,j,k;
    for (i = 0;i < MAX_SNUM;++i)
	{ 
	    for(j = 0;j < MAX_PNUM;++j)
		{
            server_t[i].port_id[j] = port_inf[j];
            server_t[i].st[j] = sst[j];
			memset(server_t[i].used_by[j],0,MAX_LEN);
			memset(server_t[i].ip_address[j],0,MAX_LEN);
		}
	    for(k = 0;k < MAX_LEN;++k)
		{
	        server_t[i].host_name[k] = pre_host_name[i][k];		    
	    }			
	}
    return server_t;
}

//global variable
S_Info * server_total;
static void create_total_server() __attribute__((constructor));
static void free_total_server() __attribute__((destructor));

static void create_total_server()
{
	server_total = init_server_info();
}

static void free_total_server()
{
	free(server_total);
	server_total = NULL;
}

可以给属性设置优先级:

static  __attribute__((constructor(101))) void before1()
{

    printf("before1n");
}
static  __attribute__((constructor(102))) void before2()
{

    printf("before2n");
}
static  __attribute__((constructor(103))) void before3()
{

    printf("before3n");
}

以上三个函数会依照优先级的顺序调用.括号内的数值（101，102，103）代表优先级，另外,我以前看过,这个1-100的范围是保留的.

所以,最好从100之后开始用.(但是实际上,我在项目中测试100以内的,也没有得到警告)

main函数之前的，即constructor的优先级，数值越小，越先调用。destructor中的数值越大，越先调用。

关于格式 -- 按照文档中的说法,__attribute__应该放在函数声明的尾部;之前.

__attribute__((constructor)) // 在main函数被调用之前调用
__attribute__((destructor)) // 在main函数被调用之后调
#include__attribute__((constructor)) void before_main() { 
   printf("before mainn"); 
} 

__attribute__((destructor)) void after_main() { 
   printf("after mainn"); 
} 

int main(int argc, char **argv) { 
   printf("in mainn"); 
   return 0; 
}
//这个例子的输出结果将会是：
before main
in main
after main