Contents|Index|Previous|Next

Concatenation

Concatenation means joining two strings into one. In the context of macro expansion, concatenation refers to joining two lexical units into one longer one. Specifically, an actual argument to the macro can be concatenated with another actual argument or with fixed text to produce a longer name. The longer name might be the name of a function, variable or type, or a C keyword; it might even be the name of another macro, in which case it will be expanded.

When you define a macro, you request concatenation with the special operator ## in the macro body. When the macro is called, after actual arguments are substituted, all ## operators are deleted, and so is any whitespace next to them (including whitespace that was part of an actual argument). The result is to concatenate the syntactic tokens on either side of the ##. 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) ();
    };

    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. What follows is an example of how it is done.

    #define COMMAND(NAME)   { #NAME, NAME ## _command }

    struct command commands[] =
    {
       COMMAND (quit),
       COMMAND (help),
       . . .
    };

The usual case of concatenation is concatenating two names (or a name and a number) into a longer name. But this isn’t the only valid case. It is also possible to concatenate two numbers (or a number and a name, such as 1.5 and e3) into a number. Also, multi-character operators such as += can be formed by concatenation. In some cases it is even possible to piece together a string constant. However, two pieces of text that don’t together form a valid lexical unit cannot be concatenated. For example, concatenation with x on one side and + on the other is not meaningful because those two characters can’t fit together in any lexical unit of C. The ANSI standard says that such attempts at concatenation are undefined, but in the GNU C preprocessor it is well defined: it puts x and + side by side with no particular special results.

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 *: the /* sequence that starts a comment is not a lexical unit, but rather the beginning of a “long” space character. Also, you can freely use comments next to ## in a macro definition, or in actual arguments that will concatenate, because the comments will be convert to spaces at first sight, and concatenation will later discard the spaces.