计算机c语言宏定义实例讲解

详解C语⾔的宏定义宏定义介绍假设我们有⼀个 C 源⽂件 main.c，那么只需要通过 gcc main.c -o main.exe 即可编译成可执⾏⽂件（如果只写 gcc main.c，那么 Windows 上会默认⽣成 a.exe、Linux 上会默认⽣成 a.out ），但是这⼀步可以拆解成如下步骤：预处理：gcc -E main.c -o main.i，根据 C 源⽂件得到预处理之后的⽂件，这⼀步只是对 main.c 进⾏了预处理：⽐如宏定义展开、头⽂件展开、条件编译等等，同时将代码中的注释删除，注意：这⾥并不会检查语法；编译：gcc -S main.i -o main.s，将预处理后的⽂件进⾏编译、⽣成汇编⽂件，这⼀步会进⾏语法检测、变量的内存分配等等；汇编：gcc -c main.s -o main.o，根据汇编⽂件⽣成⽬标⽂件，当然我们也可以通过 gcc -c main.c -o main.o 直接通过 C 源⽂件得到⽬标⽂件；链接：gcc main.o -o main.exe，程序是需要依赖各种库的，可以是静态库也可以是动态库，因此需要将⽬标⽂件和其引⽤的库链接在⼀起，最终才能构成可执⾏的⼆进制⽂件。

⽽这⾥我们主要来介绍⼀下预处理中的宏定义，相信很多⼈都觉得宏定义⾮常简单，但其实宏定义有很多⾼级⽤法。

我们先来看看简单的宏定义：#include <stdio.h>// 宏定义的⽅式为：#define 标识符常量// 然后会将所有的 PI 替换成 3.14#define PI 3.14int main() {printf("%f\n", PI);}我们⽣成预处理之后的⽂件：gcc -E main.c -o main.i我们看到 PI 被替换成了 3.14，当然除了浮点型之外，也可以是其它的类型：#include <stdio.h>#define NAME "satori"#define AGE 17#define GENDER 'f'int main() {printf("%s %d %c\n", NAME, AGE, GENDER); // satori 17 f}我们再来查看⽣成的预处理⽂件：我们看到确实只是简单替换，除此之外，没有做任何的处理。

CC++语⾔宏定义使⽤实例详解C/C++语⾔宏定义使⽤实例详解1. #ifndef 防⽌头⽂件重定义在⼀个⼤的软件⼯程⾥⾯，可能会有多个⽂件同时包含⼀个头⽂件，当这些⽂件编译链接成⼀个可执⾏⽂件时，就会出现⼤量“重定义”的错误。

在头⽂件中实⽤#ifndef #define #endif能避免头⽂件的重定义。

⽅法：例如要编写头⽂件test.h在头⽂件开头写上两⾏：#ifndef TEST_H#define TEST_H //⼀般是⽂件名的⼤写头⽂件结尾写上⼀⾏：#endif这样⼀个⼯程⽂件⾥同时包含两个test.h时，就不会出现重定义的错误了。

注：Visual C++中有⼀种简化的⽅法，那就是使⽤ #pragma once2. 编写跨平台的C/C++程序2.1 操作系统相关宏定义Windows: WIN32Linux: linuxSolaris: __sun2.2 编译器相关宏定义VC: _MSC_VERGCC/G++: __GNUC__SunCC: __SUNPRO_C 和 __SUNPRO_CC3. 完整的代码实例//Avoid redefine anything in this header#ifndef UUID_H#define UUID_H// Check platform is Windows or Linux#ifdef _MSC_VER#ifndef DLL_API#define DLL_API __declspec(dllexport)#endif#else#ifndef DLL_API#define DLL_API#endif#endif#include <string>#include <random>#include <time.h>#include <stdlib.h>using namespace std;class DLL_API UUID {public:static string getUuidString();};#endif感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

C语言中的宏定义SUNNY.MAN1.宏定义格式：#define 标识符字符串其中的标识符就是所谓的符号常量，也称为“宏名”。

预处理（预编译）工作也叫做宏展开，就是把宏名替换为字符串。

2.为什么要使用宏定义我认为主要有两点：1.增强程序的可读性2.增强程序的可移植性int a=16;int *a=(int *)0;如果我们都是把int当32位来处理的，有一天我们的程序需要把int当16位来处理，你怎么办呢？#define int int16//请注意这个int16才是真正的类型(int *)0;也不好看啊。

我们喜欢用NULL，那也定义一个宏好了。

#define NULL (myint *)03.宏定义的作用域这是我写这文的目的。

请看下面的小例子Int sum(int a);Int main(void){Int a=sum(1);Int b=MM;Return 0;}Int sum(int a){#define MM 123Return a+MM;}这个程序在编译的时假会产生一个类似于下面的错误：MM undeclared (first use in this function)。

所以切记宏展开的位置是在文件中的位置，而不是调用它的位置。

运行和编译是两个阶段。

如果1.c文件中#undef MM#define MM 102.c文件中#undef MM#define MM 20那么到底是MM被定义为10呢还是20呢。

请记住宏展开的时机是预处理阶段而不是编译阶段，预处理阶段不检查语法错误。

也就是文件1中的还是10，文件2中的还是20。

4.宏的基本使用1.宏定义末尾不需要像语句一样加分号，但你可以根据需要自己进行添加；2.宏定义不管写在函数的花括号里外边，作用域为其后的程序行，通常在文件的最开头。

3.可以用#undef命令终止宏定义的作用域4.宏定义允许嵌套5.字符串( " " )中不会进行宏替换例如：#define TEST "this is a test"程序行中有"TEST"时不会替换为”this is a test”.6.宏定义的第二个“标识符”必须是合法的C语言的标识符。

c 函数内部宏定义C函数内部宏定义一、参数检查宏定义在函数内部，我们经常需要对参数进行检查，以确保参数的合法性。

为了简化参数检查的代码，我们可以使用宏定义来实现。

下面是一个示例：```#define CHECK_PARAM(param) \if (!(param)) { \printf("参数错误：%s\n", #param); \return; \}```在上面的示例中，我们定义了一个宏CHECK_PARAM，该宏接受一个参数param，并在参数为假时输出错误信息并返回。

通过使用这个宏，我们可以简化参数检查的代码，提高代码的可读性和可维护性。

二、条件编译宏定义在函数内部，有时我们需要根据不同的条件编译不同的代码。

为了简化条件编译的代码，我们可以使用宏定义来实现。

下面是一个示例：```#define DEBUG_MODE#ifdef DEBUG_MODE#define DEBUG_LOG(...) printf(__VA_ARGS__)#else#define DEBUG_LOG(...)#endif```在上面的示例中，我们定义了一个宏DEBUG_MODE，该宏用于开启或关闭调试模式。

当DEBUG_MODE被定义时，宏DEBUG_LOG会输出调试信息；当DEBUG_MODE未被定义时，宏DEBUG_LOG为空宏。

通过使用这个宏，我们可以方便地在调试模式和发布模式之间切换，提高代码的可维护性。

三、局部变量宏定义在函数内部，有时我们需要定义一些局部变量来辅助实现某些功能。

为了简化局部变量的定义，我们可以使用宏定义来实现。

下面是一个示例：```#define LOCAL_VAR(type, name, value) \type name = value;```在上面的示例中，我们定义了一个宏LOCAL_VAR，该宏接受三个参数：变量的类型type、变量的名称name和变量的初始值value。

在软件开发过程中需要定制各种小工具在软件开发过程中需要定制各种小工具实现模块公共功能的复用和易用其中编码实现模块公共功能的复用和易用其中编码过程中的过程中的bugbug调试工具就是非常重要的一种调试工具就是非常重要的一种类型
Special Issue for HITMath-07
补充（三） 宏 编程 —— #define
& 常用调试技巧
Macro Programming Using #define &
General Debug Technology
1
内容简介
本部分将主要讲解C++中宏定义的 应用——如何利用宏来简化程序设计， 实现代码级的简化、封装、重用等。
2
简单常量的定义
#define N 1000
定义简单的常量，便于修改。 切不可在后面加上分号！ 等效于 const int N = 1000; 仅是简单替换，而不是作为一个量来使用。
则，IW3DScene* pScene = MAKE_COMPONENT( Scene ); 将被理解为：
pScene = ((IW3DScene *)MakeComponent("Scene");
8
宏定义举例（二）
#define IMPLEMENT_COMPONENT( I, C )
\
static IComponent* Component_Factory_##C() \
// …
void Draw() {
// … } // Draw
private: DWORD m_dwFogColor; ///< Fog color
// … }; //class CW3DCamera

宏定义在C语言中是一种预处理指令，它可以在编译之前对代码进行替换。

宏定义可以用来定义常量、创建函数等。

下面是一个简单的宏定义函数的例子：
```c
#include <stdio.h>
// 宏定义函数，将输入的两个整数相加
#define ADD(x, y) ((x) + (y))
int main() {
int a = 5;
int b = 10;
int sum = ADD(a, b);
printf("The sum of %d and %d is %d\n", a, b, sum);
return 0;
}
```
在这个例子中，我们定义了一个名为ADD的宏，它接受两个参数x 和y，并返回它们的和。

在main函数中，我们使用这个宏来计算两
个整数的和，并打印结果。

注意，为了在宏中使用加法运算符，我们需要使用括号将其包围起来，否则编译器可能会将其解析为乘法运算符。

c语⾔宏定义详解1,防⽌⼀个头⽂件被重复包含#ifndef COMDEF_H#define COMDEF_H//头⽂件内容#endif2,重新定义⼀些类型,防⽌由于各种平台和编译器的不同,⽽产⽣的类型字节数差异,⽅便移植。

typedef unsigned char boolean; /* Boolean value type. */typedef unsigned long int uint32; /* Unsigned 32 bit value */typedef unsigned short uint16; /* Unsigned 16 bit value */typedef unsigned char uint8; /* Unsigned 8 bit value */typedef signed long int int32; /* Signed 32 bit value */typedef signed short int16; /* Signed 16 bit value */typedef signed char int8; /* Signed 8 bit value *///下⾯的不建议使⽤typedef unsigned char byte; /* Unsigned 8 bit value type. */typedef unsigned short word; /* Unsinged 16 bit value type. */typedef unsigned long dword; /* Unsigned 32 bit value type. */typedef unsigned char uint1; /* Unsigned 8 bit value type. */typedef unsigned short uint2; /* Unsigned 16 bit value type. */typedef unsigned long uint4; /* Unsigned 32 bit value type. */typedef signed char int1; /* Signed 8 bit value type. */typedef signed short int2; /* Signed 16 bit value type. */typedef long int int4; /* Signed 32 bit value type. */typedef signed long sint31; /* Signed 32 bit value */typedef signed short sint15; /* Signed 16 bit value */typedef signed char sint7; /* Signed 8 bit value */3,得到指定地址上的⼀个字节或字#define MEM_B( x ) ( *( (byte *) (x) ) )#define MEM_W( x ) ( *( (word *) (x) ) )4,求最⼤值和最⼩值#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )5, 得到⼀个field在结构体(struct)中的偏移量#define FPOS( type, field ) \/*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e545 */分析：#includetypedef struct person {int num;int age;char name[20];}person;#define FPOS(type,field) sizeof(((type *)0)->field)main(){printf("%d\n",FPOS(person,name));}^_^[sunny@localhost ~]52$ ./a.out20#define OFFSETOF(type, field) ((size_t)&(((type *)0)->field))(type *)0：把0地址当成type类型的指针。

#define MALLOC(type, x) (type*)malloc(sizeof(type)*x)
#define FREE(p) (free(p), p=NULL)
#define LOG(s) printf("[%s] {%s:%d} %s \n", __DATE__,
__FILE__, __LINE__, s)
return 0; }
预编译： # 1 "test.c" # 1 "<built-in>" # 1 "<command-line>" # 1 "/usr/include/stdc-predef.h" 1 3 4 # 1 "<command-line>" 2 # 1 "test.c"
int main() {
#define FOREACH(i, m) for(i=0; i<m; i++) #define BEGIN { #define END }
int main(void) {
int x = 0; int* p = MALLOC(int, 5);
LOG("Begin to run main code...");
例程： //#include <stdio.h>
#define _SUM_(a, b) (a) + (b) #define _MIN_(a, b) ((a) < (b) ? (a) : (b)) #define _DIM_(a) sizeof(a)/sizeof(*a)
int main() {
int a = 1;

c语⾔之带参数的宏定义1.带参数的宏定义中，宏名和新参表之间不能有空格，2.在带参数的宏定义中，形参参数不分配内存单元，因此不必作类型定义。

⽽宏调⽤中的实参有具体值，要⽤它去代换形参，因此必须作类型说明。

#include<stdio.h>#include<iostream>#define MAX(a,b) (a>b)?a:bint main() {int x, y, max;x = 2;y = 3;max = MAX(x,y);printf("%d\n", max);system("pause");return0;}3.在宏定义中的形参是标识符，⽽宏调⽤中实参可以是表达式。

4.在宏定义中，字符串内的形参通常要⽤括号括起来以避免出错。

5.带参的宏和代餐函数类似，但本质不同，除此之外，把同⼀表达式⽤函数处理和⽤宏处理两者的结果有可能不同。

普通函数：#include<stdio.h>#include<iostream>int SQ(int y) {return ((y) * (y));}int main() {int i = 1;int SQ(int y);while (i <= 5) {printf("%d ", SQ(i++));}printf("\n");system("pause");return0;}输出：宏定义：#include<stdio.h>#include<iostream>#define SQ(y) (y)*(y)int main() {int i = 1;while (i <= 5) {printf("%d ", SQ(i++));}printf("\n");system("pause");return0;}输出：为什么结果不同呢？这是因为普通函数调⽤时，实参传给形参的是值，⽽在宏定义时，要⽤表达式进⾏替换，即(i++)*(i++)，所以I++会被执⾏两次。

C语言宏定义详解我们可能要定义很多常量( 不管是放在源文件还是头文件 ),那么我们有时考虑定义某个常量时,我们就必须返回检查原来此常量是否定义,但这样做很麻烦.if defined宏正是为这种情况提供了解决方案.举个例子,如下:#define ....#define ....................#define a 100.......此时，我们要检查a是否定义（假设我们已经记不着这点了）,或者我们要给a一个不同的值，就加入如下句子#if defined a#undef a#define a 200#endif上述语句检验a是否被定义，如果被定义，则用#undef语句解除定义，并重新定义a为200 同样，检验a是否定义：#ifndef a //如果a没有被定义#define a 100#endif以上所用的宏中：#undef为解除定义，#ifndef是if not defined的缩写，即如果没有定义。

这就是#if defined 的唯一作用常用宏定义总结*pclint////////////////////////////////// #include <stdio.h>////////////////////////////////#define VPLS_EXT_DEBUG 1#if VPLS_EXT_DEBUG#define _VE_DEBUG(msg...) printf("[VPLS_DEBUG] %s,%d => ",__FILE__, __LINE__);printf(msg);printf("\r\n")#else#define_VE_DEBUG(x1,x2) (void)(x1),(void)(x2)#endif调用直接写为_VE_DEBUG("XXXXX %d",adb)开关关闭后这句直接失效//////////////////////////////main(void){ int a,b,c,d; a = b = c = d = 9;_BUG("a = %d,b = %d,c = %d,d = %d\n",a,b,c,d);}#define assert(e)\ ((void)((e) || fprintf(stderr,"line %d: 'asserterror!'\n",__LINE__)))////////////////////////////////////__attribute__ 作用- -__attribute__ 是GCC的关键字，描述变量的属性。

C语⾔预处理命令--宏定义⼀、宏讲解1、宏定义宏（Macro），是⼀种的称谓。

⾥的宏是⼀种（Abstraction），它根据⼀系列预定义的规则替换⼀定的⽂本模式。

或在遇到宏时会⾃动进⾏这⼀模式替换。

2、C语⾔宏定义的常规⽤法1) 定义符号常量#define PI 3.1415926#define MAX_N 100002) 定义傻⽠表达式（注意，定义的这种表达式⼀不⼩⼼很容易出现bug，下⽂会讲）#define S(a, b) a * b#define MAX(a, b) (a) > (b) ? (a) : (b)3) 定义代码段#define P(a) {\ printf("%d\n", a);\}　ps：编译器对于宏的解析是很严谨的，只能⽀持⼀⾏解析，\是起连接作⽤，表⽰当⾏的宏代码与下⼀⾏宏连接在⼀起，使得编译器当成⼀⾏看待。

3、编译器预定义的宏在C语⾔中，我们有很多预定义的宏，就是C语⾔帮程序员预先定义好的宏，可以让我们使⽤。

宏说明__DATE__ ⽇期：Mmm dd yyyy__TIME__ 时间：hh:mm:ss__LINE__ 当前源⽂件的代码⾏号__FILE__ ⽂件名__func__ 函数名/⾮标准__FUNC__ 函数名/⾮标准__PRETTY_FUNCTION__ 更详细的函数信息/⾮标准4、预定义命令-条件式编译函数说明#ifdef DEBUG 是否定义了DEBUG宏#ifndef DEBUG 是否没有定义DEBUG宏#if MAX_N == 5 宏MAX_N是否等于5#elif MAX_N == 4 否则宏MAX_N是否等于4#else#endif5、预定义命令从上图可以看到： 预编译 将.c ⽂件转化成 .i⽂件 使⽤的gcc命令是：gcc –E 对应于预处理命令cpp 编译 将.c/.h⽂件转换成.s⽂件 使⽤的gcc命令是：gcc –S 对应于编译命令 cc –S 汇编 将.s ⽂件转化成 .o⽂件 使⽤的gcc 命令是：gcc –c 对应于汇编命令是 as 链接 将.o⽂件转化成可执⾏程序 使⽤的gcc 命令是： gcc 对应于链接命令是 ld 总结起来编译过程就上⾯的四个过程：预编译、编译、汇编、链接。

指令用途# 空指令，无任何效果#include 包含一个源代码文件#define 定义宏#undef 取消已定义的宏#if 如果给定条件为真，则编译下面代码#ifdef 如果宏已经定义，则编译下面代码#ifndef 如果宏没有定义，则编译下面代码#elif 如果前面的#if给定条件不为真，当前条件为真，则编译下面代码#endif 结束一个#if……#else条件编译块#error 停止编译并显示错误信息一、文件包含#include预处理指令的作用是在指令处展开被包含的文件。

包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。

标准C编译器至少支持八重嵌套包含。

预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。

这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。

例如：#define AAA #include t.c #undef AAA #include t.c为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。

例如：/*my.h*/#ifndef MY_H#define MY_H……#endif在程序中包含头文件有两种格式：#include#include my.h第一种方法是用尖括号把头文件括起来。

这种格式告诉预处理程序在编译器自带的或外部库的头文件中搜索被包含的头文件。

第二种方法是用双引号把头文件括起来。

这种格式告诉预处理程序在当前被编译的应用程序的源代码文件中搜索被包含的头文件，如果找不到，再搜索编译器自带的头文件。

采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。

一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。

采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。

二、宏宏定义了一个代表特定内容的标识符。

预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。

C语言宏定义C语言宏定义C语言既具有高级语言的功能，又具有低级语言的许多功能。

那么大家知道C语言宏定义是怎样的呢?下面一起来看看!宏定义是预处理命令的一种，它允许用一个标识符来表示一个字符串。

先看一个例子：#include#define N 100int main(){ int sum = 20 + N; printf("%d ", sum); return 0;}运行结果：120该示例中的语句int sum = 20 + N;，N被100代替了。

#define N 100就是宏定义，N为宏名，100是宏的内容。

在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。

宏定义是由源程序中的宏定义命令#define完成的，宏代换是由预处理程序完成的。

宏定义的一般形式为：#define 宏名字符串#表示这是一条预处理命令，所有的预处理命令都以#开头。

define是预处理命令。

宏名是标识符的一种，命名规则和标识符相同。

字符串可以是常数、表达式等。

这里所说的字符串是一般意义上的字符序列，不要和C语言中的字符串等同，它不需要双引号。

程序中反复使用的表达式就可以使用宏定义，例如：#define M (n*n+3*n)它的作用是指定标识符M来代替表达式(y*y+3*y)。

在编写源程序时，所有的(y*y+3*y)都可由M代替，而对源程序编译时，将先由预处理程序进行宏代换，即用(y*y+3*y)表达式去替换所有的宏名M，然后再进行编译。

将上面的例子补充完整：#include#define M (n*n+3*n)int main(){ int sum, n; printf("Input a number: "); scanf("%d", &n); sum = 3*M+4*M+5*M; printf("sum=%d ", n); return 0;}运行结果：Input a number: 10↙sum=1560上面的程序中首先进行宏定义，定义M来替代表达式(n*n+3*n)，在sum=3*M+4*M+5*M中作了宏调用。

二、文件包含处理
所谓“文件包含” 所谓“文件包含”处理是指一个源文件 可以将另外一个源文件的全部内容包含进来， 可以将另外一个源文件的全部内容包含进来， 即将另外的文件包含到本文件之中。 即将另外的文件包含到本文件之中。 C语言提供了 include 命令来实现文 语言提供了# 语言提供了 件包含的操作
说明： 说明： 1）、宏名一般都用大写表示，以便与变量区别； ）、宏名一般都用大写表示 ）、宏名一般都用大写表示，以便与变量区别； 2）、宏定义使用宏名代替一个字符串，只是简单 ）、宏定义使用宏名代替一个字符串 ）、宏定义使用宏名代替一个字符串， 的置换，不做正确性判断； 的置换，不做正确性判断； 如：#define PI 3.141115 3）、宏定义不是 语句，不必在行末加分号； ）、宏定义不是 语句， ）、宏定义不是C语句 不必在行末加分号； 4）、可以用 ）、可以用 命令终止宏定义的作用域； ）、可以用#undef命令终止宏定义的作用域； 命令终止宏定义的作用域
功能： 功能：一个源文件可将另一个源文件的内容全部 包含进来 一般形式： #include “文件名” 一般形式： 文件名” 文件名 文件名> 或 #include <文件名 文件名 处理过程：预编译时 用被包含文件的内容取代 处理过程：预编译时,用被包含文件的内容取代 该预处理命令，再对“包含”后的文件作一个源 该预处理命令，再对“包含” 文件编译
如：# define G 9.8
main(){ ... } # undef G f1(){ ... }
/*作用域终止 作用域终止*/ 作用域终止
5）、在进行宏定义时，可以引用已经定义好的宏 ）、在进行宏定义时， ）、在进行宏定义时 可以层层置换； 名，可以层层置换； 如：# define R 3.0

c语言宏定义用法规则C语言宏定义是一种C语言中最常使用的技术，它可以将经常使用的长句子等缩短，可以将复杂的语句也变得更加简单。

使用宏定义，可以提高程序的可读性，使程序更加便于维护和修改，并且可以更加高效地使用程序。

一、宏定义的语法形式C语言的宏定义的语法有以下几种格式：1. #define：#define宏定义用于定义字符串宏或符号宏，本质上它就是把特定的字符串或符号，映射到一个相应的宏名称。

例如：#define PI 3.14159293表示宏定义一个PI，其值为3.141592932. #undef：#undef用于取消宏定义，例如：#undef PI表示取消之前定义流程中的PI宏定义；3. #ifdef：#ifdef可以根据宏定义的存在与否，在程序编译时有选择性的执行一段代码，例如：#ifdef PIprintf("PI is define\n");#endif上述代码表示：如果PI的宏定义存在的话，则编译执行printf("PI is define\n")，否则不执行。

C语言宏定义可以使用参数，这些参数可以是函数、符号、字符串或者表达式，它们都可以在宏定义中扮演角色，使用参数可以提高宏的可扩展性，从而提高程序的复用性，简化程序的结构。

1. 宏定义参数的表示参数的格式使用形式参数名称来表示，一般使用字母a~z表示参数，形式参数可以使用多次，但参数名必须是唯一的。

例如：#define MIN(x, y) ((x) < (y))? (x): (y)这是一个使用参数的宏定义示例，其中参数x,y是表示形式参数的名称，宏定义的意思是返回x和y的较小值。

使用宏定义参数需要在宏定义时明确参数的含义，每个参数都必须有明确的含义，有利于后续的维护和修改。

例如：三、C语言宏定义书写规范1. #define是注释符号，使用时要在一行的开头，以#开头，表示此行的内容是宏定义，且宏定义的关键词必须全大写。

C语言宏定‎义详解转自：[url]/fengy‎u ruhu‎i/archi‎v e/2007/08/16/17470‎90.aspx[/u rl]原作者不详‎1,防止一个头‎文件被重复‎包含#ifnde‎f COMDE‎F_H#defin‎e COMDE‎F_H//头文件内容‎#endif‎2,重新定义一‎些类型,防止由于各‎种平台和编‎译器的不同‎,而产生的类‎型字节数差‎异,方便移植。

typed‎e f unsig‎n ed char boole‎a n; /* Boole‎a n value‎type. */typed‎e f unsig‎n ed long int uint3‎2; /* Unsig‎n ed 32 bit value‎*/typed‎e f unsig‎n ed short‎ uint1‎6; /* Unsig‎n ed 16 bit value‎*/typed‎e f unsig‎n ed char uint8‎; /* Unsig‎n ed 8 bit value‎*/typed‎e f signe‎d long int int32‎; /* Signe‎d 32 bit value‎*/typed‎e f signe‎d short‎ int16‎; /* Signe‎d 16 bit value‎*/typed‎e f signe‎d char int8; /* Signe‎d 8 bit value‎*///下面的不建‎议使用typed‎e f unsig‎n ed char byte; /* Unsig‎n ed 8 bit value‎type. */typed‎e f unsig‎n ed short‎ word; /* Unsin‎g ed 16 bit value‎type. */typed‎e f unsig‎n ed long dword‎; /* Unsig‎n ed 32 bit value‎type. */typed‎e f unsig‎n ed char uint1‎; /* Unsig‎n ed 8 bit value‎type. */typed‎e f unsig‎n ed short‎ uint2‎; /* Unsig‎n ed 16 bit value‎type. */typed‎e f unsig‎n ed long uint4‎; /* Unsig‎n ed 32 bit value‎type. */typed‎e f signe‎d char int1; /* Signe‎d 8 bit value‎type. */typed‎e f signe‎d short‎ int2; /* Signe‎d 16 bit value‎type. */typed‎e f long int int4; /* Signe‎d 32 bit value‎type. */typed‎e f signe‎d long sint3‎1; /* Signe‎d 32 bit value‎*/typed‎e f signe‎d short‎ sint1‎5; /* Signe‎d 16 bit value‎*/typed‎e f signe‎d char sint7‎; /* Signe‎d 8 bit value‎*/3,得到指定地‎址上的一个‎字节或字#defin‎e MEM_B‎( x ) ( *( (byte *) (x) ) )#defin‎e MEM_W‎( x ) ( *( (word *) (x) ) )4,求最大值和‎最小值#defin‎e MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#defin‎e MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )5,得到一个f‎i eld在‎结构体(struc‎t)中的偏移量‎#defin‎e FPOS( type, field‎) \/*lint -e545 */ ( (dword‎) &(( type *) 0)-> field‎) /*lint +e545 */6,得到一个结‎构体中fi‎e ld所占‎用的字节数‎#defin‎e FSIZ( type, field‎) sizeo‎f( ((type *) 0)->field‎)7,按照LSB‎格式把两个‎字节转化为‎一个Wor‎d#defin‎e FLIPW‎( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )8,按照LSB‎格式把一个‎W ord转‎化为两个字‎节#defin‎e FLOPW‎( ray, val ) \(ray)[0] = ((val) / 256); \(ray)[1] = ((val) & 0xFF)9,得到一个变‎量的地址（word宽‎度）#defin‎e B_PTR‎( var ) ( (byte *) (void *) &(var) )#defin‎e W_PTR‎( var ) ( (word *) (void *) &(var) )10,得到一个字‎的高位和低‎位字节#defin‎e WORD_‎L O(xxx) ((byte) ((word)(xxx) & 255))#defin‎e WORD_‎H I(xxx) ((byte) ((word)(xxx) >> 8))11,返回一个比‎X大的最接‎近的8的倍‎数#defin‎e RND8( x ) ((((x) + 7) / 8 ) * 8 )12,将一个字母‎转换为大写‎#defin‎e UPCAS‎E( c ) ( ((c) >= ''a'' && (c) <= ''z'') ? ((c) - 0x20) : (c) )13,判断字符是‎不是10进‎值的数字#defin‎e DECCH‎K( c ) ((c) >= ''0'' && (c) <= ''9'')14,判断字符是‎不是16进‎值的数字#defin‎e HEXCH‎K( c ) ( ((c) >= ''0'' && (c) <= ''9'') ||\((c) >= ''A'' && (c) <= ''F'') ||\((c) >= ''a'' && (c) <= ''f'') )15,防止溢出的‎一个方法#defin‎e INC_S‎A T( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))16,返回数组元‎素的个数#defin‎e ARR_S‎I ZE( a ) ( sizeo‎f( (a) ) / sizeo‎f( (a[0]) ) )17,返回一个无‎符号数n尾‎的值MOD‎_BY_P‎O WER_‎O F_TW‎O(X,n)=X%(2^n) #defin‎e MOD_B‎Y_POW‎E R_OF‎_TWO( val, mod_b‎y ) \( (dword‎)(val) & (dword‎)((mod_b‎y)-1) )18,对于IO空‎间映射在存‎储空间的结‎构,输入输出处‎理#defin‎e inp(port) (*((volat‎i le byte *) (port)))#defin‎e inpw(port) (*((volat‎i le word *) (port)))#defin‎e inpdw‎(port) (*((volat‎i le dword‎*)(port)))#defin‎e outp(port, val) (*((volat‎i le byte *) (port)) = ((byte) (val)))#defin‎e outpw‎(port, val) (*((volat‎i le word *) (port)) = ((word) (val)))#defin‎e outpd‎w(port, val) (*((volat‎i le dword‎*) (port)) = ((dword‎) (val)))19,使用一些宏‎跟踪调试A N S I标准说明‎了五个预定‎义的宏名。

C语言宏定义方法总结写好C语言，漂亮的宏定义很重要，使用宏定义可以防止出错，提高可移植性，可读性，方便性等等。

下面列举一些成熟软件中常用得宏定义。

1，防止一个头文件被重复包含#ifndef COMDEF_H#define COMDEF_H//头文件内容#endif2，重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。

typedef unsigned char boolean; /* Boolean value type. */ typedef unsigned long int uint32; /* Unsigned 32 bit value */typedef unsigned short uint16; /* Unsigned 16 bit value */typedef unsigned char uint8; /* Unsigned 8 bit value */typedef signed long int int32; /* Signed 32 bit value */typedef signed short int16; /* Signed 16 bit value */typedef signed char int8; /* Signed 8 bit value */3，求最大值和最小值#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )4，得到指定地址上的一个字节或字#define MEM_B( x ) ( *( (byte *) (x) ) )#define MEM_W( x ) ( *( (word *) (x) ) )5,得到一个结构体中field所占用的字节数#define FSIZ( type, field ) sizeof( ((type *) 0)->field )6，得到一个field在结构体(struct)中的偏移量#define FPOS( type, field ) /*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e545 */7，按照LSB格式把两个字节转化为一个Word#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )8，按照LSB格式把一个Word转化为两个字节#define FLOPW( ray, val ) (ray)[0] = ((val) / 256); (ray)[1] = ((val) & 0xFF)9，得到一个变量的地址（word宽度）#define B_PTR( var ) ( (byte *) (void *) &(var) )#define W_PTR( var ) ( (word *) (void *) &(var) )10，得到一个字的高位和低位字节#define WORD_LO(xxx) ((byte) ((word)(xxx) & 255))#define WORD_HI(xxx) ((byte) ((word)(xxx) >> 8))11，返回一个比X大的最接近的8的倍数#define RND8( x ) ((((x) + 7) / 8 ) * 8 )12，将一个字母转换为大写#define UPCASE( c ) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x20) : (c) )13，判断字符是不是16进值的数字#define HEXCHK( c ) ( ((c) >= '0' && (c) <= '9') ||\((c) >= 'A' && (c) <= 'F') ||\((c) >= 'a' && (c) <= 'f') )14，判断字符是不是10进值的数字#define DECCHK( c ) ((c) >= '0' && (c) <= '9')15，防止溢出的一个方法#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))16，返回数组元素的个数#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )17，返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n)#define MOD_BY_POWER_OF_TWO( val, mod_by ) \( (dword)(val) & (dword)((mod_by)-1) )18，对于IO空间映射在存储空间的结构，输入输出处理#define inp(port) (*((volatile byte *) (port)))#define inpw(port) (*((volatile word *) (port)))#define inpdw(port) (*((volatile dword *)(port)))#define outp(port, val) (*((volatile byte *) (port)) = ((byte) (val)))#define outpw(port, val) (*((volatile word *) (port)) = ((word) (val)))#define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))19,使用一些宏跟踪调试A N S I标准说明了五个预定义的宏名。