matlab 类似宏定义,比较全面的宏定义解析

宏定义

宏定义是C提供的三种预处理功能的其中一种，这三种预处理包括：宏定义、文件包含、条件编译。

参数

不带参数

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

格式：

#define 标识符 字符串

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

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

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

即在对相关命令或语句的含义和功能作具体分析之前就要换：

例：

#define Pi 3.1415926

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

说明：

(1)宏名一般用大写

(2)使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。例如：数组大小常用宏定义

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

(4)宏定义末尾不加分号；

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

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

(7)宏定义允许嵌套

(8)字符串' '中永远不包含宏

(9)宏定义不分配内存，变量定义分配内存。

(10)宏定义不存在类型问题，它的参数也是无类型的。[2]

带参数

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

格式：

#define宏名(参数表) 字符串

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

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

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

(1)实参如果是表达式容易出问题

#define S(r) r*r

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

正确的宏定义是#define S(r) ((r)*(r))

(2)宏名和参数的括号间不能有空格

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

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

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

(6)函数只有一个返回值，利用宏则可以设法得到多个值

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

(8)宏展开不占运行时间，只占编译时间，函数调用占运行时间(分配内存、保留现场、值传递、返回值)[3]

冷门重点

1.#define用法

1、 用无参宏定义一个简单的常量

#define LEN 12

这个是最常见的用法，但也会出错。

比如下面几个知识点你会吗？可以看下：

(1)#define NAME 'zhangyuncong'

程序中有'NAME'则，它会不会被替换呢？

(2)#define 0x abcd

可以吗？也就是说，可不可以用不是标识符的字母替换成别的东西？

(3)#define NAME 'zhang

这个可以吗？

(4)#define NAME 'zhangyuncong'

程序中有上面的宏定义，并且，程序里有句：

NAMELIST这样，会不会被替换成'zhangyuncong'LIST

四个题答案都是十分明确的。

第一个，''内的东西不会被宏替换。这一点应该大都知道。

第二个，宏定义前面的那个必须是合法的用户标识符

第三个，宏定义也不是说后面东西随便写，不能把字符串的两个''拆开。

第四个：只替换标识符，不替换别的东西。NAMELIST整体是个标识符，而没有NAME标识符，所以不替换。

也就是说，这种情况下记住：#define第一位置第二位置

(1) 不替换程序中字符串里的东西。

(2) 第一位置只能是合法的标识符(可以是关键字)

(3) 第二位置如果有字符串，必须把''配对。

(4) 只替换与第一位置完全相同的标识符

还有就是老生常谈的话：记住这是简单的替换而已，不要在中间计算结果，一定要替换出表达式之后再算。

2、 带参宏一般用法

比如#define MAX(a,b) ((a)>(b)?(a):(b))

则遇到MAX(1+2,value)则会把它替换成：

((1+2)>(value)?(1+2):(value))

注意事项和无参宏差不多。

但还是应注意

#define FUN(a) 'a'

则，输入FUN(345)会被替换成什么？

其实，如果这么写，无论宏的实参是什么，都不会影响其被替换成'a'的命运。

也就是说，''内的字符不被当成形参，即使它和一模一样。

那么，你会问了，我要是想让这里输入FUN(345)它就替换成'345'该怎么实现呢？

请看下面关于#的用法

3、 有参宏定义中#的用法

需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开，被当做字符串处理

#define STR(str) #str

#用于把宏定义中的参数两端加上字符串的''

比如，这里STR(my#name)会被替换成'my#name'

一般由任意字符都可以做形参，但以下情况会出错：

STR())这样，编译器不会把“)”当成STR()的参数。

STR(,)同上，编译器不会把“,”当成STR的参数。

STR(A,B)如果实参过多，则编译器会把多余的参数舍去。(VC++2008为例)

STR((A,B))会被解读为实参为：(A,B)，而不是被解读为两个实参，第一个是(A第二个是B)。

4、 有参宏定义中##的用法

#define WIDE(str) L##str

则会将形参str的前面加上L

比如：WIDE('abc')就会被替换成L'abc'

如果有#defineFUN(a,b) vo##a##b()

那么FUN(id ma,in)会被替换成void main()

5、 多行宏定义：

#define doit(m,n) for(int i=0;i

{\

m+=i;\

}

宏定义转自 百度百科

C语言宏定义##连接符和#符的使用

C语言中如何使用宏C(和C++)中的宏(Macro)属于编译器预处理的范畴，属于编译期概念(而非运行期概念)。下面对常遇到的宏的使用问题做了简单总结。

宏中'#'和'##'的用法

一般用法我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起(这里说的是在预处理是对源文件的操作).

用法:

#include#includeusing namespace std;

#define STR(s)     #s

#define CONS(a,b) int(a##e##b)

int main()

{

printf(STR(vck));           // 输出字符串'vck'

printf('%d/n', CONS(2,3)); // 2e3 输出:2000

return 0;

}

当宏参数是另一个宏的时候需要注意的是凡宏定义里有用''#''或''##''的地方宏参数是不会再展开.

1, 非''#''和''##''的情况

#define TOW      (2)

#define MUL(a,b) (a*b)

printf('%d*%d=%d/n', TOW, TOW, MUL(TOW,TOW));

这行的宏会被展开为：

printf('%d*%d=%d/n', (2), (2), ((2)*(2)));

MUL里的参数TOW会被展开为(2).

2, 当有''#''或''##''的时候

#define A          (2)

#define STR(s)     #s

#define CONS(a,b) int(a##e##b)

printf('int max: %s/n', STR(INT_MAX));    // INT_MAX #include

这行会被展开为：

printf('int max: %s/n', 'INT_MAX');           //而不是0x7FFFFFFF INT_MAX不展开了

printf('%s/n', CONS(A, A));               // compile error

这一行则是：

printf('%s/n', int(AeA));

INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏.

加这层宏的用意是把所有宏的参数在中间层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.

#define A           (2)

#define _STR(s)     #s

#define STR(s)      _STR(s)         // 转换宏

#define _CONS(a,b) int(a##e##b)

#define CONS(a,b)   _CONS(a,b)      // 转换宏

printf('int max: %s/n', STR(INT_MAX));            // INT_MAX,int型的最大值,为一个变量 #include

输出为: int max: 0x7fffffff

STR(INT_MAX) --> _STR(0x7fffffff) 然后再转换成字符串;

printf('%d/n', CONS(A, A));

输出为：200

CONS(A, A) --> _CONS((2), (2)) --> int((2)e(2))

''#''和''##''的一些应用特例1、合并匿名变量名

#define ___ANONYMOUS1(type, var, line) type var##line

#define __ANONYMOUS0(type, line) ___ANONYMOUS1(type, _anonymous, line)

#define ANONYMOUS(type) __ANONYMOUS0(type, __LINE__)

例：ANONYMOUS(static int); 即: static int _anonymous70; 70表示该行行号;

第一层：ANONYMOUS(static int); --> __ANONYMOUS0(static int, __LINE__);

第二层：                        --> ___ANONYMOUS1(static int, _anonymous, 70);

第三层：                        --> static int _anonymous70;

即每次只能解开当前层的宏,所以__LINE__在第二层才能被解开;

2、填充结构

#define FILL(a)   {a, #a}

enum IDD{OPEN, CLOSE};

typedef struct MSG{

IDD id;

const char * msg;

}MSG;

MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};

相当于：

MSG _msg[] = {{OPEN, 'OPEN'},

{CLOSE, 'CLOSE'}};

3、记录文件名

#define _GET_FILE_NAME(f)   #f

#define GET_FILE_NAME(f)    _GET_FILE_NAME(f)

static char FILE_NAME[] = GET_FILE_NAME(__FILE__);

4、得到一个数值类型所对应的字符串缓冲大小

#define _TYPE_BUF_SIZE(type) sizeof #type

#define TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type)

char buf[TYPE_BUF_SIZE(INT_MAX)];

--> char buf[_TYPE_BUF_SIZE(0x7fffffff)];

--> char buf[sizeof '0x7fffffff'];

这里相当于：

char buf[11];

变参宏消除多余的分号Duplication of Side Effects

关于变参的使用

...在C宏中称为Variadic Macro，也就是变参宏。比如：

#define myprintf(templt,...) fprintf(stderr,templt,__VA_ARGS__)// 或者#define myprintf(templt,args...) fprintf(stderr,templt,args)

第一个宏中由于没有对变参起名，我们用默认的宏__VA_ARGS__来替代它。第二个宏 中，我们显式地命名变参为args，那么我们在宏定义中就可以用args来代指变参了。同C语言的stdcall一样，变参必须作为参数表的最有一项出 现。当上面的宏中我们只能提供第一个参数templt时，C标准要求我们必须写成：

myprintf(templt,);

的形式。这时的替换过程为：

myprintf('Error!/n',);

替换为：fprintf(stderr,'Error!/n',);

这是一个语法错误，不能正常编译。这个问题一般有两个解决方法。首先，GNU CPP提供的解决方法允许上面的宏调用写成：

myprintf(templt);

而它将会被通过替换变成：

fprintf(stderr,'Error!/n',);

很明显，这里仍然会产生编译错误(非本例的某些情况下不会产生编译错误)。除了这种方式外，c99和GNU CPP都支持下面的宏定义方式：

#define myprintf(templt, ...) fprintf(stderr,templt, ##__VAR_ARGS__)

这时，##这个连接符号充当的作用就是当__VAR_ARGS__为空的时候，消除前面的那个逗号。那么此时的翻译过程如下：

myprintf(templt);

被转化为：fprintf(stderr,templt);

这样如果templt合法，将不会产生编译错误。 这里列出了一些宏使用中容易出错的地方，以及合适的使用方式。

消除多余的分号－Semicolon Swallowing

通常情况下，为了使函数模样的宏在表面上看起来像一个通常的C语言调用一样，通常情况下我们在宏的后面加上一个分号，比如下面的带参宏：

MY_MACRO(x);

但是如果是下面的情况：

#define MY_MACRO(x) { /* line 1 */ /* line 2 */ /* line 3 */ }//...if (condition())MY_MACRO(a);else{...}

这样会由于多出的那个分号产生编译错误。为了避免这种情况出现同时保持MY_MACRO(x);的这种写法，我们需要把宏定义为这种形式：

#define MY_MACRO(x) do {/* line 1 */ /* line 2 */ /* line 3 */ } while(0)

这样只要保证总是使用分号，就不会有任何问题。

Duplication of Side Effects

这里的Side Effect是指宏在展开的时候对其参数可能进行多次Evaluation(也就是取值)，但是如果这个宏参数是一个函数，那么就有可能被调用多次从而达到不一致的结果，甚至会发生更严重的错误。比如：

#define min(X,Y) ((X) > (Y) ? (Y) : (X))//...c = min(a,foo(b));

这时foo()函数就被调用了两次。为了解决这个潜在的问题，我们应当这样写min(X,Y)这个宏：

#define min(X,Y) ({ typeof (X) x_ = (X); typeof (Y) y_ = (Y); (x_ < y_) ? x_ : y_; })

({...})的作用是将内部的几条语句中最后一条的值返回，它也允许在内部声明变量(因为它通过大括号组成了一个局部Scope)。

ANSI C标准中有几个标准预定义宏：__FILE__     __DATE__   __TIME___    __LINE__   等

__LINE__：在源代码中插入当前源代码行号；

__FILE__：在源文件中插入当前源文件名；

__DATE__：在源文件中插入当前的编译日期

__TIME__：在源文件中插入当前编译时间；

__STDC__：当要求程序严格遵循ANSI C标准时该标识被赋值为1；

__cplusplus：当编写C++程序时该标识符被定义。

_FUNCTION_  当前所在函数名

这几个宏比较有用

在调试程序时或编译时，__LINE__比较有用，可以用来打印逻辑错误的行号～～～～～～～，例子：

switch(x)

{

case 1:

....;

break;

case 2:

.....;

break;

default:

printf('logic erro line number%d!/n',__LINE__);

break;

}

又如利用__DATE__和__TIME__可以插入编译时间。

代码：

void print_version_info(void)

{

printf('Date Compiled:%s/n',__DATE__);

printf('TimeCompiled:%s/n',__TIME__);

}

输出格式为:mm dd yy 和 hh：mm：ss

对于__FILE__，__LINE__，__func__这样的宏，在调试程序时是很有用的，因为你可以很容易的知道程序运行到了哪个文件的那一 行，是哪个函数。

下面一个例子是打印上面这些预定义的宏的。

__DATE__,__FILE__,__LINE__,__TIME__,__FUNCTION__ C标准中指定了一些预定义的宏，对于编程经常会用到。下面这个表中就是一些常常用到的预定义宏。

__DATE_ %s_

进行预处理的日期(“Mmm dd yyyy”形式的字符串文字)

__FILE__  %s

代表当前源代码文件名的字符串文字

__LINE__    %d

代表当前源代码中的行号的整数常量

__TIME__  %s

源文件编译时间，格式微“hh：mm：ss”

__FUNCTION__(__func__)  %s

当前所在函数名

__PRETTY_FUNCTION__ %s

当前所在函数名，包括返回类型和参数类型。

例如：printf('__PRETTY_FUNCTION__:%s/n', __PRETTY_FUNCTION__);

输出：__PRETTY_FUNCTION__:int main(int, char**)

#include #include void why_me();

int main()

{

printf( 'The file is %s./n', __FILE__ );

printf( 'The date is %s./n', __DATE__ );

printf( 'The time is %s./n', __TIME__ );

printf( 'This is line %d./n', __LINE__ );

printf( 'This function is %s./n', __FUNCTION__ );

why_me();

return 0;

}

void why_me()

{

printf( 'This function is %s/n', __func__ );

printf( 'The file is %s./n', __FILE__ );

printf( 'This is line %d./n', __LINE__ );

}

c,c++ ANSI中预定义 _cplusplus 简介

经常在/usr/include目录下看到这种字句：

#ifdef __cplusplus

extern 'C' {

#endif

...

#ifdef __cplusplus

}

#endif

不太明白是怎么用的。今天阅读autobook，在第53页看到了作者的解释：C/C++编译器对函数和变量名的命名方法不一样(例如C++中重载的函数有多个名字，而C的函数只有一个名字)，这样当C编译器去引用C++编译器编译出来的符号时，会找不到链接。因此，当一个头文件可能既被C程序引用，又被C++程序引用时，需要使用如上代码进行区分。

上面的写法太复杂了，况且两个大括号{和}分离，会造成有些编辑器的缩进错误。更好的手法是将如下代码定义在一个公共头文件中，然后所有其它头文件去引用它：

#ifdef __cplusplus

#  define BEGIN_C_DECLS         extern 'C' {

#  define END_C_DECLS           }

#else

#  define BEGIN_C_DECLS

#  define END_C_DECLS

#endif