Is it possible to use #define constant integers in string literals?

[traynor]

Hello,

I've been searching for some time now and have been unable to find an answer to my question. Essentially, I would like to be able to do this:

#define WIDTH 5
 
printf("%" WIDTH "d", some_int);

Of course that doesn't work.

If you have a function-like macro, you can prefix its arguments with '#' and the preprocessor will wrap them with quotation marks (as well as perform escaping and other features.) Is there a way to use the same functionality with object-like macros?


Thanks

[traynor]

I managed to find a solution. I am not sure how it works, but it is the standard way of doing it. The solution comes from an example in the C:1999 standard (PDF, pg. 154) that does exactly what I'm looking for. Here's the excerpt:

#define hash_hash # ## #
#define mkstr(a) # a
#define in_between(a) mkstr(a)
#define join(c, d) in_between(c hash_hash d)
char p[] = join(x, y); // equivalent to
                       // char p[] = "x ## y";

The in_between() macro is why this works. If you just call mkstr() directly, you get "x hash_hash y". You need to define two function-like macros, one that calls the other, in order to turn an object-like macro into a string literal.

[gpraghuram]

I managed to find a solution. I am not sure how it works, but it is the standard way of doing it. The solution comes from an example in the C:1999 standard (PDF, pg. 154) that does exactly what I'm looking for. Here's the excerpt:

#define hash_hash # ## #
#define mkstr(a) # a
#define in_between(a) mkstr(a)
#define join(c, d) in_between(c hash_hash d)
char p[] = join(x, y); // equivalent to
                       // char p[] = "x ## y";

The in_between() macro is why this works. If you just call mkstr() directly, you get "x hash_hash y". You need to define two function-like macros, one that calls the other, in order to turn an object-like macro into a string literal.

Whatever u have used are trigraph sequences.
You have to check whether the current ANSI standard supports this

Raghuram

[traynor]

Whatever u have used are trigraph sequences.
You have to check whether the current ANSI standard supports this

Raghuram

I don't think you're right. According to the same document, "for both object-like and function-like macro invocations, before the replacement list is reexamined for more macro names to replace, each instance of a ## preprocessing token in the replacement list (not from an argument) is deleted and the preceding preprocessing token is concatenated with the following preprocessing token."

You can get the same effect without using that token:

#define WIDTH 10
#define mkstr(a) # a
#define in_between(a) mkstr(a)
printf("%" in_between(WIDTH) "d", some_int);

The last line will be processed as 'printf("%" "10" "d", some_int)'.

The only odd token in that example is the '#' before the identifier in the replacement list of 'mkstr()'. The document says "if, in the replacement list, a parameter is immediately preceded by a # preprocessing token, both are replaced by a single character string literal preprocessing token that contains the spelling of the preprocessing token sequence for the corresponding argument" The trigraph sequence for '#' is '??=', so I am pretty sure that there are no trigraph sequences in that example.