Advantage and disadvantages of #define vs. constants? [duplicate]

Answer 1

Explanation for #define:A #define is either an immediate value or a macro.

Explanation for constant:A constant is a value of any type which can never change.

You can delcare a pointer to a const, but not to a #define, although a #define could be a pointer for eg: #define ADDRESS ((int *)0x0012)

So why we should use constant is as follows:

• they obey the language's scoping rules
• you can see them in the debugger
• you can take their address if you need to
• you can pass them by const-reference if you need to
• they don't create new "keywords" in your program.

In short, const identifiers act like they're part of the language because they are part of the language.

Within a module, a C compiler could optimize a const as if it were a #define, if there are no pointers declared to the constant. In CPU terms, the const would become an "immediate" value. Other alternatives is that a const variable could be placed in the code area as opposed to the data area since it doesn't change. On some machines, declaring a ponter to a constant could cause an exception if you tried to modify the constant via the pointer.

There are cases where #define is needed, but you should generally avoid it when you have the choice. You should evaluate whether to use const or #define based on business value: time, money, risk.

Answer 2

the benefit of using define is once you define the variable for exp: #define NUMBER 30, all the code in main will use that code with value 30. If you change the 30 to 40 it will directly change all value in main which using this variable (NUMBER).

Answer 3

1. const produces an lvalue, meaning its address can be taken. #define doesn't.
2. #define can cause unintentional macro expansions, which can be a PITA to debug.
3. As mentioned by others, #define doesn't have a type associated with it.

In general, I'd avoid the preprocessor like the plague for anything I didn't have to use it for, mostly because of the possibility of unintentional expansion and because the ALL_CAPS convention for mitigating this is unbelievably ugly.

Answer 4

Constants allow you to specify a datatype, which is (usually) an advantage. Macros are much more flexible, and therefore can get you into much more trouble if you're not careful.

Best practice is to use constants as much as possible, and use #define only when you really need a macro, not just a named literal value.