Lenguaje C: comandos de preprocesamiento del ensayo 7

Aquellos que comienzan con # son comandos de preprocesamiento.

#include <stdio.h> // Archivos de encabezado de entrada y salida estándar

#define PI 3.1415925 // Comando de definición de macro

En el programa fuente, estos comandos se colocan fuera de la función y, por lo general, se colocan delante del archivo fuente, se denominan parte de preprocesamiento. (Porque se procesaron antes que el archivo fuente)

1. Definición de macro sin parámetros

1. No hay parámetros después del nombre de la macro sin parámetros.

La forma general de su definición es:

#define  标识符  字符串//其中“#”表示这是一条预处理命令
凡是以“#”开头的均为预处理命令。define为宏定义命令。”标识符“为多定义的宏名。“字符串”可以是阐述、表达式、格式串等。
//例如
#define PI 3.1415926
//他的作用是指定标识符PI来代替数3.1415926.
//在百你写源程序时，所有的3.1415926都可以由PI代替，而对源程序做编译时，将由预处理程序进行宏代换，即用3.1415926表达式去置换所有的宏名PI，然后再进行编译。

Descripción de la definición de macro sin parámetros:

(1) La definición de macro usa el nombre de la macro para representar una cadena y luego reemplaza el nombre de la macro con la cadena cuando la macro se expande. Esto es solo un reemplazo simple. La cadena puede contener cualquier carácter, puede ser una constante o puede Es una expresión. No se realiza ninguna comprobación durante el preprocesamiento. Si hay un error, solo se puede encontrar al compilar el programa fuente que ha sido expandido por la macro.

(2) La definición de macro no es una descripción o una declaración. No es necesario agregar un punto y coma al final de la línea. Si se agrega un punto y coma, el punto y coma se reemplazará en conjunto.

(3) La definición de macro debe escribirse fuera de la función y su alcance es desde el comando de definición de macro hasta el final del programa fuente . Para terminar su alcance, use el comando #undef. # identificadorundef

(4) Si el nombre de la macro está entre comillas en el programa fuente, el programa de preprocesamiento no lo sustituirá por la macro. (Entre comillas dobles, lo tratamos como una cadena constante a la salida)

(5) Se permite anidar las definiciones de macro y el nombre de la macro definida se puede utilizar en la cadena de la definición de la macro. La macro expansión es reemplazada por el programa de preprocesamiento.

(6) Es habitual utilizar letras mayúsculas para los nombres de macros para distinguirlos de las variables. Sin embargo, también se permiten letras minúsculas. (Porque es costumbre usar minúsculas para nombres de variables)

(7) La definición de macro se puede utilizar para expresar el tipo de datos, lo que facilita la escritura. 

Por ejemplo: #define TNTEGER int (usando TNTEGER a; significa int a;)

----- PS: La diferencia entre una definición de macro y un especificador de datos definido por typedef

Diferencia: la definición de macro es simplemente un reemplazo de cadena simple, que se realiza en el preprocesamiento, mientras que typedef (en realidad una declaración con un punto y coma ";") se procesa en tiempo de compilación. No es un reemplazo simple, sino un Se cambió el nombre del especificador de tipo. El identificador nombrado tiene la función de descripción de definición de tipo.

Utilice los siguientes ejemplos para comparar:

#include<stdio.h>
#define PTN1 char*//PIN1是一个char* 是一个指针形式的字符
typedef char* PIN2;//指针形式的字符为PIN2
void main()
{
    PIN1 x,y;//用PIN1定义x和y//3宏定义替换：char* x,y;(相当于定义x是一个指针而y是一个字符型)
    PIN2 a,b;//用PIN2定义a和b//4而用typedef呢使类型重命名，将char*用PIN2表示，也就是说这里相当于char* a,char* b;所以打印出来不一样
    printf("By #define:%d %d\n\n",sizeof(x),sizeof(y));//分别取他们的大小然后打印。1打印结果4 1
    printf("By typedef:%d %d\n\n",sizeof(a),sizeof(b)); //2打印结果：4  4

}

(8) La definición macro de "formato de salida" puede reducir los problemas de escritura. (Por ejemplo, es problemático imprimir% dy% s cien veces con printf durante la salida)

#include<stdio.h>
#define P printf
#define D "%d\n"
#define F "%f\n"

void main()
{
   int a=5,c=8,e=11;
   float b=3.8,d=9.7,f=21.08;
   P(D F,a,b);
   P(D F,c,d);
   P(D F,e,f);

}

2. Definición de macro con parámetros

El lenguaje C permite que las macros tengan parámetros. Los parámetros de la definición de la macro se denominan parámetros formales y los parámetros de la llamada a la macro se denominan parámetros reales.

Para macros con parámetros, en la llamada, no solo la expansión de macro, sino también los parámetros reales para reemplazar los parámetros formales.

La forma general con definición de macro de parámetros es:

#define 宏名（形参表）  字符串//不带分号“;”

La forma general de llamada de macro con parámetros es:

宏名（实参表）；//带分号“;”

P.ej:

#define M(y) y*y+3*y//宏定义//参数是y，字符串是y*y+3*y
...
K=M(5);//宏调用//传递给的实参是5，在调用时，实参5去替换形参y。（但是这里跟函数的调用值传递是不一样的，这里是直接的替换）

Ejemplos:

#include<stdio.h>
#define MAX(a,b) (a>b?a:b)//a和b是虚有的只是一个替代的符号
void main()
{
    int x,y,max;//定义了类型
    printf("input two numbers:")
    scanf("%d %d",&x,&y);
    max=MAX(x,y);//这里替换为max=(x>y)?x,y;//上边的a和b就被x和y实参化了
    printf("The max is %d\n\n",max);

}

Descripción de la definición de macro con parámetros:

(1) En la definición de macro con parámetros, no puede haber espacios entre el nombre de la macro y la lista de parámetros formales. Por ejemplo, lo anterior no se puede escribir como #define MAX (a, b) y no puede haber espacios entre ellos.

(2) En la definición de macro parametrizada, los parámetros formales no asignan unidades de memoria, por lo que no es necesario realizar definiciones de tipo. Los parámetros reales en la llamada de macro tienen valores específicos. Para usar his para reemplazar los parámetros formales, se debe realizar la especificación de tipo. (Esto es diferente de la situación en la función. El parámetro formal y el parámetro real en la función son dos cantidades diferentes, cada una con su propio alcance, (es decir, el parámetro formal en la definición de la función tiene su valor variable, el parámetro real Hay otros valores de variable) al llamar, el valor real del parámetro debe asignarse al parámetro formal para realizar la "transferencia de valor". En la macro con parámetros, solo reemplazo de símbolo, no hay problema de transferencia de valor.) (En la macro, solo el parámetro real tiene otro Ámbito de acción)

(3) El parámetro formal en la definición de la macro es un identificador, y el parámetro real en la llamada a la macro puede ser una expresión. (Lo que es una expresión es en realidad una fórmula)

#include<stdio.h>
#define SAY(y)  (y)
void main()
{
    int i;
    char say[]={73,32,108,111,118,101,32,102,105,115,104,99,46,99,111,109,3}
    while(say[i])
    {
        say[i]=SAY(say[i]+1);//可以是表达式（刚才打印的各个字符的ASCII码加1）
    }
    printf("\n\t%s\n\n",say);//打印出来I love fishc,com!
}

#include<stdio.h>
#define SAY(y)  (y)^(y)//里边的符号^是异或的意思
void main()
{
    int i;
    char say[]={73,32,108,111,118,101,32,102,105,115,104,99,46,99,111,109,3}
    while(say[i])
    {
        say[i]=SAY(say[i]^say[i]);
    }
    printf("\n\t%s\n\n",say);

}

(4) En la definición de macro, los parámetros formales de la cadena suelen estar entre paréntesis para evitar errores. (Agregue paréntesis para evitar cambios de prioridad)

(5) Los parámetros con macros y funciones con parámetros son muy similares, pero existen diferencias esenciales. Además de los puntos mencionados anteriormente, el resultado de procesar la misma expresión con funciones y macros puede ser diferente.

Tres, compilación condicional

El preprocesador proporciona una función de compilación condicional. Puede compilar diferentes partes del programa en diferentes condiciones, lo que da como resultado diferentes archivos de código objeto. Esto es muy útil para el trasplante y depuración de programas.

Hay tres reglas tácitas para la compilación condicional:

El primer tipo: La función es: si el identificador ha sido definido por el comando #define, compile el bloque 1; de lo contrario, compile el bloque 2.

#ifdef  标识符//如果有定义这个标识符的话，那么就执行程序1
    程序段1
#else//没有定义的话就执行2
    程序段2
#endif

 Si no hay un segmento de programa 2 (está vacío) #else en este formato puede estar ausente, es decir, se puede escribir como:

#ifdef  标识符//如果有定义这个标识符的话，那么就执行程序
    程序段
#endif

La segunda forma:

#ifndef  标识符//如果没有定义这个标识符的话，那么就执行程序1
    程序段1
#else//有定义的话就执行2
    程序段2
#endif

La tercera forma:

#if  常量表达式//if 0下边的就不会被编译执行做注释用的多（相当于一个开关，是1就执行程序1，是0就执行程序2）
    程序段1
#else
    程序段2
#endif