CODEWITHSUNDEEP
cc-preprocessor
Techievent.in
Techievent.in

Reputation: 85

Can i write preprocessor directives anywhere in my c program?

Is it mandatory to write #include at the top of the program and outside the main function?

I tried using #define preprocessor inside the main function and it worked fine with only one exception..that being the constant which i defined using the define directive can be used only after the line #define For instance say printf("%d",PI); #define PI 3.14will give error "Undefined symbol PI". But in the following code i did not encounter any error 

#define PI 3.14 
printf("%d",PI);

Is this because C is a procedural language and procedural languages implements top down approach?

Also i would like to know that can we use only #define inside the main function or other preprocessor directives too? If we can use then which ones? Or is it the other way around, instead of #include we can use all the preprocessor directives in the main function?

Upvotes: 4

Views: 4938

Answers (4)

Kevin Boone
Kevin Boone

Reputation: 4307

The trick here is to realize that # directives have traditionally been interpreted by a pre-processor, that runs before any compilation. The pre-processor would produce a new source file, which was then compiled. I don't think any modern compiler works that way by default, but the same principles apply.

So when you say 

#include "foo.h"

you're saying "insert the entire contents of foo.h into my source code starting at this line."

You can use this directive pretty much anywhere in a source file, but it's rarely useful (and not often readable) to use it anywhere other than at the start of the source.

Upvotes: 1

jxh
jxh

Reputation: 70382

The pre-processor does its work before the compiler performs the source code translation into object code. Pre-processing is mostly a string replacement task, so it can be placed just about anywhere in your code. Of course, if the resulting expansion is syntactically incorrect, the expanded source code will fail to compile.

A commonly tolerated practice is to embed conditional compilation directives inside a function to allow the function to use platform specific APIs.

void some_wrapper_function () {
#if defined(UNIX)
    some_unix_specific_function();
#elif defined(WIN32)
    some_win32_specific_function();
#else
    #error "Compiled on an unsupported platform"
#endif
}

By their nature, the directives themselves normally have to be defined at the beginning of the line, and not somewhere in the middle of source line. But, defined macros can of course appear anywhere in the source, and will be replaced according to the substitution rules defined by your directives.

Upvotes: 1

o11c
o11c

Reputation: 16026

The only place you can't put a preprocessor directive is in a macro expansion. The sole exception is #pragma, which can also be written _Pragma().

This has nothing to do with "procedural", but due to the fact that C is defined in terms of 8 translation phases, each of which is "as-if" fully-completed before the next phase. For more details, see the C11 standard, section 5.1.1.2.

One example of when it is useful to use preprocessor directives after the start of a file is for the "X Macro" technique (which many people only know as "those .def files").

Upvotes: 5

Charles Srstka
Charles Srstka

Reputation: 17040

Preprocessor directives work pretty much anywhere. Of course, you can make your code confusing pretty easily if you abuse this.

Upvotes: 1

Related Questions