Working of these two pieces of code [duplicate] - c

Question

This question already has answers here:
Scope of #define preprocessor in C
(6 answers)
Closed 8 years ago.
Here are two pieces of C code, but I don't understand how they work:
Program 1 :
#include<stdio.h>
#define s 10
fun() {
#undef s
#define s 20
}
int main(){
printf("%d\n",s);
fun();
printf("%d\n",s);
return 0;
}
Output: 20
20
Program 2:
#include<stdio.h>
#define s 10
int main(){
printf("%d\n",s);
fun();
printf("%d\n",s);
return 0;
}
fun() {
#undef s
#define s 20
}
output: 10
10
What I know is preprocessor works before starting of main() and replaces all of its variables.
Here fun() is called after one printf(), so how are both program are outputting different values by changing the position of fun()?

Answer 1

Macro will be replaced in compile time itself. so code will be like this after preprocessing,
Case 1:
#include<stdio.h>
fun() {
}
int main(){
printf("%d\n", 20);//latest definition of s will be considered.
fun();
printf("%d\n",20);
return 0;
}
Case 2:
#include<stdio.h>
int main(){
printf("%d\n",10); //replaced with 10 only, because in this instance, there is no change in s
fun();
printf("%d\n",10);
return 0;
}
fun() {
//#undef s
//#define s 20 //no use in ur code.
}
fun_extra() { //Added for demo
printf("%d\n",s);//will be replaced by 20.
}

Answer 2

The preprocessor doesn't care about scope. It just goes through the file line by line, in order from top to bottom, and makes textual replacements. If something is #defined or #undefined, it takes effect from that line until the bottom of the file (or another preprocessor statement overrides it).

Answer 3

Preprocessor statements are not executable. They are... well, preprocessed. This means that the compiler will perform an initial, single pass and resolve all preprocessing definitions. If a preprocessing definition is located inside a C control structure, it will be executed regardless of the meaning of the C control structure. In other words, from the point of view of the preprocessor there is no C code. Just text (and other preprocessor statements).
In your case, in this first pass:
#include<stdio.h> // File stdio.h is included/copied
#define s 10 // Preprocessor symbol s is defined as 10
fun() { // Copied literally
#undef s // Preprocessor symbol s is undefined
#define s 20 // Preprocessor symbol s is defined as 20
} // Copied literally
int main(){ // Copied literally
printf("%d\n",s); // Copied with s substituted, ie. printf("%d\n",20);
fun(); // Copied literally
printf("%d\n",s); // Copied with s substituted, ie. printf("%d\n",20);
return 0; // Copied literally
} // Copied literally
So, the input that really gets compiled is:
// Empty line originally corresponding to #include
// Empty line originally corresponding to #define
fun() {
// Empty line originally corresponding to #undef
// Empty line originally corresponding to #define
}
int main(){
printf("%d\n",20);
fun();
printf("%d\n",20);
return 0;
}
In particular, note that the fun function does not contain any C instruction. Before pre-processing it did contain 2 pre-processing instructions, but:
They disappeared after pro-processing
They never really belonged to a function fun because at that point there was no function fun or any other C code. Just text and preprocessor statements.
This work is usually done silently and internally by C compilers. However, many of them have options to save the pre-processed source files. You should obtain a result like the above (except that #include<stdio.h> would expand into many blank lines, and some C code, which here I sinthesized as a single empty line).
The second case is left as an exercise to the OP.