C++宏

C++提供的编译预处理功能主要有以下三种：

　　（一） 宏定义

　　（二） 文件包含

　　（三） 条件编译

在C++中，我们一般用const定义符号常量。很显然，用const定义常量比用define定义常量更好。

　　在使用宏定义时应注意的是：

　　（a） 在书写#define 命令时，注意<宏名>和<字符串>之间用空格分开，而不是用等号连接。

　　（b） 使用#define定义的标识符不是变量，它只用作宏替换，因此不占有内存。

　　（c） 习惯上用大写字母表示<宏名>，这只是一种习惯的约定，其目的是为了与变量名区分，因为变量名

                    通常用小写字母。

　　如果某一个标识符被定义为宏名后，在取消该宏定义之前，不允许重新对它进行宏定义。取消宏定义使用如下命令：

　　#undef<标识符>

　　其中，undef是关键字。该命令的功能是取消对<标识符>已有的宏定义。被取消了宏定义的标识符，可以对它重新进行定义。

　　宏定义可以嵌套，已被定义的标识符可以用来定义新的标识符。例如：

　　#define PI 3.14159265

　　#define R 10

　　#define AREA (PI*R*R)

单的宏定义将一个标识符定义为一个字符串，源程序中的该标识符均以指定的字符串来代替。前面已经说过，预处理命令不同于一般C++语句。因此预处理命令后通常不加分号。这并不是说所有的预处理命令后都不能有分号出现。由于宏定义只是用宏名对一个字符串进行简单的替换，因此如果在宏定义命令后加了分号，将会连同分号一起进行置换。

带参数的宏定义

　　带参数的宏定义的一般形式如下：

　　#define <宏名>（<参数表>） <宏体>

　　其中， <宏名>是一个标识符，<参数表>中的参数可以是一个，也可以是多个，视具体情况而定，当有多个参数的时候，每个参数之间用逗号分隔。<宏体>是被替换用的字符串，宏体中的字符串是由参数表中的各个参数组成的表达式。例如：

　　#define SUB(a,b) a-b

如果在程序中出现如下语句：

　　result=SUB(2, 3)

则被替换为：

　　result=2-3；

如果程序中出现如下语句：

　　result= SUB（x+1, y+2）;

则被替换为：

　　result=x+1-y+2;

　　在这样的宏替换过程中，其实只是将参数表中的参数代入到宏体的表达式中去，上述例子中，即是将表达式中的a和b分别用2和3代入。

　　我们可以发现：带参的宏定义与函数类似。如果我们把宏定义时出现的参数视为形参，而在程序中引用宏定义时出现的参数视为实参。那么上例中的a和b就是形参，而2和3以及x+1和y+2都为实参。在宏替换时，就是用实参来替换<宏体>中的形参。

在使用带参数的宏定义时需要注意的是：

　　（1）带参数的宏定义的<宏体>应写在一行上，如果需要写在多行上时，在每行结束时，使用续行符 "/"结

                  束，并在该符号后按下回车键，最后一行除外。

　　（2）在书写带参数的宏定义时，<宏名>与左括号之间不能出现空格，否则空格右边的部分都作为宏体。

                  例如：

　　          #define ADD (x,y) x+y

                  将会把"（x,y）x+y"的一个整体作为被定义的字符串。

　   （3）定义带参数的宏时，宏体中与参数名相同的字符串适当地加上圆括号是十分重要的，这样能够避免可能产生的错误。例如,对于宏定义：

　           　#define SQ(x) x*x

                 当程序中出现下列语句：

　　          m=SQ(a+b);

                 替换结果为：

　　         m=a+b*a+b;

这可能不是我们期望的结果，如果需要下面的替换结果：

　　m=(a+b)*(a+b);

应将宏定义修改为：

　　#define SQ(x) (x)*(x) 

　　对于带参的宏定义展开置换的方法是：在程序中如果有带实参的宏（如"SUB（2,3）"），则按"#define"命令行中指定的字符串从左到右进行置换。如果串中包含宏中的形参（如a、b），则将程序语句中相应的实参（可以是常量、变量或者表达式）代替形参，如果宏定义中的字符串中的字符不是参数字符（如a-b中的-号），则保留。这样就形成了置换的字符串。

C++宏定义中的## 和#

我们用一来实例来学习一下C++宏定义中的## 和#的区别，首先我们来定义一个宏：#define STRCPY(a, b)    strcpy(a ## _p, #b) 

1. 宏定义里面有个##表示把字符串联在一起。如： 

#include <stdio.h>  

#define CAT(x,y) x##y 

int main()  

{  

 printf("%s", CAT("hello", " world"));  

 return 0; 

} 

2.宏定义中的#表示将其变为字符串。如： 

#include <stdio.h> 

#include<string.h>  

#define STRCPY(a, b)    strcpy(a ##_p, #b) 

int main() 

{ 

char arrr_p[]="abcdefg"; 

char *b = "123456"; 

STRCPY(arrr, b); 

 return 0; 

} 

结果为把b变成了字符串，可见#b的功能是将所有类型名都变成了字符串。 另，a、_p和##有没有空格不影响结果。 

c/c++宏的使用总结

 

1 条件include

如下

CODE

#ifndef MAIN_H_

#define MAIN_H_

其它内容

#endif

上面在看到头文件时会看到 作用就是阻止这个头文件被多次include

多次include就会出现重复的定义情况 所以需要在每个头文件中都使用这个定义

如果还不是很了解要怎样使用 可以看看 c的标准头文件 如fcntl.h

在这里总结宏的使用方法 欢迎补充

 

1 条件include

如下

CODE

#ifndef MAIN_H_

#define MAIN_H_

其它内容

#endif

上面在看到头文件时会看到 作用就是阻止这个头文件被多次include

多次include就会出现重复的定义情况 所以需要在每个头文件中都使用这个定义 如果还不是很了解要怎样使用 可以看看 c的标准头文件 如fcntl.h

 

2 条件编译

 

#ifdef _DEBUG

printf("this debug info/n");

#endif

如果没有定义_DEBUG宏的话 那么上面那一行是不会编译进去的 

但是定义了_DEBUG后 上面那行就会编译进去 可以写个简单的程序测试

CODE

 

#include <stdio.h>

int main()

{

#ifdef _DEBUG

printf("hello world/n");

#else

printf("no debug");

#endif

return 0;

}

第一次使用 gcc -D_DEBUG main.c

第二次使用 gcc main.c

 

3 定义为某个值 以便后面修改这个值时不用修改其它地方代码 只要修改这个宏的定义就可以了 

如一个软件的多语言版本等 

如下

CODE

 

#include <stdio.h>

#define PRINT_STR "你好 DD"

main(){

printf(PRINT_STR);

return 0;

}

编译时 会把PRINT_STR代替成"你好 DD"以后想修改时就方便了

 

另外也可以定义为函数

#include <stdio.h>

 

#ifdef _DEBUG

#define A(x) a(x)

#else

#define A(x) b(x)

#endif

int a(int x)

{

return x+1;

}

int b(int x){

return x+100;

}

 

int main(){

printf ("A(10) value is %d",A(10));

return 0;

}

 

其实也可以定义成

#define A a

的但是 定义成A(x)后 只有A后面带一个(x)类型的 编译器才会执行替换 比较安全 可以保证只替换函数而不替换变量

 

第四个

可变参数宏

有些时候定义一个宏来代替某个函数 但是这个函数是可变参数的话 那就需要考虑办法了

定义方法如下

CODE

#define PRINT(...) printf(__VA_ARGS__)

#include <stdio.h>

int main(){

PRINT("%d %s %s",1,"吃饭了吗 smile MM:)","/n");

return 0;

}

 

第五个 宏组合 

也就是## 和 #的用法

## 是连接符号 连接两个宏

#是把名字代替成字符串

如下

CODE

#define s5(a) supper_ ## a

#include <stdio.h>

void supper_printf(const char* p )

{

printf("this is supper printf:/n%s/n",a);

}

 

int main()

{

 s5(printf)("hello owrld");

 return 0;

}

 

#用法如下

#include <stdio.h>

#define s(p) #p

int main(){

printf(s(p)"/n");

return 0;

}

 

最后 附上网上找到的宏定义的概念 

第一篇

第九章 预处理命令

预处理的概念：编译之前的处理

C的预处理主要有三个方面的内容：宏定义、文件包含、条件编译预处理命令以符号“#”开头。

 

9.1 宏定义

9.1.1 不带参数的宏定义

宏定义又称为宏代换、宏替换，简称“宏”

格式：

#define 标识符 字符串

其中的标识符就是所谓的符号常量，也称为“宏名”

预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。

掌握"宏"概念的关键是“换”。一切以换为前提、做任何事情之前先要换，准确理解之前就要“换”。

即在对相关命令或语句的含义和功能作具体分析之前就要换，“不管三七二十一，先换了再说”。那么剩下的问题就简单了：

1 把谁换掉？2 换成什么？

#define PI 3.1415926

把程序中出现的PI全部换成3.1415926

 

说明：（1）宏名一般用大写

（2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。

例如：数组大小常用宏定义

（3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法检查。

（4）宏定义末尾不加分号；

（5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。

（6）可以用#undef命令终止宏定义的作用域

（7）宏定义可以嵌套

（8）字符串""中永远不包含宏

（9）宏定义不分配内存，变量定义分配内存。

 

9.1.2 带参数的宏

除了一般的字符串替换，还要做参数代换

格式：

#define 宏名（参数表） 字符串

例如：#define S(a,B) a*b

area=S(3,2)；第一步被换为area=a*b;，第二步被换为area=3*2;

类似于函数调用，有一个哑实结合的过程

 

（1）实参如果是表达式容易出问题

#define S&reg; r*r

area=S(a+B);第一步换为area=r*r;,第二步被换为area=a+b*a+b;

正确的宏定义是#define S&reg; &reg;*&reg;

（2）宏名和参数的括号间不能有空格

（3）宏替换只作替换，不做计算，不做表达式求解

（4）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内存

（5）宏的哑实结合不存在类型，也没有类型转换。

（6）函数只有一个返回值，利用宏则可以设法得到多个值li9_4.c

（7）宏展开使源程序变长，函数调用不会

（8）宏展开不占运行时间，只占编译时间，函数调用占运行时间（分配内存、保留现场、值传递、返回值）li9_5.c分析该例中的"

9.2 “文件包含”处理

一个文件包含另一个文件的内容

格式：

#include "文件名"

或

#include <文件名>

编译时以包含处理以后的文件为编译单位，被包含的文件是源文件的一部分。

li9_6a.c li9_6b.c

编译以后只得到一个目标文件.obj

被包含的文件又被称为“标题文件”或“头部文件”、“头文件”，并且常用.h作扩展名。

修改头文件后所有包含该文件的文件都要重新编译

头文件的内容除了函数原型和宏定义外，还可以有结构体定义，全局变量定义

 

（1）一个#include命令指定一个头文件

（2）文件1包含文件2，文件2用到文件3，则文件3的包含命令#include应放在文件1的头部第一行。

（3）包含可以嵌套

（4）<文件名>称为标准方式，系统到头文件目录查找文件

"文件名"则先在当前目录查找，而后到头文件目录查找

（5）被包含文件中的静态全局变量不用在包含文件中声明。

 

9.3 条件编译

 

有些语句行希望在条件满足时才编译。

格式：（1）

#ifdef 标识符

程序段1

#else

程序段2

#endif

或

#ifdef

程序段1

#endif

 

当标识符已经定义时，程序段1才参加编译。

格式：（2）

#ifndef 标识符

格式：（3）

#if 表达式

li9_7.c

使用条件编译可以使目标程序变小，运行时间变短。

预编译使问题或算法的解决方案增多，有助于我们选择合适的解决方案。

 

第7章 预处理程序

 

7.1什么是预处理程序

预处理程序是一些行首以＃开始的特殊语句，例如：＃include，＃define等就是预处理语句。在编译程序的编译过程中，进行其它编译处理(词法分析、语法分析、代码生成、优化和连接等)之前，先进行这些语句的分析处理。

预处理语句使用的目的在于帮助程序员编写出易读、易改、易移植并便于调试的程序。预处理语句主要有四种：

宏定义和宏替换、文件包含、条件编译和行控制。

预处理语句的作用范围是从被定义语句开始直至被解除定义或是到包含它的文件结术为止均有效。

 

7.2宏定义和宏替换

“宏”是借用汇编语言中的概念。为的是在C语言程序中方便的作一些定义和扩展。这些语句以＃define开头，分为两种：符号常量的宏定义和带参数的宏定义。

1.符号常量的宏定义和宏替换

符号常量的宏定义语句是一般格式：

＃define 标识符 字符串

其中标识符就叫作宏名称。

注意：标识符与字符串之间不要用‘＝’，结尾不要加‘；’。

2.带有参数的宏定义及其替换

复杂的宏定义带有参数列表，参数列表中可有不止一个参数，其一般格式：

＃define 标识符(参数列表) 字符串

对带有参数的宏定义进行宏替换时，不仅对宏标识符作字符串替换，还必须作参数的替换。

例如：

＃define SQ(x) ((x)*(x))

那么SQ(a+B)将被宏替换成(a+B)*(a+B)。

宏定义也可嵌套使用，即一个宏定义可用另一个宏定义来定义。例如：

＃define SQ(x) ((x)*(x))

＃define CUBE(x) (SQ(x)*(x))

3.宏定义类函数

宏定义常用于把直接插入的代码来代替函数，以提高执行效率。这一类的宏，就称做宏定义类函数，例如：

＃define MIN(x，y) (((x)＜(y))?(x):(y))

有了这样的宏之后，就可以直接引用，例如：

m=MIN(a，B)；

这语句将被预处理成：

m=(((a)＜(B))?(a):(B))；

 

7.3文件包含

文件包含是指一个程序文件将另一个指定义文件的内容包含进来，用＃include语句来说明。

一般有两种格式：

(1) ＃include ＜文件名＞

(2) ＃include ″文件名″

第一种，用尖括号表示在标准库目录下找该文件；第二种，用双引号表示先在当前目录(源文件所在目录)中找包含文件，若找不到，再到标准库目录中找。系统的标准库文件都是.h文件。例如：

＃include ＜stdio.h＞ /* 标准输入输出的基本常量和宏或函数文件 */

＃include ＜string.h＞ /* 串函数文件 */

＃include ＜malloc.h＞ /* 内存分配函数文件 */

＃include ＜ctype.h＞ /* 字符函数文件 */

＃include ＜math.h＞ /* 数学函数库文件 */

用文件包含，可以减少重复工作，提高程序正确性，还便于维护修改。程序员可以把自己常用的一些符号常量、类型定义和带参数的宏定义，以及一些常用自编函数都放在.h文件中，通过＃include语句包含引用之。

 

 

 

7.4条件编译

提供条件编译措施使同一源程序可以根据不同编译条件(参数)产生不同的目录代码，其作用在于便于调试和移植。

条件编译控制语句有不同形式，下面分别讨论。

1.＃ifdef语句及其使用

一般格式：

＃ifdef 标识符

语句块1

＃else

语句块2

＃endif

 

7.4格式化输入/输出

格式化的控制台I/O函数有两种，它们都与标准I/O库有关。源程序开头应包含标准输入输出头文件：

＃include ＜stdio.h＞

1.printf()

printf()函数功能为按指定格式输出显示各种基本类型数据，其一般格式：

printf(“控制串”，参数列表)

控制串分两部分，即：要显示的字符和格式串。格式串以“%”开头，后跟格式码。格式串与参数一一对应。

2.scanf()

scanf()的功能是读入各种类型数据，并自动将其转换为恰当的格式，其一般格式为： scanf(“控制串”，参数列表)

控制串与前述printf()中的控制串类似，也包含有以“%”开头加格式码组成的格式串。参数列表所列出的应当是变量的地址，而不是变量名。