Steps in C Program
The human-readable source code is converted into an executable program that the computer can run through a sequence of stages in a standard C program-development environment. The six stages of these procedures are usually edit, preprocess, compile, link, load, and execute. The general process is the same, even though the specifics may change based on the operating system and the tools utilized.
The stages of a typical C software development environment are broken down as follows:
Creating the Program (Editor)
- Editing a file in an editor program is the first step. The C program’s source code is written here by the programmer.
- Editors can be included in a larger software package known as an Integrated Development Environment (IDE) or run independently as standalone applications, as vi or emacs on Linux/Unix systems. IDEs with built-in editors include Borland C++, Code::Blocks, Turbo C, Apple Xcode, and Microsoft Visual Studio.
- Once the program has been typed and any necessary adjustments have been made, the source code is saved to a hard drive or other secondary storage medium.
- File names for C programs should finish in.c. For this step, it’s crucial to use a text editor rather than a word processor because word processors can introduce formatting codes that cause confusion for the compiler.
Preprocessing
- The program is compiled after the C preprocessor has finished running. On many platforms, the compiler has it conceptually built in.
- Preprocessor directives are special commands that start with the # symbol and are followed by the preprocessor.
- The source-code files of a program are altered by these commands. Typical operations include replacing different text with other text (using #define directives, frequently for constructing macros or symbolic constants) and adding the contents of other files (using #include directives, commonly for header files).
- Conditional compilation (#ifdef, #endif, #if, #else, #ifndef, #elif) and directives like #undef and #pragma are additional preprocessor capabilities that enable particular program segments to be included or excluded before to compilation based on conditions.
- A translation unit is created when the preprocessor makes changes to a copy of the source code in accordance with the instructions.
Compiling
- At this point, the compiler turns the C program’s translation unit into object code.
- Compilers first verify that statements follow language syntax and semantics.
- Syntax errors occur when the compiler finds a statement that violates language rules. They are also known as build-time errors or compile errors. Programmers must update the source file and correct the mistakes before attempting again, as the compiler usually stops the compilation process after displaying an error notice.
- The source code is converted into object code by the compiler if there are no syntactic or semantic mistakes. An assembler converts the assembly language into binary object code once the C Program code has been converted to assembly language on the majority of computers.
- An intermediate file containing the object code is usually saved with the.o extension on Unix/Linux systems and the.obj extension on Windows systems.
Linking
- C applications frequently make use of functions defined elsewhere, such in private libraries, open-source libraries, or the C standard library. Usually, the compiler creates object code with “holes” or references to these absent sections.
- To create a complete, executable image (without any missing bits), the linker merges the object code for these missing functions from libraries with the object code of the program.
- As part of the command used to compile the software, such as the Unix/Linux cc or gcc command, the linking step is frequently carried out automatically.
- The executable file is what is left over after the linking process. This file often has the same name as the source file, although on Windows systems it has an.exe extension. On most Unix/Linux systems, it is named a.out by default. The term “building” frequently refers to the full compilation and linking process.
Loading
- An executable image must be loaded into the computer’s memory by the operating system before a program can be run.
- The executable image is moved into memory by the loader program after it has been removed from disc.
- This stage also involves loading more program-supporting components from shared libraries into memory.
Execution
- Ultimately, the Central Processing Unit (CPU) of the computer carries out the program by carrying out each command individually.
- The main() function usually marks the start of program execution.
- The executable file name is usually typed at the command line by the user to launch the program.
- Runtime or execution-time errors are those that happen while the program is operating. Control-c can stop a running application in interactive environments like MS-DOS and UNIX.
IDEs like Visual Studio, Xcode, and Code:Development environments include blocks, command-line compilers like GNU gcc, Clang, and vendor-specific compilers (bcc, tcc, qc). The entire development process is simplified by IDEs, which often contain the editor, compiler, linker, and debugger.