带防护的包含在内的标头

Question

Let's say I have a special header file which is designed to be included multiple times and generates different code depending on the value of some macro which must be defined before including it. For example, the following file dumb.h :

#define RETFUNC return_ ## VALUE
static inline int RETFUNC() {
  return VALUE;
}

You include it like:

#define VALUE 100
#include "dumb.h"
#define VALUE 200
#include "dumb.h"

and it generates two versions of the function like:

static inline return_100 {
  return 100;
}

static inline return_200 {
  return 200;
}

Great ¹ .

How can I make a header guard for this type of file? Without guards, if two different consumers of the header file both requested the same VALUE , you'd get an error since two identical versions of the return_* function would be generated.

Now a normal header guard like:

#ifndef DUMB_H_
#define DUMB_H_
...
#endif // DUMB_H_

Isn't going to work since it would only effectively include the file once (the #include sequence above would generate the _100 version of the function, but not the _200 version).

In principle I would like to generate the name of a macro using token pasting, to check as the guard, like:

#ifndef DUMB_H_ ## VALUE
#define DUMB_H_ ## VALUE
...

But token pasting can't be used like that (outside of macro expansion).

Any there any other options to prevent this file from being included multiple times with the same VALUE , but to still allow the body to be effectively included once for each different VALUE requested?

---

¹ Not great in the sense that this is a good pattern or anything like that, but in it that it at least appears to work.

Answer 1

With the explanation in comment 1 and comment 2 , I think the normal process is more like this. I'm going to use a type as the argument, and generate a 'minimum' function for the different types:

dumb.h

#ifndef DUMB_H_INCLUDED
#define DUMB_H_INCLUDED

#define MIN_TYPE(x) \
    static inline x min_ ## x(x v1, x v2) { return (v1 < v2) ? v1 : v2; }

#endif /* DUMB_H_INCLUDED */

Consumer code

#include "dumb.h"
#include <inttypes.h>

MIN_TYPE(int)          // No semicolon; no empty declaration!
MIN_TYPE(double)
MIN_TYPE(uint64_t)

void write_minima(int i1, int i2, double d1, double d2, uint64_t u1, uint64_t u2)
{
    printf("Minima: (%d, %g, %" PRIu64 ")\n",
           min_int(i1, i2), min_double(d1, d2), min_uint64_t(u1, u2));
}

This does not stop you from trying to instantiate the same function twice in a single TU (translation unit), but the compiler will object if you do that. And frankly, letting the compiler do the complaining is simpler than trying to make the C preprocessor spot that you've screwed up and rectify your mistake.

If the C code will be generated by another program, then you need to ensure that the code generator keeps a track of what it has requested and ensure that it doesn't double generate the code.