宏定义的优缺点
通俗易懂地介绍一下什么是宏
通俗易懂地介绍一下什么是宏
“宏”在许多领域都有应用，但在这里我假设你是在谈论编程或软件中的“宏”。
在编程中，宏是一种代码块，可以用来定义一组操作或命令。
当你在程序中调用这个宏时，它就会执行这些预先定义的操作或命令。
宏可以使代码更加简洁、可读性更好，并且可以重复使用。
例如，假设你在编写一个处理数字的程序，你经常需要使用到求平方的代码。
你可以定义一个宏来完成这个操作，而不是每次都写出完整的求平方的代码。
宏也有一些缺点。
例如，调试可能会比较困难，因为错误可能出现在宏的内部，但可能在宏调用处出现。
此外，过度使用宏可能会导致代码变得难以阅读和理解。
在某些编程语言中，如C和C++，宏可以通过预处理器指令定义，如`#define`。
在其他语言中，如Python和JavaScript，宏的概念可能并不明显，但可以通过函数、模块或其他方式实现类似的功能。
总之，宏是一种预定义的代码块，可以在程序中重复使用，以简化代码和提高效率。
宏定义的优缺点
如果某个常量或者函数名很长的时候可以用宏定义做替换，这样的话程序也会比较美观一点，可读性也大大增强了。
其实在用VC编程的时候就会遇到很多宏定义，尤其是类似“LONG，LPCTSTR”等等之类的，它们属于微软的自定义类型，但其本质上还是属于C/C++里面的那几个标准类型。
那用宏定义到底有什么好处呢？先来看一下宏的定义：用#define命令将一个指定的标识符（即宏名）来代表一个字符串。
它的一般型式为：#define 表示符字符串#define命令属于“预处理命令”中的一种。
它是由C++统一规定的，但非C++语言本身的组成部分，由于编译器无法识别他们，不能对其直接进行编译。
预处理过程必须在对程序进行词法与语义分析、代码生成与优化等通常的编译过程之前进行，经过预处理后的程序不再包含之前的预处理命令。
C++提供的预处理功能除了宏定义之外，还有以下两个:1. 文件包含（#include命令）2. 条件编译（#ifdef ….#def …. #endif命令）#define命令还可以定义带参数的宏定义，用于实现某种特定的功能，其定义型式为：#define 宏名(参数列表) 字符串例如：#define Sum(a,b) a+b不过，由于C++增加了内联函数(inline)，实现起来比带参数的宏更方便，这样的宏在C++中已经很少使用了。
接下来看看宏都有什么好处：1. 提高了程序的可读性，同时也方便进行修改；2. 提高程序的运行效率：使用带参的宏定义既可完成函数调用的功能，又能避免函数的出栈与入栈操作，减少系统开销，提高运行效率；3.宏是由预处理器处理的，通过字符串操作可以完成很多编译器无法实现的功能。
比如##连接符。
但是它也有自己的缺点：1. 由于是直接嵌入的，所以代码可能相对多一点；2. 嵌套定义过多可能会影响程序的可读性，而且很容易出错；3. 对带参的宏而言，由于是直接替换，并不会检查参数是否合法，存在安全隐患。
C语言宏的特殊用法和几个坑（转）
C语⾔宏的特殊⽤法和⼏个坑（转）总结⼀下C语⾔中宏的⼀些特殊⽤法和⼏个容易踩的坑。
由于本⽂主要参考GCC⽂档，某些细节（如宏参数中的空格是否处理之类）在别的编译器可能有细微差别，请参考相应⽂档。
宏基础宏仅仅是在C预处理阶段的⼀种⽂本替换⼯具，编译完之后对⼆进制代码不可见。
基本⽤法如下：1. 标⽰符别名#define BUFFER_SIZE 1024预处理阶段，foo = (char *) malloc (BUFFER_SIZE);会被替换成foo = (char *) malloc (1024);宏体换⾏需要在⾏末加反斜杠\#define NUMBERS 1, \2, \3预处理阶段int x[] = { NUMBERS };会被扩展成int x[] = { 1, 2, 3 };2. 宏函数宏名之后带括号的宏被认为是宏函数。
⽤法和普通函数⼀样，只不过在预处理阶段，宏函数会被展开。
优点是没有普通函数保存寄存器和参数传递的开销，展开后的代码有利于CPU cache的利⽤和指令预测，速度快。
缺点是可执⾏代码体积⼤。
#define min(X, Y) ((X) < (Y) ? (X) : (Y))y = min(1, 2);会被扩展成y = ((1) < (2) ? (1) : (2));宏特殊⽤法1. 字符串化(Stringification)在宏体中，如果宏参数前加个#，那么在宏体扩展的时候，宏参数会被扩展成字符串的形式。
如：#define WARN_IF(EXP) \do { if (EXP) \fprintf (stderr, "Warning: " #EXP "\n"); } \while (0)WARN_IF (x == 0);会被扩展成：do { if (x == 0)fprintf (stderr, "Warning: " "x == 0" "\n"); }while (0);这种⽤法可以⽤在assert中，如果断⾔失败，可以将失败的语句输出到反馈信息中2. 连接(Concatenation)在宏体中，如果宏体所在标⽰符中有##，那么在宏体扩展的时候，宏参数会被直接替换到标⽰符中。
c语言宏的用法
c语言宏的用法C语言中的宏（macro）是一种预处理指令，用于在编译过程中对程序进行简单的文本替换。
宏定义的格式一般为`#define`，后跟宏的名称和替换的文本。
宏的使用可以简化代码书写、提高代码的可读性和可维护性。
宏的使用可以提高代码的可读性，减少重复的代码。
例如，可以定义一个用于交换两个变量的宏`#define SWAP(a, b) {int tmp; tmp=a; a=b; b=tmp;}`，使用时只需写`SWAP(某, y)`，宏会被替换为实际的交换代码。
这样可以避免多次编写相同的交换代码。
宏还可以帮助实现条件编译，根据条件在编译时选择是否包含某段代码。
例如，可以定义一个用于调试输出的宏：```#ifdef DEBUG#define PRINT_DEBUG(msg) printf("Debug: %s\n", msg)#else#define PRINT_DEBUG(msg)#endif```当定义了`DEBUG`宏时，可以使用`PRINT_DEBUG("message")`输出调试信息；否则，调试输出语句会被为空替换。
通过宏的条件编译，可以方便地在调试和发布版本之间切换。
宏的使用也需注意一些潜在的问题。
首先，宏的替换是简单的文本替换，可能会导致意外的结果。
例如，定义一个用于计算立方的宏`#define CUBE(某) 某某某某某`，使用时`y = CUBE(2 + 3)`会被替换为`y =2 +3 某 2 + 3 某 2 + 3`，导致错误的计算结果。
这种问题可以通过使用括号来解决，即`#define CUBE(某) ((某) 某 (某) 某 (某))`。
其次，宏的使用会增加代码的长度和复杂度，可能会降低代码的可读性和可维护性。
宏替换发生在编译阶段，生成的代码可能难以阅读和调试。
为了避免宏的使用被滥用，可以合理使用宏，避免定义过长或过于复杂的宏。
宏定义
一、#define的基本用法#define是C语言中提供的宏定义命令，其主要目的是为程序员在编程时提供一定的方便，并能在一定程度上提高程序的运行效率，但学生在学习时往往不能理解该命令的本质，总是在此处产生一些困惑，在编程时误用该命令，使得程序的运行与预期的目的不一致，或者在读别人写的程序时，把运行结果理解错误，这对 C语言的学习很不利。
1 #define命令剖析1.1 #define的概念#define命令是C语言中的一个宏定义命令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。
该命令有两种格式：一种是简单的宏定义，另一种是带参数的宏定义。
(1)简单的宏定义：#define<宏名><字符串>例：#define PI 3.1415926(2) 带参数的宏定义#define<宏名>(<参数表>)<宏体>例：#define A(x) x一个标识符被宏定义后，该标识符便是一个宏名。
这时，在程序中出现的是宏名，在该程序被编译前，先将宏名用被定义的字符串替换，这称为宏替换，替换后才进行编译，宏替换是简单的替换。
1.2 宏替换发生的时机为了能够真正理解#define的作用，让我们来了解一下对C语言源程序的处理过程。
当我们在一个集成的开发环境如Turbo C中将编写好的源程序进行编译时，实际经过了预处理、编译、汇编和连接几个过程。
其中预处理器产生编译器的输出，它实现以下的功能：（1）文件包含可以把源程序中的#include 扩展为文件正文，即把包含的.h文件找到并展开到#include 所在处。
（2）条件编译预处理器根据#if和#ifdef等编译命令及其后的条件，将源程序中的某部分包含进来或排除在外，通常把排除在外的语句转换成空行。
（3）宏展开预处理器将源程序文件中出现的对宏的引用展开成相应的宏定义，即本文所说的#define的功能，由预处理器来完成。
单片机中宏定义
单片机中宏定义在单片机编程中，宏定义是指使用预处理指令#define定义的常量、变量、函数等。
宏定义可以在代码中多次使用，提高编写代码的效率。
宏定义的基本语法格式如下：#define 宏名值在定义宏时，宏名和值之间需要用空格隔开。
值可以是数值、字符、字符串等。
例如：#define LED1 1 //定义LED1为1#define SUM(a,b) ((a)+(b)) //定义求和函数SUM(a,b)使用宏时可以直接调用宏名，编译器会自动将宏名替换成所定义的值。
例如：port = LED1; //将端口port设为LED1sum = SUM(10,20); //计算10和20的和，结果为30宏定义在单片机编程中具有重要作用，可以大大提高编程效率和代码的可读性。
一、宏定义的使用1.定义常量在单片机编程中，常量是指值不能被改变的变量，一般使用宏定义来定义常量。
如下面的代码：#define LED1 0x01 //定义LED1为0x01#define LED2 0x02 //定义LED2为0x02#define LED3 0x04 //定义LED3为0x04这样就可以方便地在代码中使用这些常量，例如：P0 = LED1 | LED2; //将P0口的LED1和LED2同时亮起来2.定义函数调用函数时可以使用宏名来代替函数名，例如：LED_ON(); //LED_ON函数被替换成P1 = 0x01;LED_OFF(); //LED_OFF函数被替换成P1 = 0x00;#define MAX 100 //定义MAX为100num = MAX; //将num变量设为MAX的值，即100#define BUF_SIZE 20 //定义BUF_SIZE为20int buf[BUF_SIZE]; //定义buf数组，大小为BUF_SIZEbuf[0] = 0x01; //将buf数组的第一个元素设为0x01二、宏定义的注意事项1.宏名一般要大写为了方便识别和区分，宏名一般使用大写字母来表示，例如：2.宏定义不能被修改一旦定义了宏，不能修改宏定义的值，否则会产生意想不到的后果。
C语言中宏、函数和Enum的优与劣
Ｔｈｅ Ａｄｖ ｎ ａ ｅ ａ ｄ Ｄｉａ ａ ａ ｅ ｏ ａ ｒ Ｆｕｎ ｔｏ ｎｄ Ｅｎ ａ ｔ ｇ ｎ ｓ ｄｖ ｎｔ ｇ ｆＭ ｃ ｏ、 ｃ ｉ ｎ ａ ｕｍ ｉ Ｃ ｎ
Ｌａ ｕａ ｅ ｎｇ ｇ
Ｃ Ｎ Ｓ ａ ｊｎ， Ｉ Ｆ ｎ ｘａ ＨＥ Ｇ ｈ ｏａ Ｌ Ｕ ｅ ｇ ｉ
电脑 编 程技 巧 与维 护
Ｃ语 言 中宏 、 函数 和 Ｅ ｕ 的优 与劣 ｎｍ
程 绍君 ，刘凤 霞
（ 宁 省北 票 市 职 教 中 心 ，北 票 １２ ０ ） 辽 ２ １０ 摘 要 ： 从 Ｃ语 言 中预 处理 、 宏 的基 本 概 念 和应 用 出发 ，对 宏 、函 数 和 ｅｕ 定 义 的枚 举 常 量 在 程 序 设 计 时是 否 方 ｎｍ
ｄ ｅ ｅ ｈ ｒ ｔｅ ｔ ｎｔａ ｐｐｉ ａｉｎ ｏ ｃ ｏ ｎ ｒ ａ ｅ ｔ ｅ ａ ｌｔ ｆｐ ｏ ｒ ｍ ｓｇ ｎｇ ｎ ｐｕ ｐ ｅ ｏ ｏ ｏ ｉａ ｎ ｈ ｅ ｐ ｎ ｔｅ ｐ ｅｒ ａｍｅ ｎｄ ａ ｌｃ ｔ ｆＭａ ｒ ，ｉ ｃ ｅ ｓ ｈ ｂｉ ｙ ｏ ｒ ｇ ａ ｄｅ ｉｎｉ ，ｏ ｒ ｏｓ ｆｃ ｎｓ ｌｄ ｔ ｇ ｔ ｅ ｏ ｉ ｉ
ｂ ｓｃｋ ｏ ｌ ｄ ｅ ｒ ｓ ｌ ｉｇ ｔ ｅ ｐ ａｉ ａ ｒ ｂ ｅ ． ａ ｉ ｎ ｗ ａ ｇ ， ｅ ｏｖ ｎ ｒ ｔ ｌｐ ｏ ｌ ｍｓ ｈ ｃ
Ｋｅ ｒ ｓ Ｃ ｌｎ ｕ ｇ ｐｅｒａｍｅ ｔ； ｃｏ ｙｗｏ ｄ ： ａ ｇ ａ ｅ； ｒｔ ｔ ｎ Ｍａ ｒ ｅ
｛
ｉｔｘ， ｎ ｙ；
ｘ ＝ ５：
此 时 ，宏 和常量标识符 已用相应 的代码和值代 替 。如果 源代
码 中包 含条 件 预 处理 指 令 （ 舟ｆ，预 处 理 程 序将 先判 断条 件 ， 如 ｉ ）
c语言 宏定义
c语言宏定义C言是一门通用的面向过程的编程语言，它既能够在小型计算机上运行，也能够在大型计算机上运行。
C言拥有极高的复杂性和丰富的语言特性，其中一种重要的特性就是“宏定义”。
本文将讨论 C言中的宏定义，以分析它们的用法、优点和缺点。
宏定义是 C言中一种重要的特性，它用于替换程序中的标识符和特定的常量。
宏定义是一种特殊的文本替换技术，它可以在编译时替换掉程序中与宏定义对应的标识符或常量。
宏定义可以有效地提高程序的可读性，并使程序易于维护和修改。
宏定义的语法非常简单，它的格式如下：#define称容在这里，“#define”是宏定义指令，名称是用于定义宏的标识符，而内容则是用于替换的代码。
宏定义的使用非常广泛，它可以用来定义常量、定义函数、定义算法实现等等。
例如，可以使用宏定义来定义一个常量：# define PI 3.14这里，PI一个标识符，而 3.14是它的内容，因此在程序中所有的 PI会被替换为 3.14。
宏定义还可以用来定义函数。
下面是一个简单的函数宏定义： #define MAX(X, Y) ((X) > (Y) ? (X) : (Y))在这里，MAX一个函数的标识符，当程序中出现 MAX(X, Y)，就会被替换为 ((X) > (Y) ? (X) : (Y))。
此外，宏定义还可以用来实现算法。
例如，可以用宏定义实现快速排序算法：#define swap(X, Y) {int temp = X; X = Y; Y = temp;} 在这里，swap一个标识符，它用于替换参数 X Y值。
宏定义具有许多优点，最为明显的就是简化程序的编写。
例如，一个函数用它来实现快速排序可能需要几十行的代码，但是使用宏定义只需要几行就可以实现。
另外，使用宏定义可以提高程序的可读性，让程序更容易被理解和维护。
然而，宏定义也有一些缺点。
首先，由于宏定义在编译时进行替换，因此它会导致程序的编译速度变慢，一些复杂的宏定义也可能导致程序运行变慢。
quartus 宏编译
Quartus宏编译介绍Quartus宏编译是指在Quartus Prime软件中使用宏定义来进行编译的过程。
宏定义是一种预处理指令，用于在编译过程中对代码进行替换和扩展，从而提高代码的复用性和可读性。
在Quartus中，宏定义可以用于定义常量、函数、模块、端口等，以及进行条件编译和代码调试。
宏定义的语法在Quartus中，宏定义使用define关键字进行定义，其语法如下：`define 宏名称值其中，宏名称是宏的名称，可以是任意合法的标识符；值是宏的取值，可以是常量、表达式或字符串。
宏定义的使用宏定义可以在代码的任何地方使用，使用方法为在宏名称前加上宏参数，如下所示：`宏名称在编译过程中，Quartus会将宏名称替换为其对应的值。
例如，定义了一个宏WIDTH 8，在代码中使用WIDTH时，Quartus会将其替换为8。
宏定义的优点宏定义在Quartus编译中具有以下优点： 1. 提高代码的复用性：通过宏定义，可以将一些常用的代码片段定义为宏，以便在其他地方进行复用。
2. 提高代码的可读性：通过宏定义，可以将一些常量和函数的含义直接体现在代码中，提高了代码的可读性。
3. 简化代码的修改：通过宏定义，可以将一些常用的参数集中管理，当需要修改这些参数时，只需修改宏定义即可，无需修改所有使用到该参数的地方。
4. 方便进行条件编译：通过宏定义，可以方便地进行条件编译，根据不同的条件来编译不同的代码。
宏定义的注意事项在使用宏定义时，需要注意以下几点： 1. 宏定义的作用范围：宏定义的作用范围是从定义宏的位置开始，到文件末尾或下一个undef指令为止。
因此，在使用宏定义时，需要确保宏定义在使用之前已经被定义。
2. 宏定义的命名规则：宏名称必须是合法的标识符，且不能与其他标识符冲突。
通常，宏名称使用全大写字母来表示，以便与其他标识符区分开。
3. 宏定义的值：宏的值可以是任意合法的表达式，但需要确保表达式的结果是常量。
C语言知识总结——宏，枚举，结构体，共用体
C语言知识总结——宏，枚举，结构体，共用体1、define宏定义以#号开头的都是编译预处理指令，它们不是C语言的成分，但是C程序离不开它们，#define用来定义一个宏，程序在预处理阶段将用define定义的来内容进行了替换。
因此在程序运行时，常量表中并没有用define定义的常量，系统不为它分配内存。
define定义的常量，预处理时只是直接进行了替换，，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。
，因此在编译时它不对宏的定义进行检查，作用域不影响对常量的访问。
它的常量值只能是字符串或数字。
该命令有两种格式:一种是简单的常量宏定义, 另一种是带参数的宏定义。
不带参数的宏：#define< 名字 >< 值 > 要注意，没有结尾的分号，因为不是C的语句，名字必须是一个单词，值可以是各种东西，宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。
如有错误，只能在编译已被宏展开后的源程序时发现。
注意.宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。
宏定义其作用域为宏定义命令起到源程序结束。
如要终止其作用域可使用#undef命令带参数的宏：像函数的宏，一般的定义形式：带参宏定义的一般形式为：「#define 宏名」（形参表）字符串，也是没有结尾的分号，可以带多个参数，#define NB（a，b）((a)>(b)?(b):(a)), 也可以组合（嵌套）使用其他宏，注意带参数宏的原则一切都要有括号，参数出现的每个地方都要有括号。
带参数的宏在大型的程序的代码中使用非常普遍，在#和##这两个运算符的帮助下可以很复杂，如“产生函数”，但是有些宏会被inline函数代替（C++的函数）使用宏好处：“提高运行效”。
定义的标识符不占内存，只是一个临时的符号，预编译后这个符号就不存在了。
const与#define的优缺点？
const与#define的优缺点？1.define由预处理程序处理，const由编译程序处理2.#define不分内存，因为它是预编译指令，编译前进行了宏替换。
const 不一定？某种说法，Const常量是占有内存的被“冻结”了的变量3.const定义常量是有数据类型的，这样const定义的常量编译器可以对其进行数据静态类型安全检查，而#define宏定义的常量却只是进行简单的字符替换，没有类型安全检查，且有时还会产生边际效应4.有些调试程序可对const进行调试，但不对#define进行调试。
5.const在编译期间会计算其值,而define不会6 当定义局部变量时，const作用域仅限于定义局部变量的函数体内。
但用#define时其作用域不仅限于定义局部变量的函数体内，而是从定义点到整个程序的结束点。
但也可以用#undef取消其定义从而限定其作用域范围。
只用const定义常量，并不能起到其强大的作用。
const还可修饰函数形式参数、返回值和类的成员函数等。
从而提高函数的健壮性。
因为const修饰的东西能受到c/c++的静态类型安全检查机制的强制保护，防止意外的修改。
二、const与c++看了传递方式后我们继续来谈“const只能用于修饰输入参数”的情况。
当输入参数用“值传递”方式时，我们不需要加const修饰，因为用值传递时，函数将自动用实际参数的拷贝初始化形式参数，当在函数体内改变形式参数时，改变的也只是栈上的拷贝而不是实际参数。
但要注意的是，当输入参数为ADT/UDT（用户自定义类型和抽象数据类型）时，应该将“值传递”改为“const &传递”，目的可以提高效率。
例如：void fun(A a);//效率底。
函数体内产生A类型的临时对象用于复制参数 a，但是临时对象的//构造、复制、析构过程都将消耗时间。
void fun(A const &a);//提高效率。
用“引用传递”不需要产生临时对象，省了临时对象的//构造、复制、析构过程消耗的时间。
C语言#define用法总结
C语言#define用法总结黄海涛，2012-3-3如果你还在为使用#define而迷茫，那请阅读这篇文章；如果读完之后你还在迷茫，那请哪天心情好了，再回来读一遍。
:)欢迎跟着我的思路走……一、概述1、宏定义在C语言中，以#开头的为预处理命令。
定义形式：2、本质其本质是：使用宏定义中的字符串替换(Substitution)宏名。
这只是一种简单的代换，预处理程序对它不作任何检查。
如有错误，只能在编译已被宏展开后的源程序时发现。
3、替换时机预处理是指在进行编译的第一遍扫描(词法扫描和语法分析)之前所作的工作。
由预处理程序负责完成。
在源程序被编译之前，宏替换已经完成，其流程如下：源程序→预处理程序→预处理后的源程序→编译器4、作用域其作用域为宏定义命令起到源程序结束。
如要终止其作用域可使用# undef命令。
5、优缺点▲优点：宏定义使用得当，可以防止出错，提高可移植性，可读性等等；减少函数调用的开销。
▲缺点：可能存在参数副作用；展开后可能比函数调用开销更大。
※规则一：保证在宏替换之后不会发生错误。
二、无参宏定义1、定义的一般形式#define identifier token-sequence#define 标识符字符串2、简单常量●约束1：宏名通常采用易读大写字母表示。
●约束2：宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起替换。
●约束3：宏名在源程序中若用引号引起来，则预处理程序不对其作宏替换。
如：3、字符串为表达式※规则二：无参宏定义中字符串为表达式(即含有运算符)，必须加小括号()。
可见，有括号与无括号差别很大，请小心加括号，保证展开后是你所期望的。
参考规则一。
4、5、6三、带参宏定义对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。
1、带参宏定义的一般形式为：#define identifier(identifier-list) token-sequence#define 宏名(形参表) 字符串在字符串中含有各个形参，形参是标识符。
C语言常用宏定义技巧
#define MEM_W(x) (*((uint16 *)(x)))
注：类似于这种有多个字符串组成的宏定义一定要注意加上“（）”，因为我们知道宏定义只是一种简单的字符替换功能。
4. 求最大值和最小值：
#define MAX(x,y) (((x)>(y))?(x):(y))
constructor
13. 冒泡排序算法的时间复杂度是什么？
O(n^2)
14. 写出float x 与“零值”比较的if语句。
if(x>0.000001&&x<-0.000001)
16. Internet采用哪种网络协议？该协议的主要层次结构？
tcp/ip 应用层/传输层/网络层/数据链路层/物理层
{
FLOPW(ray,val)
}
else
Hale Waihona Puke { } 8. 得到一个变量的地址：
#define B_PTR(var) ((byte *)(void *)&(var))
#define W_PTR(var) ((word *)(void *)&(var))
C语言常用宏定义技巧
2
推荐 C语言常用宏定义技巧
用C语言编程，宏定义是个很重要的编程技巧。用好了宏定义，它可以增强程序的可读性、可移植性、方便性、灵活性等等。
1. 防止一个头文件被重复包含：
#ifndef COMDEF_H
#define COMDEF_H
#define FLOPW(ray,val) do{ (ray)[0]=((val)/256); (ray)[1] =((val)&0xFF);}while(0)
函数式宏定义与普通函数的区别
函数式宏定义与普通函数的区别在Ｃ及C++语⾔中允许⽤⼀个标识符来表⽰⼀个字符串，称为宏，该字符串可以是常数、表达式、格式串等。
在编译预处理时，对程序中所有出现的“宏名”，都⽤宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。
宏定义是由源程序中的宏定义命令完成的。
宏代换是由预处理程序⾃动完成的。
若字符串是表达式，我们称之为函数式宏定义，那函数式宏定义与普通函数有什么区别呢？我们以下⾯两⾏代码为例，展开描述：函数式宏定义：#define MAX(a,b) ((a)>(b)?(a):(b))普通函数：MAX(a,b) { return a>b?a:b;}（1）函数式宏定义的参数没有类型，预处理器只负责做形式上的替换，⽽不做参数类型检查，所以传参时要格外⼩⼼。
（2）调⽤真正函数的代码和调⽤函数式宏定义的代码编译⽣成的指令不同。
如果MAX是个普通函数，那么它的函数体return a > b ? a : b; 要编译⽣成指令，代码中出现的每次调⽤也要编译⽣成传参指令和call指令。
⽽如果MAX是个函数式宏定义，这个宏定义本⾝倒不必编译⽣成指令，但是代码中出现的每次调⽤编译⽣成的指令都相当于⼀个函数体，⽽不是简单的⼏条传参指令和call指令。
所以，使⽤函数式宏定义编译⽣成的⽬标⽂件会⽐较⼤。
（3）函数式宏定义要注意格式，尤其是括号。
如果上⾯的函数式宏定义写成 #define MAX(a, b) (a>b?a:b)，省去内层括号，则宏展开就成了k = (i&0x0f>j&0x0f?i&0x0f:j&0x0f)，运算的优先级就错了。
同样道理，这个宏定义的外层括号也是不能省的。
若函数中是宏替换为 ++MAX(a,b)，则宏展开就成了 ++(a)>(b)?(a):(b)，运算优先级也是错了。
（4）若函数参数为表达式，则普通函数的调⽤与函数式宏定义的替换过程是不⼀样的。
define宏定义函数
define宏定义函数宏定义是C/C++语言中一种预处理指令，可以用来对代码中的固定值或者复杂表达式进行替换，减少代码编写时的重复性问题，提高代码重用性和可读性。
宏定义的语法格式为：#define 宏名称宏替换文本其中，宏名称是自定义的标识符，宏替换文本可以是单个字符、数值、表达式、函数调用等。
宏定义的有效范围是从定义处到文件末尾或者遇到#undef指令为止。
宏定义的优点在于，它可以让程序员在代码中使用一个短小的名称来代替一个复杂的表达式或者语句，从而提高代码可读性和可维护性。
同时，在编译时，编译器会将所有使用到宏定义的代码中的宏名称展开成对应的宏替换文本，从而使得程序的运行效率得到提高。
宏定义的应用场景非常广泛，例如：1.定义常量：可以使用#define宏定义，将一个固定的值定义为一个常量，方便在代码中多次使用。
例如：#define PI 3.14这样在后续的代码中就可以使用PI来代替3.14，提高可读性和可维护性。
2.定义函数：宏定义可以定义一些简单的函数。
例如：#define max(a,b) ((a)>(b)?(a):(b))这个宏定义表示求取两个数中的最大值，在后续的代码中可以用max(a,b)来代替((a)>(b)?(a):(b))，达到简洁、明了的效果。
3.定义缩写：在代码中，有时需要使用一些比较长的名称来表示一些事物，为了方便使用，可以用宏定义来缩写这些名称，在代码中使用时可以提高可读性和代码规范性。
例如：#define HTTP_STATUS_OK 200#define HTTP_STATUS_BAD_REQUEST 4004.条件编译：宏定义可以用于条件编译，在程序中加入一些特别的代码，根据不同的编译选项选择编译或者不编译这些代码。
例如：#ifdef DEBUGprintf("error message: %s\n", error_msg);#endif如果在编译程序的时候加上了-DDEBUG选项，则会将上述代码编译到程序中，否则会被忽略。
枚举使用宏定义
枚举使用宏定义宏定义是C语言中一种非常重要的技术，它可以将一个值或一段代码片段定义为一个标识符，以便在程序的其他地方使用。
枚举是用宏定义时常见的一种用法，它可以用于定义一组相关的常量，方便程序的编写和维护。
枚举通常由程序员在头文件中创建，并以宏的形式定义。
例如：```#define SEASON_SPRING 1#define SEASON_SUMMER 2#define SEASON_AUTUMN 3#define SEASON_WINTER 4```在上述代码中，我们通过宏定义了四个季节的常量。
这样一来，在程序的其他地方可以直接使用这些宏定义，而不需要每次都写明具体的常量值。
枚举宏定义的优点之一是可读性强。
通过使用宏定义，程序员可以在代码中直接使用可读性强的名称，而不是具体的数值。
这样一来，代码可读性更高，更易于理解和维护。
另外，如果需要修改某个常量值，只需在宏定义处修改一次即可，而不需要在程序的各个地方进行修改。
我将通过一个具体的例子来说明枚举宏定义的使用。
假设我们需要编写一个程序，根据用户输入的数字判断对应的星期几，并打印出来。
这时，我们可以使用枚举宏定义来定义星期几的常量。
例如：```#define WEEKDAY_MONDAY 1#define WEEKDAY_TUESDAY 2#define WEEKDAY_WEDNESDAY 3#define WEEKDAY_THURSDAY 4#define WEEKDAY_FRIDAY 5#define WEEKDAY_SATURDAY 6#define WEEKDAY_SUNDAY 7```有了以上的枚举宏定义，我们可以将用户输入的数字与常量进行比较，从而确定对应的星期几。
例如：```cint main() {int input;printf("请输入一个数字：");scanf("%d", &input);switch(input) {case WEEKDAY_MONDAY:printf("星期一\n"); break;case WEEKDAY_TUESDAY: printf("星期二\n"); break;case WEEKDAY_WEDNESDAY: printf("星期三\n"); break;//其他星期几的判断... default:printf("输入错误\n"); break;}return 0;}```在上述代码中，我们使用了switch语句来判断用户输入的数字与哪个常量匹配，并输出对应的星期几。
宏定义的优缺点
宏定义是C提供的三种预处理功能的其中一种，这三种预处理包括：宏定义、文件包含、条件编译编辑本段1.不带参数的宏定义：宏定义又称为宏代换、宏替换，简称“宏”。
格式：#define 标识符字符串其中的标识符就是所谓的符号常量，也称为“宏名”。
预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。
掌握"宏"概念的关键是“换”。
一切以换为前提、做任何事情之前先要换，准确理解之前就要“换”。
即在对相关命令或语句的含义和功能作具体分析之前就要换：例：#define PI 3.1415926把程序中出现的PI全部换成3.1415926说明：（1）宏名一般用大写（2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。
例如：数组大小常用宏定义（3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法检查。
（4）宏定义末尾不加分号；（5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。
（6）可以用#undef命令终止宏定义的作用域（7）宏定义可以嵌套（8）字符串" "中永远不包含宏（9）宏定义不分配内存，变量定义分配内存。
编辑本段2.带参数的宏定义：除了一般的字符串替换，还要做参数代换格式：#define 宏名（参数表）字符串例如：#define S(a,b) a*barea=S(3,2)；第一步被换为area=a*b; ，第二步被换为area=3*2;类似于函数调用，有一个哑实结合的过程：（1）实参如果是表达式容易出问题#define S(r) r*rarea=S(a+b);第一步换为area=r*r;,第二步被换为area=a+b*a+b;正确的宏定义是#define S(r) ((r)*(r))（2）宏名和参数的括号间不能有空格（3）宏替换只作替换，不做计算，不做表达式求解（4）函数调用在编译后程序运行时进行，并且分配内存。
宏定义和常量定义的区别
宏定义和常量定义的区别1.效果-《⾼质量C++/C编程指南》C++ 语⾔可以⽤const 来定义常量，也可以⽤#define 来定义常量。
但是前者⽐后者有更多的优点：（1） const 常量有数据类型，⽽宏常量没有数据类型。
编译器可以对前者进⾏类型安全检查。
⽽对后者只进⾏字符替换，没有类型安全检查，并且在字符替换可能会产⽣意料不到的错误（边际效应）。
（2）有些集成化的调试⼯具可以对const 常量进⾏调试，但是不能对宏常量进⾏调试。
规则5-2-1：在C++ 程序中只使⽤const 常量⽽不使⽤宏常量，即const 常量完全取代宏常量。
2.实现机制宏是预处理命令，即在预编译阶段进⾏字节替换。
const常量是变量，在执⾏时const定义的只读变量在程序运⾏过程中只有⼀份拷贝（因为它是全局的只读变量，存放在静态存储区的只读数据区。
根据c/c++语法，当你声明该量为常量，即告诉程序和编译器，你不希望此量被修改。
程序的实现，为了保护常量，特将常量都放在受保护的静态存储区内。
凡是试图修改这个区域内的值，都将被视为⾮法，并报错。
这不能理解为凡是字符串都是放在静态存储区域的。
这个跟数据类型没有关系，⽽是这个量是变量还是常量的问题。
例如，⼀个字符串变量就是可以被修改的。
这种静态存储区域的保护机制是由编译器实现的，⽽⾮存储该值的内存的电器属性。
换⾔之，实质上内存永远都可以被⽤户随意修改，只是编译器给⽤户的代码注⼊了⼀些⾃⼰的保护代码，通过软件⼿段将这段内存软保护起来。
这种保护在汇编级别可以轻松突破，其保护也就⽆效了。
）。
3.⽤法区别define宏定义和const常变量区别：1.define是宏定义，程序在预处理阶段将⽤define定义的内容进⾏了替换。
因此程序运⾏时，常量表中并没有⽤define定义的常量，系统不为它分配内存。
const定义的常量，在程序运⾏时在常量表中，系统为它分配内存。
2.define定义的常量，预处理时只是直接进⾏了替换。
C语言宏定义define，及一些陷阱！
C语言宏定义define，及一些陷阱！/group/6584292311289561607/?iid=39362926900&app=news_article×tamp=1533028562一、数值宏常量#define 宏定义是个演技非常高超的替身演员，但也会经常耍大牌的，所以我们用它要慎之又慎。
它可以出现在代码的任何地方，从本行宏定义开始，以后的代码就就都认识这个宏了；也可以把任何东西定义成宏。
因为编译器会在预编译的时候用真身替换替身，而在我们的代码里面却又用常常用替身来帮忙。
看例子：#define PI 3.141592654在此后的代码中你尽可以使用PI 来代替3.141592654，而且你最好就这么做。
不然的话，如果我要把PI 的精度再提高一些，你是否愿意一个一个的去修改这串数呢？你能保证不漏不出错？而使用PI 的话，我们却只需要修改一次。
这种情况还不是最要命的，我们再看一个例子：#define ERROR_POWEROFF -1如果你在代码里不用ERROR_POWEROFF 这个宏而用-1，尤其在函数返回错误代码的时候（往往一个开发一个系统需要定义很多错误代码）。
肯怕上帝都无法知道-1 表示的是什么意思吧。
这个-1，我们一般称为“魔鬼数”，上帝遇到它也会发狂的。
所以，我奉劝你代码里一定不要出现“魔鬼数”。
我们已经讨论了const 这个关键字，我们知道const 修饰的数据是有类型的，而define 宏定义的数据没有类型。
为了安全，我建议你以后在定义一些宏常数的时候用const代替，编译器会给const 修饰的只读变量做类型校验，减少错误的可能。
但一定要注意const修饰的不是常量而是readonly 的变量，const 修饰的只读变量不能用来作为定义数组的维数，也不能放在case 关键字后面。
二、字符串宏常量除了定义宏常数之外，经常还用来定义字符串，尤其是路径：A),#define ENG_PATH_1 E:\English\listen_to_this\listen_to_this_3B),#define ENG_PATH_2 “E:\English\listen_to_this\listen_to_this_3”噢，到底哪一个正确呢？如果路径太长，一行写下来比较别扭怎么办？用反斜杠接续符啊：C), #define ENG_PATH_3 E:\English\listen_to_this\listen\_to_this_3还没发现问题？这里用了4 个反斜杠，到底哪个是接续符？回去看看接续符反斜杠。
【C++】内联函数（inline）和宏定义（#define）的优劣及其区别
【C++】内联函数（inline）和宏定义（#define）的优劣及其区别⼀.宏定义:# define1.为什么要使⽤宏？因为调⽤宏⽐调⽤函数更有效率，函数的调⽤必须要将程序的执⾏顺序转移到函数所存放的内存地址中，将函数程序内容执⾏完后，再返回到执⾏该函数前的地⽅，这种转移操作要求执⾏前要保存现场并记忆执⾏地址，转回后要恢复现场，并按原来保存的地址继续执⾏，因此，函数调⽤有⼀定的时间和空间的开销，⽽宏只是在预处理的地⽅把代码展开，不需要额外的时间和空间开销，所以调⽤⼀个宏⽐调⽤⼀个函数更有效率2.宏定义的最⼤好处：宏定义的使⽤上像⼀个函数，但不是函数，它使⽤预处理器实现，没有了参数压栈，代码⽣成等⼀系列操作，因此效率很⾼3.宏定义的缺点：1）虽然宏定义类似⼀个函数，但在使⽤时，仅仅只是做预处理器符号表中的简单替换，因此它不能进⾏参数有效性的检测，也就不能享受C++编译器严格类型检查的好处，另外它的返回值也就不能被强制转换为可转换的合适类型2）宏定义不能访问类的成员变量3）宏定义使⽤参数时，是严格的替换策略，⽆论你得参数时是何种形式，在展开代码中都是⽤形参数代替实参，这样，宏定义很容易产⽣⼆义性，它的使⽤就存在⼀系列的隐患⼆.内联函数：inline1.内联函数的介绍：内联函数从源代码层看，有函数结构，⽽在编译后，却不具备函数性质，内联函数不是在调⽤时发⽣控制转移，⽽是在编译时将函数体嵌⼊每⼀个调⽤处，编译时，类似宏替换，使⽤函数体替换调⽤处的函数名，在代码中⽤inline关键字修饰，在类中声明的成员函数，⾃动转换为内联函数1）类中的成员函数默认是内联函数(要求成员函数没有循环和递归，当其中存在循环的递归的时候，编译器会将其默认为⼀个普通函数处理)2）内联函数不允许有循环或者递归语句3）内联函数的定义必须出现在第⼀次调⽤内联函数之前2.内联函数的优点：1）有参数类型检测，更加安全2）内联函数是在程序运⾏时展开，⽽且是进⾏参数传递3）inline关键字只是对编译器的⼀个定义，如果函数本地不符合内联函数的标准，编译器就会将这个函数当作是普通函数3.内联函数的缺点：1）因为内联函数是在调⽤处展开，所以会使代码边长，占⽤更多内存三.内联函数和宏定义的主要区别：1）内联函数在运⾏时可调试，⽽宏定义不可以2）编译器会对内联函数的参数类型做安全检查或⾃动类型转换，⽽宏定义则不会3）内联函数可以访问类的成员变量，⽽宏定义则不能。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
宏定义的优缺点
其实在用VC编程的时候就会遇到很多宏定义，尤其是类似LONG，LPCTSTR等等之类的，它们属于微软的自定义类型，但其本质上还是属于C/C++里面的那几个标准类型。
那用宏定义到底有什么好处呢？
先来看一下宏的定义：用#define命令将一个指定的标识符（即宏名）来代表一个字符串。
它的一般型式为：
#define 表示符字符串
#define命令属于“预处理命令”中的一种。
它是由C++统一规定的，但非C++语言本身的组成部分，由于编译器无法识别他们，不能对其直接进行编译。
预处理过程必须在对程序进行词法与语义分析、代码生成与优化等通常的编译过程之前进行，经过预处理后的程序不再包含之前的预处理命令。
C++提供的预处理功能除了宏定义之外，还有以下两个:
文件包含（#include命令）
条件编译（#ifdef …. #def …. #endif命令）
#define命令还可以定义带参数的宏定义，用于实现某种特定的功能，其定义型式为：
#define 宏名(参数列表) 字符串
例如：#define Sum(a,b) a+b
不过，由于C++增加了内联函数(inline)，实现起来比带参数的宏更方便，这样的宏在C++中已经很少使用了。
接下来看看宏都有什么好处：
提高了程序的可读性，同时也方便进行修改；
提高程序的运行效率：使用带参的宏定义既可完成函数调用的功能，又能避免函数的出栈与入栈操作，减少系统开销，提高运行效率；
宏是由预处理器处理的，通过字符串操作可以完成很多编译器无法实现的功能。
比如##连接符。
但是它也有自己的缺点：
由于是直接嵌入的，所以代码可能相对多一点；
嵌套定义过多可能会影响程序的可读性，而且很容易出错；
对带参的宏而言，由于是直接替换，并不会检查参数是否合法，存在安全隐患。
补充：预编译语句仅仅是简单的值代替，缺乏类型的检测机制。
这样预处理语句就不能享受C++严格的类型检查的好处，从而可能成为引发一系列错误的隐患。
的确，宏定义给我们带来很多方便之处，但是必须正确使用，否则，可能会出现一些意想不到的问题。
最后，引用《C陷进与缺陷》的一句话，对其进行总结：
宏并不是函数,宏并不是语句,宏并不是类型定义。