Structure of a C Program

Introduction

Every C program follows a standard, well-defined structure. Understanding this structure is essential because the compiler processes each section in a specific order. A well-structured C program is easier to read, debug, and maintain.

Sections of a C Program

A C program is typically divided into the following sections:

1. Documentation Section

• Contains comments that describe the purpose of the program, author name, date, etc.
• Comments are ignored by the compiler.
• Single-line comment: // comment
• Multi-line comment: /* comment */

/* Program to add two numbers
   Author: Ram
   Date: 2081 */

2. Preprocessor Directives

• Lines that begin with # are processed before compilation.
• #include is used to include header files (libraries).
• #define is used to define constants or macros.
• These directives make library functions like printf() and scanf() available to the program.

#include <stdio.h>
#define PI 3.14

3. Global Declarations

• Variables or functions declared outside all functions are called global.
• They are accessible throughout the entire program.

int count = 0;   /* global variable */

4. main() Function

• The main() function is the entry point of every C program.
• Execution always begins from main().
• It returns an integer value to the operating system.
• return 0 signals that the program ended successfully.
• Curly braces { } define the body of the function.
• Every statement inside must end with a semicolon (;).

int main()
{
    /* statements */
    return 0;
}

5. User-Defined Functions

• Functions written by the programmer to perform specific tasks.
• They are defined outside main() but can be called from main() or other functions.
• They help in making the program modular and reusable.

int add(int x, int y)
{
    return x + y;
}

Complete Example

The following example demonstrates all sections of a C program:

/* Program to add two numbers and display the result */   /* 1. Documentation */

#include <stdio.h>                                        /* 2. Preprocessor directive */

int result;                                               /* 3. Global declaration */

int add(int x, int y);                                    /* Function prototype */

int main()                                                /* 4. main() function */
{
    int a, b;
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    result = add(a, b);
    printf("Sum = %d\n", result);
    return 0;                                             /* Signals successful end */
}

int add(int x, int y)                                     /* 5. User-defined function */
{
    return x + y;
}

Sample Output

Enter two numbers: 5 3
Sum = 8

Explanation of Key Elements

How a C Program Runs

Once the source code is written following the above structure, it goes through the following stages before producing output:

source.c  -->  Compiler  -->  source.obj  -->  Linker  -->  source.exe  -->  Output

1. Compilation: The compiler translates source code into object code and catches syntax errors.
2. Linking: The linker combines object code with library functions (like printf, scanf) to produce an executable file.
3. Loading: The loader places the executable into memory.
4. Execution: The CPU runs the program and produces output.

Summary

A well-structured C program contains five main sections: documentation, preprocessor directives, global declarations, the main() function, and user-defined functions. Following this structure makes programs organized, readable, and easy to maintain. The main() function is mandatory in every C program as it serves as the entry point for execution.

Algorithm and Flowchart

What is an Algorithm? [2 marks]

An algorithm is a finite, step-by-step set of instructions to solve a problem. It must be clear, unambiguous, and always terminate.

Properties of a Good Algorithm:

Example: Algorithm to find the largest of two numbers

Step 1: Start.
Step 2: Read a and b.
Step 3: If a > b, print a. Else print b.
Step 4: Stop.

Difference Between Algorithm and Flowchart [3 marks]

A flowchart is a diagram that represents an algorithm using standard symbols connected by arrows. It shows the flow of control from start to end.

Key Relationship

An algorithm and a flowchart both serve the same purpose: to plan and represent the solution to a problem before coding. The algorithm is the textual form, while the flowchart is its graphical equivalent. A flowchart is essentially a visual translation of an algorithm.

Function in C Programming

What is a Function? [1.5 marks]

A function is a self-contained, named block of code that performs a specific task. It is written once and can be called (invoked) multiple times from anywhere in the program.

General Syntax:

return_type function_name(parameter_list)
{
    // body of the function
    return value;
}

Example:

int add(int a, int b)
{
    return a + b;
}

A C program must have at least one function: int main(), which is the starting point of every C program.

Benefits of Using Functions [3.5 marks]

1. Reusability

A function is written once and can be called multiple times from different parts of the program. This avoids writing the same code repeatedly.

int square(int n) { return n * n; }
// Can be called as: square(3), square(5), square(10) ...

2. Modularity / Divide and Conquer

A large, complex program can be broken down into smaller, manageable, and independent modules (functions). Each function handles one specific task, making the overall program easier to design and understand.

3. Readability and Clarity

Programs written using functions are easier to read and understand. The main() function becomes shorter and cleaner because the detailed logic is moved into separate named functions.

4. Easy Debugging and Testing

Since each function performs a specific task, errors can be located and fixed more easily. Functions can be unit tested individually (tested separately) before being combined into the full program.

5. Reduced Program Length (Avoids Code Duplication)

Without functions, the same logic would need to be written multiple times. Functions reduce the total size of the program by replacing repeated code with a single function call.

6. Easy Maintenance

If a change is needed in a particular task, only the corresponding function needs to be modified. There is no need to search and change the same logic at multiple places throughout the program.

7. Abstraction

The user of a function does not need to know how it works internally. They only need to know what input to provide and what output to expect. This hides complexity and promotes abstraction.

Summary Table