Structure of a C Program

1. Documentation Section

Documentation Content:

Used to describe what the program does
Helps humans understand the code
Written as comments that are ignored by the compiler

📝 Comment Types:

Single-line: // This is a comment

Multi-line: /* This is a multi-line comment */

documentation_example.c

// Program to add two numbers

        /* This program demonstrates 
   how to add numbers in C */
    


#include <stdio.h>

// Function to add two integers
int add(int a, int b) {
    return a + b;  // Return the sum
}


        /*
 * Main function - Entry point of the program
 * Purpose: Demonstrate addition of two numbers
 * Author: Your Name
 * Date: Today's Date
 */
    

int main() {
    int num1 = 10;    // First number
    int num2 = 20;    // Second number
    int result;        // Variable to store result
    
    result = add(num1, num2);  // Call add function
    
    // Display the result
    printf("Sum of %d and %d is %d\n", num1, num2, result);
    
    return 0;  // Indicate successful execution
}

Documentation Best Practices:

Header Comments: Include program purpose, author, and date
Function Comments: Explain what each function does
Inline Comments: Clarify complex or important lines
Variable Comments: Describe the purpose of variables
Algorithm Comments: Explain the logic behind complex operations

2. Basic Structure Overview

Documentation Section

↓

Preprocessor Directives

↓

Global Declarations

↓

Function Prototypes

↓

main() Function

↓

User-defined Functions

Key Points:

Every C program follows a structured format
Documentation comes first to explain the program's purpose
The main() function is the entry point of execution
Preprocessor directives are processed before compilation
Functions can be defined before or after main()

3. Simple C Program Example

hello.c

// This is a simple C program
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

Line-by-line explanation:

#include <stdio.h> - Includes standard input/output library
int main() - Main function declaration returning an integer
printf() - Function to print text to console
return 0; - Indicates successful program termination

4. Preprocessor Directives

preprocessor_example.c

// Header file inclusion
#include <stdio.h>      // Standard I/O
#include <stdlib.h>     // Standard library
#include <math.h>       // Math functions

// Macro definitions
#define PI 3.14159
#define MAX_SIZE 100
#define SQUARE(x) ((x) * (x))

// Conditional compilation
#ifdef DEBUG
    #define PRINT_DEBUG(msg) printf("DEBUG: %s\n", msg)
#else
    #define PRINT_DEBUG(msg)
#endif

int main() {
    double radius = 5.0;
    double area = PI * SQUARE(radius);
    
    printf("Area of circle: %.2f\n", area);
    PRINT_DEBUG("Calculation completed");
    
    return 0;
}

Common Preprocessor Directives:

#include - Include header files
#define - Define macros and constants
#ifdef/#ifndef - Conditional compilation
#pragma - Compiler-specific instructions

                        Benefits:
                        Code reusability
Constants definition
Conditional compilation
Platform-specific code

                    

5. Global Declarations

global_declarations.c

#include <stdio.h>

// Global variables
int global_counter = 0;           // Initialized global variable
char global_message[50];           // Global array
const double GRAVITY = 9.81;    // Global constant

// Global structure definition
struct Student {
    int id;
    char name[30];
    float gpa;
};

// Function prototypes (declarations)
void increment_counter(void);
void display_student(struct Student s);
double calculate_weight(double mass);

int main() {
    struct Student student1 = {101, "John Doe", 3.75};
    
    printf("Initial counter: %d\n", global_counter);
    increment_counter();
    printf("After increment: %d\n", global_counter);
    
    display_student(student1);
    
    double mass = 70.5;
    printf("Weight: %.2f N\n", calculate_weight(mass));
    
    return 0;
}

// Function definitions
void increment_counter(void) {
    global_counter++;
}

void display_student(struct Student s) {
    printf("Student ID: %d, Name: %s, GPA: %.2f\n", 
           s.id, s.name, s.gpa);
}

double calculate_weight(double mass) {
    return mass * GRAVITY;
}

Global Declaration Types:

Global Variables: Accessible throughout the program
Constants: Read-only values defined globally
Structure/Union Definitions: Custom data type definitions
Function Prototypes: Function declarations for early reference

5. The main() Function

main_function_variations.c

#include <stdio.h> #include <stdlib.h> // Standard main function int main() { printf("Simple main function\n"); return 0; } // Alternative: main with command line arguments

    /*
int main(int argc, char *argv[]) {
    printf("Program name: %s\n", argv[0]);
    printf("Number of arguments: %d\n", argc);
    
    for(int i = 1; i < argc; i++) {
        printf("Argument %d: %s\n", i, argv[i]);
    }
    
    return 0;
}
*/

// Alternative: main with environment variables

    /*
int main(int argc, char *argv[], char *envp[]) {
    printf("Environment variables:\n");
    for(int i = 0; envp[i] != NULL; i++) {
        printf("%s\n", envp[i]);
    }
    
    return 0;
}
*/

// Alternative: void main (not recommended)

   
    /*
void main() {
    printf("Void main - not standard compliant\n");
}
*/

main() Function Features:

Entry point of program execution
Returns integer status code
Can accept command-line arguments
Must be present in every C program

                        Return Values:
                        0 - Success
Non-zero - Error
EXIT_SUCCESS - Success macro
EXIT_FAILURE - Failure macro

                    

6. User-Defined Functions

user_functions.c

#include <stdio.h> #include <math.h> // Function prototypes int add(int a, int b); float calculate_area(float radius); void print_pattern(int n); int factorial(int n); void swap(int *a, int *b); int main() { // Testing different functions int sum = add(10, 20); printf("Sum: %d\n", sum); float area = calculate_area(5.0); printf("Circle area: %.2f\n", area); print_pattern(5); int fact = factorial(5); printf("Factorial of 5: %d\n", fact); int x = 100, y = 200; printf("Before swap: x=%d, y=%d\n", x, y); swap(&x, &y); printf("After swap: x=%d, y=%d\n", x, y); return 0; } // Function to add two integers int add(int a, int b) { return a + b; } // Function to calculate circle area float calculate_area(float radius) { return 3.14159 * radius * radius; } // Function to print a pattern void print_pattern(int n) { for(int i = 1; i <= n; i++) { for(int j = 1; j <= i; j++) { printf("* "); } printf("\n"); } } // Recursive function to calculate factorial int factorial(int n) { if(n <= 1) return 1; return n * factorial(n - 1); } // Function to swap two integers using pointers void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; }

Function Components:

Return Type: Data type of value returned (void for no return)
Function Name: Identifier following naming conventions
Parameters: Input values (can be empty)
Function Body: Code block containing implementation
Return Statement: Returns value to calling function

7. Complete Program Example

complete_program.c

    /*
 * Student Management System
 * Demonstrates complete C program structure
 * Author: P    rogramming Tutorial
 */

// Preprocessor directives #include <stdio.h> #include <string.h> #include <stdlib.h> // Macro definitions #define MAX_STUDENTS 50 #define NAME_LENGTH 50 // Global structure definition struct Student { int id; char name[NAME_LENGTH]; float gpa; int age; }; // Global variables struct Student students[MAX_STUDENTS]; int student_count = 0; // Function prototypes void add_student(int id, char *name, float gpa, int age); void display_students(void); void find_student(int id); float calculate_average_gpa(void); void display_menu(void); // Main function - Program entry point int main() { int choice, id, age; char name[NAME_LENGTH]; float gpa; printf("=== Student Management System ===\n\n"); // Sample data add_student(101, "Alice Johnson", 3.8, 20); add_student(102, "Bob Smith", 3.5, 21); add_student(103, "Carol Davis", 3.9, 19); while(1) { display_menu(); printf("Enter your choice: "); scanf("%d", &choice); switch(choice) { case 1: printf("Enter ID: "); scanf("%d", &id); printf("Enter name: "); scanf("%s", name); printf("Enter GPA: "); scanf("%f", &gpa); printf("Enter age: "); scanf("%d", &age); add_student(id, name, gpa, age); break; case 2: display_students(); break; case 3: printf("Enter student ID to find: "); scanf("%d", &id); find_student(id); break; case 4: printf("Average GPA: %.2f\n", calculate_average_gpa()); break; case 5: printf("Goodbye!\n"); exit(0); default: printf("Invalid choice! Please try again.\n"); } printf("\n"); } return 0; } // Function to add a new student void add_student(int id, char *name, float gpa, int age) { if(student_count < MAX_STUDENTS) { students[student_count].id = id; strcpy(students[student_count].name, name); students[student_count].gpa = gpa; students[student_count].age = age; student_count++; printf("Student added successfully!\n"); } else { printf("Maximum student limit reached!\n"); } } // Function to display all students void display_students(void) { if(student_count == 0) { printf("No students found!\n"); return; } printf("\n--- Student List ---\n"); printf("ID\tName\t\tGPA\tAge\n"); printf("----------------------------------------\n"); for(int i = 0; i < student_count; i++) { printf("%d\t%-15s\t%.2f\t%d\n", students[i].id, students[i].name, students[i].gpa, students[i].age); } } // Function to find a student by ID void find_student(int id) { for(int i = 0; i < student_count; i++) { if(students[i].id == id) { printf("Student Found:\n"); printf("ID: %d\n", students[i].id); printf("Name: %s\n", students[i].name); printf("GPA: %.2f\n", students[i].gpa); printf("Age: %d\n", students[i].age); return; } } printf("Student with ID %d not found!\n", id); } // Function to calculate average GPA float calculate_average_gpa(void) { if(student_count == 0) return 0.0; float total = 0.0; for(int i = 0; i < student_count; i++) { total += students[i].gpa; } return total / student_count; } // Function to display menu void display_menu(void) { printf("\n=== MENU ===\n"); printf("1. Add Student\n"); printf("2. Display All Students\n"); printf("3. Find Student\n"); printf("4. Calculate Average GPA\n"); printf("5. Exit\n"); }

This complete program demonstrates:

Multi-file organization: Header includes, macros, globals
Data structures: Custom struct definition
Function modularization: Separate functions for different tasks
User interaction: Menu-driven interface
Memory management: Array-based storage

8. Program Structure Best Practices

                        📝 Code Organization
                        Place includes at the top
Define macros after includes
Declare global variables sparingly
Use meaningful function names
Group related functions together

                    

                        🎯 Naming Conventions
                        Use lowercase with underscores
Constants in UPPERCASE
Descriptive variable names
Consistent naming style
Avoid single-letter variables

                    

                        💬 Documentation
                        Add header comments
Explain complex algorithms
Document function parameters
Use inline comments wisely
Maintain consistent formatting

                    

                        🔧 Function Design
                        Keep functions focused and small
Use clear parameter names
Return appropriate values
Handle error conditions
Avoid deep nesting

                    

Additional Tips:

Indentation: Use consistent indentation (2-4 spaces or tabs)
Line Length: Keep lines under 80-100 characters
Error Handling: Check return values and handle errors gracefully
Memory Management: Always free allocated memory
Testing: Write test cases for your functions

9. Common Mistakes to Avoid

common_mistakes.c

// ❌ MISTAKE 1: Missing includes // #include <stdio.h> // Don't forget this! // ❌ MISTAKE 2: No function prototypes int main() { calculate(5, 3); // Error: function not declared return 0; } int calculate(int a, int b) { // Defined after main return a + b; } // ✅ CORRECT VERSION #include <stdio.h> // Function prototype int calculate(int a, int b); int main() { int result = calculate(5, 3); printf("Result: %d\n", result); return 0; } int calculate(int a, int b) { return a + b; } // ❌ MISTAKE 3: Missing return statement int bad_function() { int x = 10; // Missing return statement! } // ✅ CORRECT: Always return a value for non-void functions int good_function() { int x = 10; return x; } // ❌ MISTAKE 4: Uninitialized variables void bad_practice() { int x; // Uninitialized printf("%d", x); // Undefined behavior } // ✅ CORRECT: Initialize variables void good_practice() { int x = 0; // Initialized printf("%d", x); // Safe to use }

⚠️ Common Mistakes:

Forgetting semicolons
Missing header files
Incorrect function declarations
Uninitialized variables
Missing return statements
Incorrect format specifiers

                        🛡️ Prevention Tips:
                        Use compiler warnings (-Wall)
Initialize all variables
Check function return types
Use proper format specifiers
Test code frequently
Use static analysis tools

                    

10. Summary & Key Takeaways

🎯 C Program Structure Hierarchy

Comments & Documentation

Preprocessor Directives (#include, #define)

Global Declarations (variables, constants, structures)

Function Prototypes

main() Function (Program Entry Point)

User-Defined Functions

                        ✅ Remember These Points:
                        Every C program needs a main() function
Include necessary header files
Declare functions before using them
Use meaningful names for variables/functions
Follow consistent coding style
Handle errors appropriately

                    

                        🚀 Next Steps:
                        Practice writing complete programs
Learn about multi-file projects
Explore advanced data structures
Study memory management
Learn debugging techniques
Understand compilation process

                    

Final Notes: Understanding C program structure is fundamental to writing efficient, maintainable code. Start with simple programs and gradually build complexity. Remember that good structure makes your code easier to read, debug, and maintain. Practice regularly and don't hesitate to experiment with different approaches to solve problems.