C ++：类似于复杂函数的宏定义

Question

While reading node.js source code, I came across a macro that I just can't understand.

// Strings are per-isolate primitives but Environment proxies them
// for the sake of convenience.
#define PER_ISOLATE_STRING_PROPERTIES(V)                            \
V(address_string, "address")                                        \
V(args_string, "args")                                              \
V(argv_string, "argv")                                              \
V(async, "async")                                                   \
V(async_queue_string, "_asyncQueue")                                \
V(atime_string, "atime")                                            \
...

*I assume the variables (eg address_string) are defined in an included header file.

And it goes on like this for a while. I looked further down the code to see how it could be used.

#define V(PropertyName, StringValue)                                \
inline v8::Local<v8::String> PropertyName() const;
PER_ISOLATE_STRING_PROPERTIES(V)
#undef V

From what I can understand, PER_ISOLATE_STRING_PROPERTIES(V) is a function-like macro that takes another function-like macro V as a parameter. I don't get the following:

1- PER_ISOLATE_STRING_PROPERTIES(V) is given multiple definitions, and I don't get how these are used in the code (eg when PER_ISOLATE_STRING_PROPERTIES(V) is seen in code by the preprocessor, how does it know which definiton of V to replace it with?)
2- I don't get how the V function is used.

Answer 1

Let's run ONLY the processor over the following code:

// Strings are per-isolate primitives but Environment proxies them
// for the sake of convenience.
#define PER_ISOLATE_STRING_PROPERTIES(V)  \
  V(address_string, "address")            \
  V(args_string, "args")                  \
  V(argv_string, "argv")                  \
  V(async, "async")                       \

  #define V(PropertyName, StringValue)     \
  inline v8::Local<v8::String> PropertyName() const;
  PER_ISOLATE_STRING_PROPERTIES(V)
#undef V  

gcc - E code.cpp

This prints out:

inline v8::Local<v8::String> address_string() const; inline v8::Local<v8::String> args_string() const; inline v8::Local<v8::String> argv_string() const; inline v8::Local<v8::String> async() const;  

C++ is a non-whitespace sensitive language, so it's essentially this:

inline v8::Local<v8::String> address_string() const; 
inline v8::Local<v8::String> args_string() const; 
inline v8::Local<v8::String> argv_string() const; 
inline v8::Local<v8::String> async() const; 

This technique is known as X Macros

Personally, I don't see the harm in listing out all of the code that you can't easily put inside a for loop, but you can see how this technique is being used to avoid specifying the rest of the function signature again and again. Macros don't obey scope, and I'd much rather do a search and replace to make changes, then play with macros. Just the fact that you asked a question about this, proves that it hinders readability as well.

tldr; The processor is being used to generate code.