If I declare a constant say
"#define MONTHS =12" in C I am aware that pre-processor directive will replace whereever MONTHS is used, but want to know if a memory is allocated to store 12??, if yes, what would be the label and what would be the datatype.
The syntax is actually:
#define MONTHS 12
No = sign allowed. And no memory is allocated in the compiled code for MONTHS, and it has no data type.
No memory is allocated for preprocessor symbols on their own. If you ever use it as a value somewhere it can cause relevant allocation.
For example:
char something[1024*MONTHS];// 1024*12 bytes
otherwise the constant never outlives the compilation time. And it has no datatype.
Isn't #define - simply find n replace by the preprocessor before it hits the compilation stage.. It replaces all instances of the symbol with the value throughout the source. Then the compiler takes over.
So don't think memory is allocated.
The whole point about the C pre-processor is that it makes it's replacements before any code is compiled. so #-defined constants aren't stored at the point they are defined, only when they are used.
You most likely want your define as such:
#define MONTHS 12 /* some code here... */ int payAnnual = payMonthly * MONTHS;
To answer your question, no memory will be used. The pre-processor is unaware of such concepts as variables and memory. It is essentially an automated text editor. It will replace any occurrence of the symbol MONTHS with 12.
Since the pre-processor is so dumb, it is generally preferable to use a const variable. This gives you the benefit of type-checking, and can make compiler errors easier to read. And so long as you declare it static, the variable will be optimized away. (If you don't declare a global variable static in C, by default, it will be exported, so the compiler can't optimize it away entirely.)
static const int MONTHS = 12;
They are used just like an actual integer, and the normal literal type for an integer is used in calculations where the macro name appears in the program.
Just as if you were to declare
#define FOO "bar"
Then occurences of FOO would be replaced with the typical usage of "bar" being a pointer to some location of the string constant in the program's object file mapped to memory.
There isn't really a difference.
The preprocessor simply makes symbolic changes to the source code. Hence the code would behave the same as if you had simply replaced all occurrences of MONTHS with 12 yourself. And consequently there is no memory impact in using it.
The use of pre compiler definitions is a great way of raising the level of abstraction of your code without memory of performance impact.
Regards
No,
weeks = 12 * 4;
Is exactly the same as:
weeks = MONTHS * 4;
Does 12 take memory? No, Therefore neither does MONTHS.
if 12 is allocated depends of the usage and got nothing to do with the preprocessor at all
Somefunction(MONTH);
would expand to
Somefunction(12);
12 here must ofc be stored somewhere, in this case it will be staticaly stored in the executable. The type will likely depend on what Somefunction take as an argument (or whatever the compiler decides fits best for this usage). There is no know label to '12'.
The preprocessoring is done before the actual compilation, as someone already wrote, it is like a automated texteditor. So the compilation stage is fully unaware of what the preprocessor did.