It is simply a macro that expands to, well, nothing. However, now that the macro has been defined you can check with #if defined (or #ifdef) whether it has been defined. #define FOO int main(){ FOO FOO FOO printf(“Hello world”); } will expand to int main(){ printf(“Hello world”); } There are certain situations where this … Read more
Yes. The preprocessor concatenation operator (##) will cause issues, for example: #define _add_penguin(a) penguin ## a #define add_penguin(a) _add_penguin(a) #define WIDTH (100) #define HEIGHT 200 add_penguin(HEIGHT) // expands to penguin200 add_penguin(WIDTH) // error, cannot concatenate penguin and (100) Same for stringization (#). Clearly this is a corner case and probably doesn’t matter considering how WIDTH … Read more
You can demonstrate the difference by doing: #define FOO 0 #if FOO // won’t compile this #endif #ifdef FOO // will compile this #endif #if checks for the value of the symbol, while #ifdef checks the existence of the symbol (regardless of its value).
The relevant steps of macro expansion are (per C 2011 [n1570] 6.10.3.1 and C++ 1998 16.3.1): Process tokens that are preceded by # or ##. Apply macro replacement to each argument. Replace each parameter with the corresponding result of the above macro replacement. Rescan for more macros. Thus, with xstr(foo), we have: The replacement text, … Read more
You can use the -U option with gcc, but it won’t undefine a macro defined in your source code. As far as I know, there’s no way to do that.
#define has many different applications, but your question seems to be about one specific application: defining named constants. In C++ there’s rarely a reason to use #define to define named constants. #define is normally widely used in C code, since C language is significantly different from C++ when it comes to defining constants. In short, … Read more
The #define directive is a preprocessor directive; the preprocessor replaces those macros by their body before the compiler even sees it. Think of it as an automatic search and replace of your source code. A const variable declaration declares an actual variable in the language, which you can use… well, like a real variable: take … Read more
There is a rather clever solution: #define MACRO(X,Y) \ do { \ cout << “1st arg is:” << (X) << endl; \ cout << “2nd arg is:” << (Y) << endl; \ cout << “Sum is:” << ((X)+(Y)) << endl; \ } while (0) Now you have a single block-level statement, which must be followed … Read more
Another alternative would be to declare a struct to hold all your functions, and then define your functions statically. Then you’d only have to worry about name conflicts for the global name struct. // foo.h #ifndef FOO_H #define FOO_H typedef struct { int (* const bar)(int, char *); void (* const baz)(void); } namespace_struct; extern … Read more
Unfortunately, the original ANSI C Specification specifically excludes any Preprocessor features in section 4 (“This specification describes only the C language. It makes no provision for either the library or the preprocessor.”). The C99 specification handles this explicity, though. The comments are replaced with a single space in the “translation phase”, which happens prior to … Read more