A C program typically has a well-defined structure consisting of several components that help organize code in a logical and readable manner. Below is a breakdown of the typical structure of a C program:

1. Preprocessor Directives

These directives instruct the compiler to include necessary files or define macros before actual compilation begins. Preprocessor directives start with a # symbol.

• Header Files: These are included to use built-in functions and standard library functions.

  #include <stdio.h>  // Standard Input Output header
  #include <stdlib.h> // Standard library functions
  

2. Global Declarations

Variables, macros, constants, and functions that need to be accessed throughout the program can be declared globally.

• Global Variables: Declared outside any function, accessible throughout the program.

  int globalVar = 10;
  

• Macros: Using #define to define constants or inline code.

  #define PI 3.14
  

3. Function Prototypes (Declarations)

Function prototypes specify the functions' names, return types, and parameters before they are defined. This allows functions to be called before their full definition in the source code.

void displayMessage();
int add(int a, int b);

4. main() Function

The main() function is the entry point for the execution of any C program. It contains the main logic and controls the flow of the program.

• Syntax:

  int main() {
      // Code to execute
      return 0;  // Returning 0 indicates successful execution
  }
  

• Return Type: Typically int, although void is also sometimes used.

5. Local Declarations and Statements

Inside the main() function or other user-defined functions, you can declare local variables and write the logic of your program.

int main() {
    int number = 5;  // Local variable
    printf("The number is: %d\n", number);
    return 0;
}

6. User-Defined Functions

Functions are defined to break the program into smaller, reusable components. They are helpful for modularity and code reuse.

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

7. Comments

Comments are used to describe and document the code, making it more understandable. In C, there are two types of comments:

• Single-line comments: // This is a single-line comment
• Multi-line comments:

  /* 
  This is a 
  multi-line comment 
  */
  

Summary of Typical Structure

#include <stdio.h>       // Preprocessor directives
#include <stdlib.h>

#define MAX 100          // Macro definition

int globalVar = 10;      // Global variable declaration

// Function prototype
void displayMessage();
int add(int a, int b);

int main() {
    int result;          // Local variable declaration
    displayMessage();    // Calling a user-defined function
    result = add(5, 3);  // Using another function
    printf("Result of addition: %d\n", result);
    return 0;            // Return statement
}

// Function definitions
void displayMessage() {
    printf("Hello, World!\n");
}

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

Key Components Recap:

1. Preprocessor Directives: #include, #define
2. Global Declarations: Variables, macros
3. Function Prototypes: Declarations of functions
4. main() Function: Entry point
5. Local Declarations: Variables inside functions
6. User-Defined Functions: To modularize the program
7. Comments: Documentation for better readability

This structured approach allows for clean, organized, and efficient C programming, making it easier to read, maintain, and debug.