object-like macros 是一个简单的标记，它将会在预编译器被真正的代码片段所取代，最常用的方式，就是用来定义一些常量，例如：

#define BUFFER_SIZE       1024

上面的例子中定义了一个 token BUFFER_SIZE ，其值是 1024，其中：

• #define 是预编译器的指令，用了声明宏定义
• #BUFFER_SIZE 是宏定义的名字
• #1024 名字之后的部分是宏定义的展开

使用示例：

// Before preprocess
foo = (char *) malloc (BUFFER_SIZE);
// After preprocess
foo = (char *) malloc (1024);

function-like macros also starts with `#define' directive, but continued immediately with a pair of parentheses after the macro name.

#define lang_init()  c_init()
lang_init() //
     ==> c_init()

A function-like macro is only expanded if its name appears with a pair of parentheses after it. If you write just the name, it is left alone.

NOTE:
If you put spaces between the macro name and the parentheses in the macro definition, that does not define a function-like macro, it defines an object-like macro whose expansion happens to begin with a pair of parentheses:

#define lang_init ()    c_init()
lang_init() // after expanding:
     ==> () c_init()()

Function-like macros can take "arguments", just like true functions. To define a macro that uses arguments, you insert "parameters" between the pair of parentheses in the macro definition that make the macro function-like. The parameters must be valid C identifiers, separated by commas and optionally whitespace.

#define min(X, Y)  ((X) < (Y) ? (X) : (Y))
  x = min(a, b);          ==>  x = ((a) < (b) ? (a) : (b));
  y = min(1, 2);          ==>  y = ((1) < (2) ? (1) : (2));
  z = min(a + 28, *p);    ==>  z = ((a + 28) < (*p) ? (a + 28) : (*p));

Things to note:

• Space and comma

Leading and trailing whitespace in each argument is dropped, and all whitespace between the tokens of an argument is reduced to a single space. Parentheses within each argument must balance; a comma within such parentheses does not end the argument. However, there is no requirement for square brackets or braces to balance, and they do not prevent a comma from separating arguments. Thus,

macro (array[x = y, x + 1])

passes two arguments to `macro': `array[x = y' and `x + 1]'. If you want to supply `array[x = y, x + 1]' as an argument, you can write it as `array[(x = y, x + 1)]', which is equivalent C code.

• Empty arguments

  You can leave macro arguments empty; this is not an error to the

preprocessor (but many macros will then expand to invalid code). You cannot leave out arguments entirely; if a macro takes two arguments, there must be exactly one comma at the top level of its argument list. Here are some silly examples using `min':

min(, b)        ==> ((   ) < (b) ? (   ) : (b))
min(a, )        ==> ((a  ) < ( ) ? (a  ) : ( ))
min(,)          ==> ((   ) < ( ) ? (   ) : ( ))
min((,),)       ==> (((,)) < ( ) ? ((,)) : ( ))

min()      // error--> macro "min" requires 2 arguments, but only 1 given
min(,,)    // error--> macro "min" passed 3 arguments, but takes just 2

Whitespace is not a preprocessing token, so if a macro `foo' takes one argument, `foo()' and `foo( )' both supply it an empty argument.

• Strings in macro

  Macro parameters appearing inside string literals are not replaced by

their corresponding actual arguments.

#define foo(x) x, "x"
foo(bar)        ==> bar, "x"

'#' 用来将宏参数子串化。

'##' 用来连接 Token: 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.

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),
  ...
};

A macro can be declared to accept a variable number of arguments much as a function can. The syntax for defining the macro is similar to that of a function. Here is an example:

#define eprintf(...) fprintf (stderr, __VA_ARGS__)

This kind of macro is called "variadic". When the macro is invoked, all the tokens in its argument list after the last named argument (this macro has none), including any commas, become the "variable argument". This sequence of tokens replaces the identifier `__VA_ARGS__' in the macro body wherever it appears. Thus, we have this expansion:

eprintf ("%s:%d: ", input_file, lineno)
     ==>  fprintf (stderr, "%s:%d: ", input_file, lineno)

测试了几个预编译器，包括 GNU/Clang/VS ，他们对 '##' 都加了和 CPP 一样的特殊处理：

the `##' token paste operator has a special meaning when placed between a comma and a variable argument. If you write

#define eprintf(format, ...) fprintf (stderr, format, ##__VA_ARGS__)

and the variable argument is left out when the `eprintf' macro is used, then the comma before the `##' will be deleted. This does not happen if you pass an empty argument, nor does it happen if the token preceding `##' is anything other than a comma.

eprintf ("success!\n")
     ==> fprintf(stderr, "success!\n");

/user_files/tubocurarine/File/cpp_info4_20141010181450.zip