亲宝软件园·资讯

展开

C语言 #pragma

清风自在 流水潺潺 人气:0

一、#pragma 简介

#pragma 用于指示编译器完成一些特定的动作

#pragma 所定义的很多指示字是编译器特有的

#pragma 在不同的编译器间是不可移植的

一般用法:

#pragma parameter

注:不同的 parameter 参数语法和意义各不相同

二、#pragma message

例如:

#if defined(ANDROID20)
    #pragma message("Compile Android SDK 2.0...")
    #define VERSION "Android 2.0 "
#endif

注:#error 和 #warning 不同,#pragma message 仅仅代表一条编译消息,不代表程序错误。

下面看一个 #pragma message 使用示例:

test.c:

#include <stdio.h>
 
#if defined(ANDROID20)
    #pragma message("Compile Android SDK 2.0...")
    #define VERSION "Android 2.0"
#elif defined(ANDROID23)
    #pragma message("Compile Android SDK 2.3...")
    #define VERSION "Android 2.3"
#elif defined(ANDROID40)
    #pragma message("Compile Android SDK 4.0...")
    #define VERSION "Android 4.0"
#else
    #error Compile Version is not provided!
#endif
 
int main()
{
    printf("%s\n", VERSION);
 
    return 0;
}

下面为输出结果:

三、#pragma once

下面两种方式的区别是:前者是被 C 语言所支持的,并不是只包含一次头文件,而是包含多次,然后通过宏控制是否嵌入到源代码中,也就是说通过宏的方式,可以保证头文件里面的内容只被嵌入一次,但是由于包含了多次,预处理器还是处理了多次,所以效率上来说比较低;后者是告诉预处理器当前文件只编译一次,所以说效率较高。

下面看一个 #pragma once 的使用示例:

global.h:

 #pragma once
 
int g_value = 1;

test.c:

#include <stdio.h>
#include "global.h"
#include "global.h"
 
int main()
{
    printf("g_value = %d\n", g_value);
 
    return 0;
}

下面为输出结果,可以看到虽然在test.c 定义了两次global.h,但是程序编译没有报错,且能正常运行,这就是 #pragma once 作用的结果:

工程应用中既想要移植性,又想要保证效率,可以采用以下做法:

global.h:

#ifndef _GLOBAL_H_
#define _GLOBAL_H_
 
#pragma once
 
int g_value = 1;
 
#endif

四、#pragma pack

什么是内存对齐?

下面想想 Test1 和 Test2 所占的内存空间是否相同?

答案是否定的,Test1 占用 12 个字节,而 Test 占用 8 个字节

为什么需要内存对齐?

#pragma pack 用于指定内存对齐方式

#pragma pack 能够改变编译器的默认对齐方式

例如,下面代码中,Test1 和 Test2 的内存均为 8 个字节

struct 占用的内存大小

第一个成员起始于 0 偏移处

每个成员按其类型大小和 pack 参数中较小的一个进行对齐

结构体总长度必须为所有对齐参数的整数倍

编译器在默认情况下按照 4 字节对齐。

下面通过代码,手工计算结构体所占用的内存大小

test.c:

#include <stdio.h>
 
#pragma pack(4)
struct Test1
{                   //对齐参数      偏移地址        大小
    char  c1;       //1            0              1
    short s;        //2            2              2
    char  c2;       //1            4              1
    int   i;        //4            8              4
};
#pragma pack()
 
#pragma pack(4)
struct Test2
{                   //对齐参数      偏移地址        大小
    char  c1;       //1            0              1
    char  c2;       //1            1              1
    short s;        //2            2              2
    int   i;        //4            4              4
};
#pragma pack()
 
int main()
{
    printf("sizeof(Test1) = %d\n", sizeof(struct Test1));
    printf("sizeof(Test2) = %d\n", sizeof(struct Test2));
 
    return 0;
}

以 Test1 为例,c1 类型大小为 1 字节,而 pack 参数默认为 4,所以对齐参数取最小为 1;同理 s 的对齐参数为 2,偏移地址要被 2 整除,所以为 2;同理 c 的对齐参数为 1,偏移地址为 4;同理,i 的对齐参数为 4,因为偏移地址要能被 对齐参数 4 整除,在偏移地址 4 之后能被 4 整除的最小偏移地址为 8,所以 i 的偏移地址为 8,而 i 占用 4 个字节,所以 Test1 结构体占用的总字节数为 12 字节,这就和上面的图对应起来了。

下面再通过一个例子感受一下:

在 gcc 编译器下,test.c:

#include <stdio.h>
 
#pragma pack(8)
 
struct S1
{                   //对齐参数      偏移地址        大小
    short a;        //2            0              2
    long b;         //4            4              4
};
 
struct S2
{                   //对齐参数      偏移地址        大小
    char c;         //1            0              1
    struct S1 d;    //4            4              8
    double e;       //4            12             8
};
 
#pragma pack()
 
int main()
{
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
 
    return 0;
}
 

下面为输出结果:

这里注意两点:

1.结构体成员的大小取其内部长度最大的数据成员作为其大小,所以 S1 的内存大小为 4,而pack 参数默认为 8,所以对齐参数为 4

2.一般的 pack 对齐格式分别是 1,2,4,8,16,默认的对齐格式,也就是:#pragmapack() 的情况下,会在结构体中挑选占用字节最多的类型,例如 double 占用 8 个字节

3.gcc 编译器暂时不支持 8 字节对齐,默认按照 4 字节对齐,所以 S2 中的 e 的对齐参数为 4,故 S2 占用内存大小为 20 字节。(学习采用的为 ubuntu 10.10)

如果把代码放在 VS2012 里运行,那结果就是和分析的一样,S2 占用 24 字节。

#include <stdio.h>
 
#pragma pack(8)
 
struct S1
{                   //对齐参数      偏移地址        大小
    short a;        //2            0              2
    long b;         //4            4              4
};
 
struct S2
{                   //对齐参数      偏移地址        大小
    char c;         //1            0              1
    struct S1 d;    //4            4              8
    double e;       //8            16             8
};
 
#pragma pack()
 
int main()
{
    printf("%d\n", sizeof(struct S1));
    printf("%d\n", sizeof(struct S2));
 
    return 0;
}
 

结果:

五、小结

#pragma 用于指示编译器完成一些特定的动作

#pragma 所定义的很多指示字是编译器特有的

加载全部内容

相关教程
猜你喜欢
用户评论