C语言宏定义+条件编译

1、宏定义

1.概念

C语言中的宏定义是一种预处理指令，它允许开发者为一段代码或值定义一个名称，称为宏。在编译程序时，预处理器会在实际编译之前对源代码进行预处理，将宏名称替换为其定义的内容。宏定义通常使用 #define 指令来实现。

#define 名称/宏名/别名    代码块/数据/原来的数据
#define macro_name replacement_text

其中，
macro_name 是宏的名称，
replacement_text 是宏替换时要插入的文本。

#define HELLO    "hello world\n"
#define PI      3.14

#define A(a,b,c)  ({a=1;b+=1;c=3;a+b+c;}) 

2.格式

1）简单的宏定义：
    #define    <宏名>    <字符串>
2）带参数的宏定义（宏函数）
    #define    <宏名>（参数表）    <宏体>

#define A(a,b,c)  ({a=1;b+=1;c=3;a+b+c;})     

3. #define xxx() ({})

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

在上面的例子中，MAX 是一个带参数的宏，它接受两个参数 a 和 b，并返回两者中的较大值。在代码中使用 MAX(x, y) 时，预处理器会将其替换为 ((x) > (y) ? (x) : (y))。
宏定义在C语言中非常有用，它们可以简化代码、提高代码的可读性和可维护性，并允许开发者在编译时进行一些特定的代码替换或操作。然而，由于宏定义只是简单的文本替换，没有类型检查或其他编译时的检查，因此在使用时需要特别小心，以避免一些常见的错误和陷阱。

3.作用

方便程序的修改，提高程序的可读性

4.注意

在简单宏定义的使用中，当替换文本所表示的字符串为一个表达式时，容易引起误解和误用。

#define   N   2+1 //--注意 #define   N   (2+1)   

#define   M   N*2
void main()
{
   int   a=N*N;
   printf("%d\n",a);
}

5.复杂的宏定义

5.1 带有条件和循环的宏
在C语言中，宏定义可以非常复杂，并且可以用于生成相当复杂的代码片段。通过结合参数、操作符、条件和嵌套宏，可以创建出功能强大的宏。以下是一些复杂宏定义的例子：

#define IS_EVEN(x) ((x) % 2 == 0)  
#define PRINT_NUMBERS(n) do { \  
    int i; \  
    for (i = 0; i < (n); ++i) { \  
        if (IS_EVEN(i)) { \  
            printf("%d is even\n", i); \  
        } else { \  
            printf("%d is odd\n", i); \  
        } \  
    } \  
} while (0)

在这个例子中，IS_EVEN 是一个简单的宏，用于检查一个数是否是偶数。PRINT_NUMBERS 是一个更复杂的宏，它使用 do { … } while (0) 结构来模拟一个语句块，并在其中使用了一个 for 循环来打印从0到 n-1 的所有整数，同时标记每个数是偶数还是奇数。

5.2 使用多个参数的宏

#define MIN(a, b) ((a) < (b) ? (a) : (b))  
#define SWAP(a, b, tmp) do { \  
    tmp = (a); \  
    (a) = (b); \  
    (b) = tmp; \  
} while (0)

MIN 宏接受两个参数并返回它们中的较小值。SWAP 宏则用于交换两个变量的值，它需要一个临时变量 tmp 来辅助完成交换。

5.3 嵌套宏

#define SQUARE(x) ((x) * (x))  
#define AREA_OF_CIRCLE(r) (3.14159 * SQUARE(r))

在这个例子中，SQUARE 宏用于计算一个数的平方，而 AREA_OF_CIRCLE 宏则用于计算圆的面积，它内部使用了 SQUARE 宏来计算半径的平方。

6.预定义宏

预定义宏是C语言中标准编译器预先定义的宏（官方定义了，不需要我们定义，我们需要时直接使用这些宏就行），常用的预定义宏如下：

1）预处理日期和时间
__DATE__ 、__TIME__
2) 函数名  和  当前行
__FUNCTION__、 ___LINE__
3)文件名
__FILE__

#include <stdio.h>

int test01()
{
    //............
    int a;
    printf("文件名:%s 当前函数:%s 当前行:%d a:%d\n",__FILE__,__FUNCTION__,__LINE__,a);

    //当前时间和日期
    printf("%s %s\n",__DATE__,__TIME__);
}

int main()
{
    test01();

    return 0;
}

7.#符号和##符号

# 符号
1.首先看这段代码

#include <stdio.h>
int main()
{
    char *str = "hello" "world";
    printf("str = %s\n", str);  
    return 0;
}

结果：
str = helloworld
结论：字符串是有自动连接的特点的

2.使用 # 符号 ，把一个宏参数变成对应的字符串

#include <stdio.h>
#define CHANGE(STR)  #STR  // #将文本STR转换成字符串
int main()
{
    char *str = "hello" "world" "ikun";
    printf("str = %s\n", str);
    printf("CHANGE(STR)= %s\n", CHANGE(ikun i love you));    // #ikun i love you 转成"ikun i love you"
    return 0;
}

## 符号
##可以把位于它两边的符号合成一个符号。它允许宏定义从分离的文本片段创建标识符

#include <stdio.h>
#define STRCAT(str1, str2)   str1##str2  // 将str1和str2标识连在一起
int main()
{
    int sum5 = 100;
    printf("sum5 =  %d\n", STRCAT(sum, 5));
    return 0;
}

结果
sum5 = 100
注意：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的,连接是在预处理的时候进行的

2、编译过程

编译过程分为以下四个阶段：

1)预处理：处理预处理语句（#开头的语句），删除注释、头文件展开、宏替换…
gcc hello.c -o hello.i -E
2)编译:将C语言程序转化为汇编语言
gcc hello.c -o hello.s -S
3)汇编：将程序代码转化为二进制代码
gcc hello.c -o hello.o -c
4)链接：将所有二进制代码合并起来，根据应用规则生成一个专门针对某个平台执行的应用程序镜像
gcc hello.c -o hello

内联函数与宏函数的的区别
C语言中的内联函数和宏函数都是用于优化代码性能的工具，但它们之间存在一些重要的区别。
1.编译时处理
：

• 宏函数：宏函数在预处理阶段由预处理器处理。预处理器会直接将宏函数替换为它的定义，然后再进行编译。因此，宏函数没有类型检查，也没有作用域，只是简单的文本替换。
• 内联函数：内联函数在编译时被处理。编译器会在调用内联函数的地方直接插入或替换内联函数的代码，从而避免函数调用的开销。内联函数有类型检查，也有作用域。
  2.参数处理
  ：
• 宏函数：由于宏函数只是文本替换，因此参数在替换过程中可能会引发一些意料之外的问题，比如运算符优先级问题。为了避免这些问题，宏函数的参数通常需要用括号包围。
• 内联函数：内联函数在参数处理上就像普通的函数一样，有明确的参数类型和参数传递方式，因此不需要担心运算符优先级等问题。
  3.调试和可读性
  ：
• 宏函数：由于宏函数是文本替换，因此在调试时可能会比较困难，因为预处理器已经将宏函数替换为了它的定义，所以无法在调试器中看到宏函数的调用。此外，由于宏函数没有明确的作用域和类型检查，因此可能会降低代码的可读性和可维护性。
• 内联函数：内联函数像普通的函数一样，可以在调试器中看到其调用和执行过程，因此更易于调试。此外，内联函数有明确的作用域和类型检查，因此可以提高代码的可读性和可维护性。
  4.适用场景
  ：
• 宏函数：通常用于执行简单的、不需要复杂逻辑或类型检查的操作，或者用于定义一些常量或简单的计算式。
• 内联函数：适用于那些函数体较小，但又频繁调用的函数。通过内联可以减少函数调用的开销，提高程序的执行效率。
  总的来说，内联函数和宏函数各有其优缺点，应根据具体的应用场景和需求来选择使用哪一种。

#define MAX(a，b) ((a)>(b)?(a):(b))
MAX(a,"Hello"); //错误地比较int和字符串，没有参数类型检查

#include <stdio.h>
inline int add(int a, int b)
{
    return (a + b);
}
 
int main(void)
{
    int a;
 
    a = add(1, 2);
    printf("a+b=%d\n", a);
 
    return 0;
}

以上a = add(1, 2);处在编译时将被展开为：
a = (a + b);

3、条件编译和模块化

1、概念
能够根据不同情况编译不同代码，产生不同目标文件的机制，称之为条件编译。说白了，条件编译的意思就是有条件地编译某些我们指定的代码，而不一定编译文件中所有的代码。

2、#if指令

#if 整型常量表达式1
    程序段1
#elif 整型常量表达式2
    程序段2
#elif 整型常量表达式3
    程序段3
#else
    程序段4
#endif

比如：

#if  0  ---相当于注释作用

#endif

2、#ifdef 指令

#ifdef  宏名
    程序段1
#else 
    程序段2
#endif

#ifdef   宏名
#undef  宏名 //取消定义该宏
    程序段
#endif

#ifndef  宏名
    程序段1
#else
    程序段2
#endif

#include<stdio.h>

//#define SELECT

int main()
{

#ifdef SELECT
    int a = 100;
    int b = 300;
    int c = 500;
    printf("SELECT\n");
    printf("a:%d b:%d c:%d\n",a,b,c);
    
#else
    int a = 1000;
    int b = 3000;
    int c = 5000;
    printf("SELECT\n");
    printf("a:%d b:%d c:%d\n",a,b,c);
    
#endif
    
    return 0;
}

3、使用宏定义调试语句

#include<stdio.h>

int main(void)
{
    #ifdef DEBUG
        printf("传入参数\n");
    #else
        printf("没有传入参数\n");
    #endif
    
    return 0;
}

在编译的时候加入 -DDEBUG

编译命令：gcc if.c -o if -DDEBUG

head.h
如何确保测试的标识符没有在别处定义？
用文件名作为标识符、使用大写字母、用下划线字符代替文件名中的点字符、用下划线字符做前缀或者后缀

#ifndef __HEAD_H //该宏的作用：防止头文件被重复包含
#define __HEAD_H
//系统头文件
//复合数据类型的设计  结构体数据类型   枚举数据类型
//宏定义
//函数的声明
//全局变量的声明
#endif

编译的时候不需要包含头文件，因为已经在源文件中 进行声明了

#include "head.h"  //双引号 表示告诉编译器该头文件是我自己封装的，在我指定的目录寻找即可

编译命令：

gcc main.c  -o project

多个.c文件拆分+工程项目模块化
-I + 头文件路径 表示在编译的时候告诉编译器我自定义的头文件在哪里

gcc   ./src/*.c  -o  project    -I  ./inc

*.c 表示 获取 所有的源文件

4、常用关键字

1、const关键字 ---- 只读

1）const修饰普通变量

int a = 100;
a = 200;//正确
const int b = 100;
b = 200;//错误，由const修饰的变量b 为只读变量，不能通过变量名修改其内存空间的数据，但是你可以定义一个指针，去间接修改

2）const修饰指针变量

int  x = 100;
//不能通过p 修改  p所指向内存空间的数据
const int  *p = &x;

//跟上面是等价的
int  const *p = &x; 

//p不能被修改，也就是说，p不能再指向别的内存空间  p = &y; //p修改--是错误的
int * const p = &x;
const int *const p = &x;

2、static 关键字

1）修饰变量

由static修饰的变量 称之为 静态变量

修饰全局变量
作用域：仅限于本文件有效
修饰局部变量
作用域：不会随着函数调用的结束而释放内存空间，也就是说，内存空间会一直存在，并且只会被初始化一次

2）修饰函数

由static修饰的函数称之为 静态函数，静态函数 仅限于本文件有效，防止一个工程项目中不同文件的函数同名冲突

3、volatile关键字

1）概念
volatile的意思是 “易变的”，应该解释为“直接存取原始内存地址”比较合适。“易变”是因为外在因素引起的，比如多线程，中断等等。volatile提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，告诉编译器对该变量不做优化，都会直接从变量内存地址中读取数据，从而可以提供对特殊地址的稳定访问。
如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。（简洁的说就是：volatile关键词影响编译器编译的结果，用volatile声明的变量表示该变量随时可能发生变化，与该变量有关的运算，不要进行编译优化，以免出错）

2）作用
防止变量被编译器优化

3）例子

int main(void)
{
    volatile int i;
    int j;

    i = 1; //1 不被优化
    i = 2; //2 不被优化
    i = 3; //3 不被优化

    j = 1; //4 被优化
    j = 2; //5 被优化
    j = 3; //6 j = 3
}

//单片机延时函数
void delay()
{
  int i = 0x1000000;
    while(i--);  
}
//单片机延时函数
void delay()
{
    volatile int i = 0x1000000; //防止编译器优化变量
    while(i--);
}

4、auto自动化变量 与 register寄存器变量

1)auto自动化变量(内存变量),定义变量时该关键字可以省略不写

int a=10;//其实完整写法是 auto int a =10;//一般auto可以默认不写

比如：int a ---->其实全称应该是 signed int a ;//一般signed可以默认不写

2）register寄存器变量
调用频繁的变量可以定义成一个寄存器变量

register int a = 10;// 变量在定义的时候会分配寄存器存储
&a 是错误的

注意：

• 定义寄存器变量不一定成功（主要看编译器）,如果不成功会自动定义成自动化变量
• 寄存器变量没有内存地址，所以不能取地址 &a

总结：变量从存储位置来说一般分为两种：存储在内存地址的自动化变量和存储在寄存器的寄存器变量。

5、typedef
1、概念
typedef 用来声明一个新类型
2、作用
给一个已经定义了的类型取一个新的名字，使新的名字更能表示它的含义。

typedef  int  size_t;
void *malloc(size_t size);    

3、给结构体取别名

typedef struct node{
    int data;
}Node_t,*pNode_t;//表示给struct node结构体变量取一个别名Node_t,表示给struct node结构体指针变量取一个别名pNode_t
struct node{
    int data;
}Node_t,*pNode_t; //如果没有使用typedef关键字修饰，此时Node_t是该结构体的变量，pNode_t是该结构体的指针变量

4、给数组取新名字

typedef int array[10];//新的类型为array,代表int[10];
array a;//定义一个数组a，它有10个元素，每个元素为int类型。

5、给函数指针取新名字

int (*p)(int,char);//定义一个函数指针变量p
typedef int (*pfunc)(int,char);//声明一个新类型pfunc，该类型与p一样