C语言宏定义

参见：

https://gcc.gnu.org/onlinedocs/cpp/index.html

在宏定义中，#和##

#表示将其后的内容转换为字符串，##表示将它先后两个TOKEN链接为一个。

3.4 Stringification

Sometimes you may want to convert a macro argument into a string constant. Parameters are not replaced inside string constants, but you can use the ‘#’ preprocessing operator instead. When a macro parameter is used with a leading ‘#’, the preprocessor replaces it with the literal text of the actual argument, converted to a string constant. Unlike normal parameter replacement, the argument is not macro-expanded first. This is called stringification.

There is no way to combine an argument with surrounding text and stringify it all together. Instead, you can write a series of adjacent string constants and stringified arguments. The preprocessor will replace the stringified arguments with string constants. The C compiler will then combine all the adjacent string constants into one long string.

Here is an example of a macro definition that uses 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);
The argument for EXP is substituted once, as-is, into the if statement, and once, stringified, into the argument to fprintf. If x were a macro, it would be expanded in the if statement, but not in the string.

The do and while (0) are a kludge to make it possible to write WARN_IF (arg);, which the resemblance of WARN_IF to a function would make C programmers want to do; see Swallowing the Semicolon.

Stringification in C involves more than putting double-quote characters around the fragment. The preprocessor backslash-escapes the quotes surrounding embedded string constants, and all backslashes within string and character constants, in order to get a valid C string constant with the proper contents. Thus, stringifying p = "foo\n"; results in "p = \"foo\\n\";". However, backslashes that are not inside string or character constants are not duplicated: ‘\n’ by itself stringifies to "\n".

All leading and trailing whitespace in text being stringified is ignored. Any sequence of whitespace in the middle of the text is converted to a single space in the stringified result. Comments are replaced by whitespace long before stringification happens, so they never appear in stringified text.

There is no way to convert a macro argument into a character constant.

If you want to stringify the result of expansion of a macro argument, you have to use two levels of macros.

     #define xstr(s) str(s)
     #define str(s) #s
     #define foo 4
     str (foo)
          ==> "foo"
     xstr (foo)
          ==> xstr (4)
          ==> str (4)
          ==> "4"
s is stringified when it is used in str, so it is

 

3.5 Concatenation

It is often useful to merge two tokens into one while expanding macros. This is called token pasting or token concatenation. The ‘##’ preprocessing operator performs token pasting. When a macro is expanded, the two tokens on either side of each ‘##’ operator are combined into a single token, which then replaces the ‘##’ and the two original tokens in the macro expansion. Usually both will be identifiers, or one will be an identifier and the other a preprocessing number. When pasted, they make a longer identifier. This isn't the only valid case. It is also possible to concatenate two numbers (or a number and a name, such as 1.5 and e3) into a number. Also, multi-character operators such as += can be formed by token pasting.

However, two tokens that don't together form a valid token cannot be pasted together. For example, you cannot concatenate x with + in either order. If you try, the preprocessor issues a warning and emits the two tokens. Whether it puts white space between the tokens is undefined. It is common to find unnecessary uses of ‘##’ in complex macros. If you get this warning, it is likely that you can simply remove the ‘##’.

Both the tokens combined by ‘##’ could come from the macro body, but you could just as well write them as one token in the first place. Token pasting is most useful when one or both of the tokens comes from a macro argument. If either of the tokens next to an ‘##’ is a parameter name, it is replaced by its actual argument before ‘##’ executes. As with stringification, the actual argument is not macro-expanded first. If the argument is empty, that ‘##’ has no effect.

Keep in mind that the C preprocessor converts comments to whitespace before macros are even considered. Therefore, you cannot create a comment by concatenating ‘/’ and ‘*’. You can put as much whitespace between ‘##’ and its operands as you like, including comments, and you can put comments in arguments that will be concatenated. However, it is an error if ‘##’ appears at either end of a macro body.

Consider a C program that interprets named commands. There probably needs to be a table of commands, perhaps an array of structures declared as follows:

     struct command
     {
       char *name;
       void (*function) (void);
     };
     
     struct command commands[] =
     {
       { "quit", quit_command },
       { "help", help_command },
       ...
     };
It would be cleaner not to have to give each command name twice, once in the string constant and once in the function name. A macro which takes the name of a command as an argument can make this unnecessary. The string constant can be created with stringification, and the function name by concatenating the argument with ‘_command’. Here is how it is done:

     #define COMMAND(NAME)  { #NAME, NAME ## _command }
     
     struct command commands[] =
     {
       COMMAND (quit),
       COMMAND (help),
       ...
     };

 

注释：

##表示将它先后两个TOKEN链接为一个，如下三种结果为：

1. #define YNAME(n) y_##n_Y， 则YNAME(1)，表示变量y_n_Y

2. #define YNAME(n) y_n##_Y， 则YNAME(1)，表示变量y_n_Y

3. #define YNAME(n) y_##n##_Y， 则YNAME(1)，表示变量y_1_Y

 

宏定义什么时候替换

例如#define VAL 352*288，当c语言函数调用VAL时，是使用352*288，仍是101376哪？

咱们知道GCC编译源代码生成最终可执行的二进制程序，GCC后台隐含执行了四个阶段步骤。
GCC编译C源码有四个步骤：预处理-----> 编译 ----> 汇编 ----> 连接
如今咱们就用GCC的命令选项来逐个剖析GCC过程。

#include <stdio.h>

#define VAL 352*288

int main(void)
{

  printf("val:%d\n", VAL);
  return 1;
}

1）预处理(Pre-processing)
在该阶段，编译器将C源代码中的包含的头文件如stdio.h编译进来，用户能够使用gcc的选项”-E”进行查看。
用法:#gcc -E test_macro.c -o test_macro.i
做用：将test_macro.c预处理输出test_macro.i文件。

vim test_macro.i

int main(void)
{
    printf("val:%d\n", 352*288);

    return 0;
}

注释：VAL被替换为352*288

2)编译阶段(Compiling)
第二步进行的是编译阶段，在这个阶段中，Gcc首先要检查代码的规范性、是否有语法错误等，以肯定代码的实际要作的工做，在检查无误后，Gcc把代码翻译成汇编语言。用户能够使用”-S”选项来进行查看，该选项只进行编译而不进行汇编，生成汇编代码。
选项 -S
用法：[root]# gcc -S test_macro.i -o test_macro.s
做用：将预处理输出文件 test_macro .i汇编成 test_macro .s文件。

vim test_macro .s

.file   "test_macro.c"
        .section        .rodata
.LC0:
        .string "val:%d\n"
        .text
.globl main
        .type   main, @function
main:
.LFB0:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16 
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    $.LC0, %eax
        movl    $101376, %esi
        movq    %rax, %rdi
        movl    $0, %eax
        call    printf
        movl    $0, %eax
        leave
        .cfi_def_cfa 7, 8
        ret 
        .cfi_endproc
.LFE0:
        .size   main, .-main
        .ident  "GCC: (GNU) 4.4.7 20120313 (Red Hat 4.4.7-16)"
        .section        .note.GNU-stack,"",@progbits

注释：VAL的值为101376，即为352*288的结果

3)汇编阶段(Assembling)
汇编阶段是把编译阶段生成的”.s”文件转成二进制目标代码.
选项 -c
用法：[root]# gcc -c test_macro .s -o test_macro .o
做用：将汇编输出文件 test_macro .s编译输出 test_macro .o文件。

 

4）连接阶段(Link)
在成功编译以后，就进入了连接阶段。
无选项连接
用法：[root]# gcc test_macro.o -o test_macro.exe
做用：将编译输出文件 test_macro .o连接成最终可执行文件 test_macro .exe。

 

注释：

宏定义的表达式在编译阶段进行计算。