stringification

After reading about VA_NARG I tried to implement function overloading depending on number of arguments in C using macros. Now the problem is: void hello1(char *s) { ... } void hello2(char *s, char *t) { ... } // PP_NARG(...) macro returns number of arguments :ref to link above // does not work #define hello(...) hello ## PP_NARG(__VA_ARGS__) int main(void) { hello("hi"); // call hello1("hi"); hello("foo","bar"); // call hello2("foo","bar"); return 0; } I've read this from C-faq. But still could not get it to work... Jens Gustedt This is because of the evaluation rules for macros. You would

In one of the answers (and its comments) on How to convert an int to string in C the following solution is given char str[ENOUGH]; sprintf(str, "%d", 42); in the comments caf mentions that ENOUGH can be determined at compile time with: #define ENOUGH ((CHAR_BIT * sizeof(int) - 1) / 3 + 2) I get the + 2 because you need to be able to display the minus sign and null terminator but what is the logic behind the other part? Specifically CHAR_BIT ? If int type is 32-bit, how many bytes do you need to represent any number (without sign and null terminator)? If int type is 32-bit the maximum int value

I have been trying to implement a function macro in C that prepends "DEBUG: ", to the argument, and passes its arguments to printf: #define DBG(format, ...) printf("DEBUG: " #format "\n", __VA_ARGS__) This gives me this error in gcc: src/include/debug.h:4:70: error: expected expression before ‘)’ token #define DBG(format, ...) printf("DEBUG: " #format "\n", __VA_ARGS__) ^ Supposedly, it should stringise format, and pass its variable arguments to printf, but so far I can't get past this error. EDIT After giving up on stringising arguments, and double-hashing ( ## ) __VA_ARGS__ I now have this

What is a##b & #a ? #define f(a,b) a##b #define g(a) #a #define h(a) g(a) main() { printf("%s\n",h(f(1,2))); //how should I interpret this?? [line 1] printf("%s\n",g(f(1,2))); //and this? [line 2] } How does this program work? The output is 12 f(1, 2) now I understand how a##b & #a work. But why is the result different in the two cases (line 1 and line 2)? The ## concatenates two tokens together. It can only be used in the preprocessor. f(1,2) becomes 1 ## 2 becomes 12 . The # operator by itself stringifies tokens: #a becomes "a" . Therefore, g(f(1,2)) becomes "f(1,2)" when the preprocessor is

If I add a macro "FOO=bar" under GCC_PREPROCESSOR_DEFINITIONS (or Preprocessor Macros if you use XCode"), what would be the best way to access the value of "FOO"? Currently, I use the clumsy: #define MACRO_NAME(f) #f #define MACRO_VALUE(f) MACRO_NAME(f) #ifdef FOO NSLog(@"%s", MACRO_VALUE(FOO)); #else NSLog(@"undefined"); #endif This will output "bar" Surely, there must be a better/cleaner way? What you are doing is the way to stringize (or stringify ) macro values. The indirection is unavoidable. This is even mentioned in the GCC preprocessor manual section that Rob linked to. NSLog(@"%s",

Consider this: #define STRINGIFY(A) #A If I then later write: STRINGIFY(hello) Is the compiler actually seeing this: #hello I think it is that additional hash in front of #A that is confusing me. No, the compiler will put the argument between quotes, resulting in this: "hello" However, beware that macro substitution doesn't take place near # and ## , so if you really need to stringify the argument ( even if it's another macro ) it's better to write two macros, the first one to expand the argument and the other one to add quotes: #define STRINGIFY(x) STRINGIFY_AUX(x) #define STRINGIFY_AUX(x) #x