Why use macro when same job is done by a variable? in C language?

Question

I don't see the need of using macro to define something , say in below example:

#define TELEPHONE 443 //why use this

int telephone = 443; //when same job is done by a regular variable

why would any one use macro for defining (declaring variable in C language) ? as in above scenario?

Answer 1

Why would any one use macro for defining (declaring variable in C language) ?

The macro does not define a variable, it defines a constant. Your C program that uses TELEPHONE that's #defined is indistinguishable to the compiler from a program that contains the hard-coded value 443.

Unlike int telephone variable, the TELEPHONE macro cannot be changed at run-time, and does not have an address.

Finally, it is possible to provide values for macros on the command line when calling the compiler - something impossible to do when you are dealing with C variables. Instead of defining #define TELEPHONE 443 you could pass the value on the command line, like this:

gcc -DTELEPHONE=443 myprog.c

Answer 2

Using a variable takes up space in the final image, which may not be required or desired (e.g. in embedded applications), whereas a define is handled strictly by the compiler (preprocessor).

Answer 3

There are several cases when a macro is more appropriate. The top of my head are:

1.To define a constant:

#define PI 3.1415926

2.To use as a constant expression.

#define BUFSIZE 1024

later you can use

int buffer[BUFSIZE];

This job cannot be done even if you use const int bufsize = 1024; (without using variable length array)

---

EDIT:

To clarify the use of const from the comment, in this code:

int main()
{
    const int x = 5;
    int array[x]; 
    return 0;
}

array is actually a variable length array, compile it with gcc test.c -std=c89 -pedantic, will generate the warning:

warning: ISO C90 forbids variable-size array `array'

The problem is, const variable in C isn't a constant expression, this is exactly my point of using #define in this situation. And this is one of the differences between C and C++.

Reference: C FAQ

Answer 4

dasblinkenlight pretty much covers it but I would just clarify some things they say, macros don't really define constants, you do that with the const modifier, and you should be using that most of the time. A macro defines substitution text, the only thing it knows about the language you are writing in is its use of spaces. So for macros you can do stuff like this

#define CODE_SNIPPET 10; i++ ) printf( "Hello %d\n"

for( int i = 0; i < CODE_SNIPPET , i );

which before being passed to the parser would be convert by the preprocessor to

for( int i = 0; i < 10; i++ ) printf( "Hello %d\n" , i );

Which is very powerful, but obviously open for abuse. I very rarely if ever use macros for constants, instead I will define the values as const in a .c file and then declare it extern in the header like

const int kAnswerToEveryThing = 42;    // .c file

extern const int kAnswerToEveryThing;        // .h file

I have one project that I use macros quite a bit, this is in Objective-C not c, but the macro system is identical and I have defined macros that expand out into class methods which add meta data to a class to be used by my library, its to do the same functionality as Java's annotations.