How to properly use defines that are parameters to other defines? C++ - c++

Question

I have the following define macros:
#define NHID 5
#define NENT 10
#define NOUT 4
#define NWEIS (NENT + 1) * NHID + (NHID + 1) * NOUT
So everytime that the compiler finds a "NWEIS", it will replace "NEWIS" for "(NENT + 1) * NHID + (NHID + 1) * NOUT". But that is not what I want. I want it replace "NWEIS" by the actual value = 79, without having to declare extra variables in the memory. Is there a decent way to do this?

Answer 1

Macro replacement is mostly1 an iterative process.
What you will get, following macro substitution is an expression with the constants. And any decent compiler will be able to fold those constants (evaluate them at compile time) to give you the single value of 79.
For example, consider the program:
#define NHID 5
#define NENT 10
#define NOUT 4
#define NWEIS (NENT + 1) * NHID + (NHID + 1) * NOUT
int main (void) { return NWEIS; }
here's the pre-processor output from gcc -E:
int main (void) { return (10 + 1) * 5 + (5 + 1) * 4; }
and here's the relevant assembler code line it generates with gcc -S (the return value is placed into the eax register):
movl $79, %eax
Having said that, there are precious few reasons to use macros any more since you have constant "variables", inline suggestions to the compiler, enumerated types and so forth, all things that macros used to be very useful for.
I still find myself reaching for macros for quick'n'dirty code of course, but that's mostly because I'm an old codger, forged in the early C days before we even had prototypes :-)
It may be worthwhile rethinking your use of them as well, since you can replace it with something like:
const int nhid = 5;
const int nent = 10;
const int nout = 4;
const int nweis = (nent + 1) * nhid + (nhid + 1) * nout;
A smart compiler should still be able to optimise the calculations away at compile time and you'll most likely find that the variables are available in the debugger for you, something that often doesn't happen with macros.
1 Full details can be found in the C++11 standard, section 16.3 Macro replacement.
Suffice to say there are certain uses of # and ## within a macro that prevent further replacement of that token (the former replaces the token with a character string literal and the latter combines multiple tokens into a different token).
Since you're not using those, it's irrelevant here.

Answer 2

The macros you are using do not cost you extra memory. You have already acheived what you want.
Let's look at what a reasonable compiler will do.
Suppose you have this code.
#define NHID 5
#define NENT 10
#define NOUT 4
#define NWEIS (NENT + 1) * NHID + (NHID + 1) * NOUT
int f()
{
return NWEIS;
}
A reasonable compiler will obviously expand it into:
int f()
{
return (NENT + 1) * NHID + (NHID + 1) * NOUT;
}
The next step will than be:
int f()
{
return (10 + 1) * 5 + (5 + 1) * 4;
}
As this arithmetic expression consist of hard-coded numbers (constant expression) only, the compiler can treat the whole thing as a constant too.
int f()
{
return 79;
}
Note that this function is so small, a reasonable compiler will try its best to in-line the function.
However, it is much more preferable to do this:
constexpr int NHID = 5;
constexpr int NENT = 10;
constexpr int NOUT = 4;
constexpr int NWEIS = (NENT + 1) * NHID + (NHID + 1) * NOUT;

Answer 3

Just use
const int NHID = 5;
const int NENT 10;
const int NOUT 4;
const int NWEIS = (NENT + 1) * NHID + (NHID + 1) * NOUT;
A good optimizer will substitute these values at compile-time and not place any variables in memory, unless you do something such as take their address. Then you have the type safety and scoping of C++ without the macro evilness.
(Upper case names are by convention reserved for macros, so you may want to rename them slightly)