28

The scope of #define is till the end of the file. But where does it start from?

Basically I tried the following code.

#include <stdio.h>
#include <stdlib.h>

#define pi 3.14

void fun();

int main()
{
    printf("%f \n", pi);
    #define pi 3.141516
    fun();
    return 0;
}

void fun()
{
    printf("%f \n", pi);
}

The output of the above program comes out to be

3.140000
3.141516

Considering preprocessing for main the value of pi should be 3.141516 and outside main 3.14. This is incorrect but please explain why.

Improve this question
5
  • 6
    Remember that it's PREprocessing. It does not know or care about the structure of your code, in the case of #define it is doing substitutions in the order that it sees them relative to what the most recent value of the #defined variable is. Commented Jun 16, 2011 at 22:55
  • 8
    This code is actually ill-formed: you cannot #define a macro with the same name as another macro that is currently defined unless their definitions are the same. So, the second #define pi makes the program ill-formed. You need to #undef pi first. Commented Jun 16, 2011 at 23:05
  • 2
    The scope of #define is till the end of the file. No, end of file or #undef of the same macro identifier. Commented Nov 14, 2013 at 21:10
  • 5
    BTW: Your value for pi is wrong. Commented Sep 27, 2016 at 7:57
  • keil.com/support/docs/2589.htm Commented Jan 21, 2019 at 20:21

6 Answers 6

Reset to default
30

The C preprocessor runs through the file top-to-bottom and treats #define statements like a glorified copy-and-paste operation. Once it encounters the line #define pi 3.14, it starts replacing every instance of the word pi with 3.14. The pre-processor does not process (or even notice) C-language scoping mechanisms like parenthesis and curly braces. Once it sees a #define, that definition is in effect until either the end of the file is reached, the macro is un-defined with #undef, or (as in this case) the macro is re-defined with another #define statement.

If you are wanting constants that obey the C scoping rules, I suggest using something more on the lines of const float pi = 3.14;.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

"or (as in this case) the macro is re-defined with another #define statement." In fact, the second #define without a preceding #undef makes the program ill-formed.
Note that const does not create a constant usable, for instance, in switch labels: it creates a read-only object. Example at ideone.com/f3aON
This is a good answer to the question raised but strictly speaking the #define does not have scope over the entire file. Specifically it would not modify pi in a string such as "the value of pi is 3" This would not become "the value of 3.14 is 3"
No, reaching the end of file does not cause macros to be undefined (the standard library wouldn't be able to provide any macros if this were the case). Macros stay defined until the corresponding #undef or the end of the entire translation unit.
11

The scope of a #define is from the occurrence, to the end of the file (or a corresponding #undef), regardless of any intervening C scopes.

Improve this answer

1 Comment

"The scope of a #define is from the occurrence, to the end of the file" - or if it is #undef'ed before EOF is reached.
4

When you have preprocessor question:

gcc -E foo.c > foo.i; vim foo.i

Improve this answer

2 Comments

Can you elaborate?
According to gcc --help, it is: Preprocess only; do not compile, assemble or link. That means that all #define clauses will be expanded and substituted in the code, but the code itself will not be compiled. In the code from the question, you would see literal 3.14 and 3.141516 instead of pi.
1

Here is what it roughly looks like after the preprocessor is done with your file:

 void fun();
 int main()
 {
    printf("%f \n",3.14);

    fun();
    return 0;
 }
 void fun(){
 printf("%f \n",3.141516);}

These are the lines that go to the compiler for compilation (I discarded much of the code for the sake of clarity, only kept what you coded). As the preprocessor replaces the #define directive with the text/value you provided, thus you don't see the #define directives anymore after preprocessing. So it is clear what is going to be printed on the console/terminal.

Improve this answer

Comments

1

The preprocessor doesn't have any concept of "scope"—it manipulates the text of the program, without any idea of what the text is.

A symbol is defined from its definition until the end of the compilation unit (a source file and the files it includes).

Improve this answer

Comments

0

As far as I know, the preprocessor uses #define statements in the order that it encounters them. In that case, your first printf statement correctly prints 3.14 and the second 3.141516 (is there a typo in the output from your program?).

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.