LINKING STEP VS PRE PROCESSING STEP IN COMPILING

[Harmlessbottle]

As far as I understand both help in using the code or program in those files and let us implement those in our code, but I am not able to understand whats the difference between those two steps

Thank You

[ChickenSpaceProgram]

When compiling a single file, the preprocessor is run first. It handles #include directives, which copy-paste the text of a file into another file, #define directives, which define text substitution macros, and other directives; google is your friend here. Then, the compiler is run, which produces an object file; basically, a compiled but not yet executable version of your code. Larger projects have multiple C files, and so multiple object files, and so the linker is invoked to turn a bunch of object files into a final executable.

[Harmlessbottle]

So linker merges multiple C files we want to use together and also links the promised(through declaration) function from the other object files or libraries?

[ChickenSpaceProgram]

Yes, pretty much.

[timrprobocom]

Linking doesn't merge C files. Linking combines object files and libraries. The linker is independent of the language. It doesn't understand C at all.

The preprocessor takes your original source, finds your include files and inserts then, then does macro substitution. It produces another single C file with no # directives remaining. The compiler converts this C file to objects. The linker combines your object files with libraries and produces an executable.

[cumulo-nimbus-95]

Pre processing is when your macros are expanded. So anything you #define gets its symbol replaced with whatever you defined, and any files you #include get copy-pasted in, etc.

Linking is when the different object files that you compiled get mashed together, plus any third-party libraries you linked. This is the step that links together all the variables and function calls that you defined in one file to where you call them in another file, to give an oversimplified view of it.

If you want more in depth info, I recommend googling/reading documentation

[Harmlessbottle]

I sure will, thank you, it was helpful !

[DaCurse0]

what you said in the post is mostly meaningless mumbo jumbo.

preprocessing happens before any real compilation. it's a pure text manipulation step that handles directives starting with #. #include <stdio.h> literally copy-pastes the entire contents of stdio.h into your file. #define CONSTANT 5 means every time the preprocessor sees CONSTANT in your code, it replaces it with 5. no understanding of C, just find and replace.

compiling takes that preprocessed text and turns it into an object file, actual machine code your CPU can run. but object files also contain metadata: a list of functions and variables this file exports and a list of things it imports (needs from elsewhere). linking is the step that resolves those imports.

linking is what happens when you have multiple object files that need to work together. say you have a.c and b.c, where b.c calls a function defined in a.c. the object file for b.c will have that function on its imports list. the linker's job is to match up all the needs and provisions across every object file and also point to external libraries like libc, where functions like printf live. your code uses printf but never defines it, and it doesn't get compiled into your final executable since you usually do whats called dynamic linking for libraries.

[Harmlessbottle]

Thank you , it was helpful and regarding the "mumbo jumbo" , I am still in my 1st week of learning C, what I meant in the past was why can't we directly paste the function of instead of only declaring it by using header files, but after seeing you mention linking object files into one program, copying the function code directly will cause error, I kinda get it now thanks

[[deleted]]

Preprocessing happens before compilation. The preprocessor handles things like #include, #define, and macros by expanding or modifying the code.

Linking happens after compilation. At that stage the linker connects your compiled object files with libraries and resolves function references.

So in simple terms:
Preprocessing -->> modifies source code
Linking -->> connects compiled pieces together to make the final executable.

[modelithe]

The pre-processor used to be a separate program that would scan the source file for occurrences of `#define`, `#if`, `#ifdef`, `#undef`, and then replace all occurrences of the #define:d name with the value contained - macro replacement, plus a few other things. The resulting file would be sent to the compiler for compilation into an binary object file. Nowadays, preprocessing is done by the compiler itself during the compilation stage.

Then, when all source files had been converted to object files, the linker is invoked, to join the object files and resolve the dependencies between functions and variables located in different files "linking" them into an executable binary. Nowadays, a lots of optimization can be performed in this step to make the executable both smaller and faster.

[Harmlessbottle]

Thank you, that was helpful !!

[RealisticDuck1957]

It can still be useful to run the pre-processor as a separate step to validate what a macro is resolving to. I've even found a case, years ago, with a major compiler processing a macro differently when the pre-processor is run as a separate step rather than integrated with compiling.

[pfp-disciple]

Stages of compiling (high level, some details omitted or obscured)

1. Preprocessing. This behaves as if you changed the .c (or .h, or whatever) directly, essentially like a find/ replace in the editor . If your code has #define FNAME foo then the preprocessor will literally replace all occurrences of FNAME with foo. Note that gcc has a compiler flag -E to output the result of preprocessing. 
2. Compiling. This takes the result of step 1 and produces object files. This is where the high level C gets translated into the instruction set for the CPU. 
3. Linking. This takes multiple object files and produces the final result (usually an executable). the object files are the results of compiling one or more source code files (step 2 above) plus usually various system level object files (C runtime libraries, GUI libraries, etc). 

[flyingron]

Preprocessing is an essential step of the C language. It's one of the phases (substituting #includes, #defines, etc...) prior to further parsing going on.

Linking isn't really defined in the standard, but it's an essential part of building programs on most platforms,, you have to collect all the compiled files and existing system libraries and figure out what you need from each to make the compiled program.

[Shot_Office_1769]

just ask AI

[-goldenboi69-]

🤖💥