Macro inside enum in C - c

Question

While trying to write a macro inside an enum, in C.
We have to sometimes write name of macro, above macro definition, why ?
#include <stdio.h>
enum month {
MSD //If I remove or comment this line, code does not work, why?
#define MSD 7
};
void main() {
printf("%d\n", MSD);
}
If we remove the 5th line of code, i.e. "MSD". We get error
empty enum is invalid. Why is this happening, can anyone explain, please ?

Answer 1

Macros and enums are separate things. Most importantly, a macro only exists at compile time so the preprocessor will replace all instances of MSD in the following code with 7 exactly as if you'd done a find-and-replace in your editor. Enums, on the other hand, exist at runtime and are generally numeric values mapped to symbols.
Now, with your code as you have it the MSD in your printf("%d\n", MSD); is replaced with 7 at compile time so the enum is never actually used. If you remove the 5th line of code the compiler sees an empty enum because the #define MSD 7 macro is filtered out by the preprocessor leaving nothing else inside the enum.

Answer 2

If intention is to define a enum. we can define as below.
(we can define MSD in form of enum of a #define, either one of this is required to use "MSD" in code for value 7)
#include <stdio.h>
enum month {
MSD = 7,
TST = 1 // added just for ref
};
// in linux requires int main() { <code> return 0;}
void main() {
printf("enum MSD == %d\n", MSD);
}

Answer 3

I was reading a source code of header file and wondered why have they written macros that way, in which I have posted
I think you may have misread a header file that was doing this slightly different thing:
enum thing_enum {
THING_ONE = 1,
#define THING_ONE THING_ONE
THING_TWO,
#define THING_TWO THING_TWO
// etc
};
This is the same as writing a normal enum declaration
enum thing_enum {
THING_ONE = 1,
THING_TWO,
// etc
};
and then, also, defining each enumerator as a macro that expands to itself:
#define THING_ONE THING_ONE
#define THING_TWO THING_TWO
// etc
Written this way, it should be clearer why you get an error when you comment out the ‘MSD’ line in your code: the #define doesn’t contribute anything to the definition of the enum, so you have an enum with no values, which the language does not allow.
Header files do this odd-looking thing because it makes each THING_ constant be both a macro and an enum value, which means you can use all the features of enum to set their values (e.g. in my example THING_TWO is equal to 2 without my having had to say so explicitly) and the names will be made visible to the debugger, but it’s still possible to check for the existence of a particular constant with #ifdef.
The disadvantages are that it doubles the length of the definition of the set of constants, you cannot make the type of each constant be anything other than int, and the constants cannot be used in an #if expression (except as the argument of defined).
(Note: A macro that expands to itself does not put the preprocessor into an infinite loop. THING_ONE is replaced with THING_ONE once and then the preprocessor moves on to the next token.)

Answer 4

MSD has nothing do with declaring above #define MSD 7, the reason for error is that enum{ }; should not be empty.
you get the below error if enum is empty.
main.c:12:1: error: empty enum is invalid
};
Try declaring another enum value there instead of MSD, it will work as shown below.
#defines are text replacements, they dont need any declarations, just definitions.
#include <stdio.h>
enum month {
x = 0
//MSD //If I remove or comment this variable declaration, code does not work, why?
#define MSD 7
};
void main() {
printf("%d\n", MSD);
}