C语言预处理（部分）¶

__FILE__      //进⾏编译的源文件 
__LINE__     //⽂件当前的行号 
__DATE__    //⽂件被编译的日期 
__TIME__    //⽂件被编译的时间 
__STDC__    //如果编译器遵循ANSI C，其值为1，否则未定义（VS2022不遵循）

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

int main()
{

    printf("文件位置:%s\n当前代码所在行数：%d\n代码编译日期：%s\n代码编译时间：%s\n", __FILE__, __LINE__, __DATE__, __TIME__);

    return 0;
}
输出结果：
文件位置:E:\C_language\c_-language\test\test.c
当前代码所在行数：8
代码编译日期：Jan 16 2024
代码编译时间：20:34:25

使用方法
#define name content

#define PLUS 50 + 5
//在替换过程中，不会替换为50 + 5之后的值55，而是直接替换为50 + 5

//#define定义常量
#define MAX 100 //定义一个MAX常量，其值为100
#define RES register //为register关键字定义一个更简短的名字
#define cycle_forever for(;;) //为死循环的实现定义一个只管的符号
#define CASE break;case //在case语句后自动加上break，使用CASE:时，将替换为break;case:
//如果定义的content过⻓，可以分成多行写，除了最后一⾏外，每行的后⾯都加一个反斜杠(续⾏符)
#define DEBUG_PRINT printf("file: %s\tline:%d\t \
                            date:%s\ttime:%s\n", \
                           __FILE__,__LINE__, __DATE__,__TIME__)

使用方法
#define name( parament-list ) content
其中的 parament-list是⼀个由逗号隔开的符号表（类似于函数参数列表，但是没有类型书写和限制，只有符号），它们可能出现在content中

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

//#define MAX 100
#define DOUBLE(x) x * x //定义一个宏实现一个数值的平方，未考虑到宏定义表达式不计算以及parament-list部分的运算符和宏定义content部分的运算符优先级
#define DOUBLE1(y) (y) * (y) //考虑到宏定义中的表达式不计算以及parament-list部分的运算符和宏定义content部分的运算符优先级
#define DOUBLE2(z) (z) * (z) + 1 //未考虑到宏定义content部分的优先级与宏使用宏时邻近的运算符的优先级
#define DOUBLE3(n) ((n) * (n) + 1) //考虑到宏定义content部分的优先级与宏使用宏时邻近的运算符的优先级

#define MAX(a, b) (((a) > (b)) ? (a) : (b)) //定义宏求两个数之间的较大数

int main()
{
    //运算符优先级
    printf("%d\n", DOUBLE(5));
    printf("%d\n", DOUBLE(5 + 1));//因为宏定义中的表达式5 + 1不会进行计算，在代入宏中时，将直接替换，即5 + 1 * 5 + 1，而不是(5 + 1) * (5 + 1)
    printf("%d\n", DOUBLE1(5 + 1));//正常输出36，即(5 + 1) * (5 + 1)
    printf("%d\n", 2 * DOUBLE2(5));//直接替换时为2 * (5) * (5) + 1，而不是2 * ((5) * (5) + 1)
    printf("%d\n", 2 * DOUBLE3(5));//正常输出52，即2 * ((5) * (5) + 1)

    putchar('\n');

    //表达式副作用
    int a = 3;
    int b = 5;

    int ret = MAX(a, b);//直接比较没有副作用

    printf("%d\n", ret);
    //不改变a和b中的值
    printf("%d\n", a);
    printf("%d\n", b);

    int ret1 = MAX(a++, b++);//存在使操作数本身发生改变的副作用

    printf("%d\n", ret1);
    //a和b中的值发生改变
    //(((a++) > (b++)) ? (a++) : (b++))
    //因为是后置++，故先使用再+1，故有3 > 5，此时再改变a和b中的值，此时a为4， b为6
    //因为三目操作符表达式的值即为满足条件的表达式的值，故即为b的值6，使用完b后进行++。此时b中的值为7，但是a++表达式并未计算，故a还是4
    //故此时a为4，b为7
    printf("%d\n", a);
    printf("%d\n", b);

    return 0;
}
输出结果：
25
11
36
51
52

5
3
5
6
4
7

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

#define MAX 100

int main()
{
    printf("MAX is %d\n", MAXN);//由于MAXN在字符串常量"MAX is %d\n"中，故不会被替换为100

    return 0;
}
输出结果：
MAX is 100

宏实现
#define MAX(a, b) (((a) > (b)) ? (a) : (b))

函数实现
int max(int a, int b)
{
    return ((a > b) ? a : b);
}

#define MALLOC(num, type) (type*)malloc(num, sizeof(type))

MALLOC(10, int);//int类型名作为参数
替换后为
(int*)malloc(10, sizeof(int))

代码实例
#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#define MALLOC(num, type) (type*)malloc(num, sizeof(type))

int main()
{
    int* p = MALLOC(10, int);
    assert(p);

    for (int i = 0; i < 10; i++)
    {
        p[i] = i;
        printf("%d ", p[i]);
    }

    return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

#define PRINT(n, type) printf(#n" = "type"\n", n) //printf语句支持有多个""的字符串构成一句字符串，例如printf("hello world");相当于printf("hello""world");

int main()
{
    int a = 10;
    int b = 10;
    float f = 10.5f;

    //常规做法
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    printf("f = %f\n", f);

    //使用#运算符与#define定义宏
    PRINT(a, "%d");
    PRINT(b, "%d");
    PRINT(f, "%f");

    return 0;
}
输出结果：
a = 10
b = 10
f = 10.500000
a = 10
b = 10
f = 10.500000

//求int类型数据的两个数中较大数
int int_max(int x, int y)
{
    return (x>y?x:y);
}

//求float类型数据的两个数中较大数
float float_max(float x, float y)
{
    return (x>y? x:y);
}

//使用##运算符以及#define定义宏
#define GENERIC_MAX(type)\
type type##_max1(type x, type y)\
{\
    return (x > y ? x : y);\
}

GENERIC_MAX(int)
GENERIC_MAX(float)

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

//求int类型数据的两个数中较大数
int int_max(int x, int y)
{
    return (x > y ? x : y);
}

//求float类型数据的两个数中较大数
float float_max(float x, float y)
{
    return (x > y ? x : y);
}

#define GENERIC_MAX(type)\
type type##_max1(type x, type y)\
{\
    return (x > y ? x : y);\
}

GENERIC_MAX(int)
GENERIC_MAX(float)

int main()
{

    int a = 10;
    int b = 20;
    float f = 10.5f;
    float f1 = 20.5f;

    //两个类型写两个函数
    int ret_i = int_max(a, b);
    float ret_f = float_max(f, f1);
    printf("%d\n", ret_i);
    printf("%f\n", ret_f);

    //##运算符和#define定义宏，只需要写一个函数
    ret_i = int_max1(a, b);
    ret_f = float_max1(f, f1);
    printf("%d\n", ret_i);
    printf("%f\n", ret_f);

    return 0;
}
输出结果：
20
20.500000
20
20.500000

#undef NAME
//如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

#define MAXNUM 100

int main()
{
    printf("%d\n", MAXNUM);
#undef MAXNUM //移除MAXNUM定义
    //printf("%d\n", MAXNUM);//未重新定义之前不可以再使用
#define MAXNUM 100 //重新定义可以使用
    printf("%d\n", MAXNUM);

    return 0;
}
输出结果：
100
100

#include <stdio.h>
int main()
{
    int array [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
    {
        array[i] = i;
    }
    for(i = 0; i< ARRAY_SIZE; i ++)
    {
        printf("%d " ,array[i]);
    }
    printf("\n" );
    return 0;
}

gcc -D ARRAY_SIZE=10 programe.c
//-D ARRAY_SIZE=10为ARRAY_SIZE指定大小

1.
#if  常量表达式
        //语句
#endif
//常量表达式由预处理器求值，并且不能使用变量，因为变量在预处理过程中并没有具体值
如：
#define __DEBUG__ 1
#if __DEBUG__ //如果DEBUG值为非0值，则编译语句，为0则不编译
        //语句
#endif

#if 1==2 //1==2为假，不编译语句
        //语句
#endif

2.多个分⽀的条件编译（只会走其中一个条件，与if-else-if逻辑相同）
#if 常量表达式
        //语句
#elif 常量表达式
        //语句
#else
        //语句
#endif

3.判断是否被定义（只关注是否被定义，不会关注具体值大小）
#if defined(symbol) //定义了symbol就编译，否则不编译
        //语句
#endif

#ifdef symbol //定义了symbol就编译，否则不编译
        //语句
#endif

#if !defined(symbol) //未定义symbol就编译，否则不编译
        //语句
#endif 

#ifndef symbol //未定义symbol就编译，否则不编译
        //语句
#endif

4.嵌套指令
#if defined(OS_UNIX)//定义了OS_UNIX则编译if内的内容
        #ifdef OPTION1 //定义了OPTION1，则编译
                unix_version_option1();
        #endif
        #ifdef OPTION2 //定义了OPTION2，则编译
                unix_version_option2();
        #endif
#elif defined(OS_MSDOS)//定义了OS_UNIX则编译elif内的内容
        #ifdef OPTION2 //定义了OPTION2，则编译
                msdos_version_option2();
        #endif
#endif

//头文件中的#ifndef/#define/#endif用于防止头文件被重复引入
#ifndef __TEST_H__//在第二次之后，查找发现文件中定义了__TEST_H__，则不进行编译后面的语句
#define __TEST_H__//在原来的头文件中第一次未定义__TEST_H__，则会编译本条语句以及头文件的内容
//头⽂件的内容 
#endif   //__TEST_H__

或者
#pragma once