C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Complete explanation of C program structure — documentation section, preprocessor directives, global declarations, main function, user-defined functions, and how each section works together with practical examples.
Every C program follows a specific structure. Unlike Python where you can just write code anywhere, C has rules about how a program must be organized. Understanding this structure is the first step to writing correct C code.
The Big Picture
Here's the complete anatomy of a C program:
┌─────────────────────────────────────────┐
│ 1. Documentation Section (comments) │ ← Optional but recommended
├─────────────────────────────────────────┤
│ 2. Preprocessor Directives (#include) │ ← Headers and macros
├─────────────────────────────────────────┤
│ 3. Global Declarations │ ← Global variables, constants
├─────────────────────────────────────────┤
│ 4. Function Prototypes (declarations) │ ← Tell compiler about functions
├─────────────────────────────────────────┤
│ 5. main() Function │ ← Entry point (REQUIRED)
├─────────────────────────────────────────┤
│ 6. User-Defined Functions │ ← Function implementations
└─────────────────────────────────────────┘
Complete Example with All Sections
Example
/* ============================================
1. DOCUMENTATION SECTION
Program: Temperature Converter
Author: Student Name
Date: 2024-01-15
Description: Converts temperatures between
Celsius and Fahrenheit
============================================ */
// 2. PREPROCESSOR DIRECTIVES
#include <stdio.h> // Standard I/O functions
#include <stdlib.h> // Standard library functions
#define FREEZE_POINT 0 // Freezing point in Celsius
#define BOIL_POINT 100 // Boiling point in Celsius
// 3. GLOBAL DECLARATIONS
const char PROGRAM_NAME[] = "TempConverter v1.0";
int conversionCount = 0;
// 4. FUNCTION PROTOTYPES (declarations)
float celsiusToFahrenheit(float celsius);
float fahrenheitToCelsius(float fahrenheit);
void displayMenu();
void printResult(float input, float output, char fromUnit, char toUnit);
// 5. MAIN FUNCTION — program starts here
int main() {
int choice;
float temperature, result;
printf("Welcome to %s\n\n", PROGRAM_NAME);
displayMenu();
printf("Enter your choice (1 or 2): ");
scanf("%d", &choice);
printf("Enter temperature: ");
scanf("%f", &temperature);
switch (choice) {
case 1:
result = celsiusToFahrenheit(temperature);
printResult(temperature, result, 'C', 'F');
break;
case 2:
result = fahrenheitToCelsius(temperature);
printResult(temperature, result, 'F', 'C');
break;
default:
printf("Invalid choice!\n");
return 1;
}
conversionCount++;
printf("\nTotal conversions this session: %d\n", conversionCount);
return 0; // 0 = successful execution
}
// 6. USER-DEFINED FUNCTIONS (definitions)
float celsiusToFahrenheit(float celsius) {
return (celsius * 9.0 / 5.0) + 32.0;
}
float fahrenheitToCelsius(float fahrenheit) {
return (fahrenheit - 32.0) * 5.0 / 9.0;
}
void displayMenu() {
printf("1. Celsius to Fahrenheit\n");
printf("2. Fahrenheit to Celsius\n");
}
void printResult(float input, float output, char fromUnit, char toUnit) {
printf("\n%.2f°%c = %.2f°%c\n", input, fromUnit, output, toUnit);
if (fromUnit == 'C') {
if (input <= FREEZE_POINT)
printf("Note: Below freezing point!\n");
else if (input >= BOIL_POINT)
printf("Note: Above boiling point!\n");
}
}
Output
Welcome to TempConverter v1.0 1. Celsius to Fahrenheit 2. Fahrenheit to Celsius Enter your choice (1 or 2): 1 Enter temperature: 100 100.00°C = 212.00°F Note: Above boiling point! Total conversions this session: 1
Section-by-Section Breakdown
Section 1: Documentation Section
This is a comment block at the top of your file describing the program. It's optional but considered professional practice:
c example
/*
* Program: Student Grade Calculator
* Author: Rahul Sharma
* Date: March 15, 2024
* Purpose: Calculate and display student grades
* based on marks in 5 subjects
*
* Compilation: gcc -o grades grades.c
* Usage: ./grades
*/C supports two types of comments:
c example
/* Multi-line comment
Can span multiple lines
Useful for documentation */
// Single-line comment (C99 and later)
// Each line needs its own //Section 2: Preprocessor Directives
Lines starting with # are processed BEFORE compilation. They're instructions to the preprocessor:
c example
// Include standard library headers
#include <stdio.h> // printf, scanf, fopen, etc.
#include <stdlib.h> // malloc, free, atoi, exit
#include <string.h> // strcpy, strlen, strcmp
#include <math.h> // sqrt, pow, sin, cos
// Include your own header files
#include "myutils.h" // Custom header (searched in current directory)
// Define constants (replaced by preprocessor, no memory used)
#define PI 3.14159265
#define MAX_STUDENTS 100
#define COURSE_NAME "C Programming"
// Define macros (inline code replacement)
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))Section 3: Global Declarations
Variables declared outside all functions are global — accessible from any function in the file:
Example
#include <stdio.h>
// Global variables — visible to ALL functions
int totalStudents = 0;
float maxScore = 0.0;
char schoolName[] = "ABC Institute";
// Global constants
const float TAX_RATE = 0.18;
const int MAX_ATTEMPTS = 3;
void addStudent() {
totalStudents++; // Can access global variable
printf("Students: %d\n", totalStudents);
}
int main() {
printf("School: %s\n", schoolName); // Can access global
addStudent();
addStudent();
printf("Final count: %d\n", totalStudents);
return 0;
}
Output
School: ABC Institute Students: 1 Students: 2 Final count: 2
Best Practice: Minimize global variables. They make code harder to understand and debug. Prefer passing data through function parameters.
Section 4: Function Prototypes
A prototype tells the compiler "this function exists, here's what it looks like" — without giving the full implementation yet:
Example
#include <stdio.h>
// Function prototypes — declared before main()
// Tells compiler: return type, name, parameter types
int add(int a, int b);
float calculateAverage(int scores[], int count);
void printLine(char character, int length);
int main() {
// Compiler already knows about these functions (from prototypes)
printf("Sum: %d\n", add(5, 3));
int scores[] = {85, 92, 78, 90, 88};
printf("Average: %.1f\n", calculateAverage(scores, 5));
printLine('=', 30);
return 0;
}
// Full function definitions — can be below main()
int add(int a, int b) {
return a + b;
}
float calculateAverage(int scores[], int count) {
int sum = 0;
for (int i = 0; i < count; i++) {
sum += scores[i];
}
return (float)sum / count;
}
void printLine(char character, int length) {
for (int i = 0; i < length; i++) {
putchar(character);
}
putchar('\n');
}
Output
Sum: 8 Average: 86.6 ==============================
Section 5: The main() Function
main() is the entry point — where execution begins. Every C program must have exactly one main() function.
Example
// Form 1: No command-line arguments
int main() {
// program code
return 0;
}
// Form 2: Accepts command-line arguments
int main(int argc, char *argv[]) {
// argc = argument count
// argv = argument values (array of strings)
printf("Program name: %s\n", argv[0]);
printf("Arguments: %d\n", argc - 1);
for (int i = 1; i < argc; i++) {
printf(" arg[%d] = %s\n", i, argv[i]);
}
return 0;
}
// Form 3: Older style (valid but not recommended)
// void main() { } — NOT standard, some compilers accept it
Output
// If run as: ./program hello world Program name: ./program Arguments: 2 arg[1] = hello arg[2] = world
The Return Value
c example
#include <stdio.h>
int main() {
// return 0 = program succeeded
// return non-zero = program failed (error code)
FILE *file = fopen("data.txt", "r");
if (file == NULL) {
printf("Error: Could not open file!\n");
return 1; // Error code 1 = file not found
}
// Process file...
fclose(file);
return 0; // Success
}The shell can check this return value:
Code example
$ ./program
$ echo $? ← prints the return value (0 = success)Section 6: User-Defined Functions
Functions you create to organize your code into reusable blocks:
Example
#include <stdio.h>
// Function with return value
int isPrime(int n) {
if (n < 2) return 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
// Function with no return value (void)
void printPrimesInRange(int start, int end) {
printf("Primes between %d and %d: ", start, end);
for (int i = start; i <= end; i++) {
if (isPrime(i)) {
printf("%d ", i);
}
}
printf("\n");
}
// Function that modifies data via pointers
void incrementAll(int arr[], int size) {
for (int i = 0; i < size; i++) {
arr[i]++;
}
}
int main() {
printPrimesInRange(1, 50);
int numbers[] = {10, 20, 30, 40, 50};
incrementAll(numbers, 5);
printf("After increment: ");
for (int i = 0; i < 5; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
Output
Primes between 1 and 50: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 After increment: 11 21 31 41 51
The Simplest Valid C Program
c example
int main() {
return 0;
}This is a complete, valid C program. It does nothing, but it compiles and runs successfully. Every other part (headers, functions, variables) is added as your program grows in complexity.
Compilation and Execution Flow
c example
// File: hello.c
#include <stdio.h>
int main() {
printf("Hello, C World!\n");
return 0;
}Output
Compilation steps: $ gcc hello.c -o hello ← Compile source to executable $ ./hello ← Run the executable Hello, C World! What happens internally: 1. Preprocessor: #include <stdio.h> → copies stdio content into file 2. Compiler: Converts C to assembly language 3. Assembler: Converts assembly to machine code (object file) 4. Linker: Connects your code with printf's implementation from C library 5. Output: Executable binary file 'hello'
Common Mistakes in Program Structure
c example
// MISTAKE 1: Missing #include
// printf("Hello"); ← Compiler warning: implicit declaration
// MISTAKE 2: Missing semicolons
// int x = 5 ← Error: expected ';'
// MISTAKE 3: Wrong main signature
// void main() { } ← Non-standard (use int main)
// MISTAKE 4: Using function before declaring it
// int main() {
// greet(); ← Error if greet() isn't declared above main
// }
// void greet() { printf("Hi\n"); }
// FIX: Add prototype above main
// void greet(); ← Prototype
// int main() { greet(); return 0; }
// void greet() { printf("Hi\n"); }
// MISTAKE 5: Forgetting return 0
// int main() { printf("Hi\n"); } ← Implicit return 0 in C99, but bad practiceInterview Questions
Q1: What are the main sections of a C program?
Answer: A C program has six sections: (1) Documentation section (comments describing the program), (2) Preprocessor directives (#include, #define), (3) Global declarations (global variables and constants), (4) Function prototypes (declarations), (5) main() function (entry point, mandatory), (6) User-defined function definitions.
Q2: What is the role of main() in a C program?
Answer: main() is the entry point of every C program — execution always begins here. The operating system calls main() when the program starts. It must return an integer: 0 for success, non-zero for error. Every C program must have exactly one main() function.
Q3: What is the difference between #include <file.h> and #include "file.h"?
Answer: #include <file.h> searches for the header in system/standard library directories (like /usr/include). #include "file.h" first searches the current directory (where your .c file is), and if not found, then searches system directories. Use <> for standard library headers and "" for your own custom headers.
Q4: What happens if you don't include <stdio.h> but use printf()?
Answer: In C89, the compiler assumes printf() returns int and generates a warning about implicit declaration. In C99/C11, it produces an error because implicit function declarations are not allowed. The code may still compile with warnings but can cause undefined behavior if the assumed function signature doesn't match the actual one.
Q5: Can a C program have multiple functions? How does the compiler know where to start?
Answer: Yes, a C program can have any number of functions. The compiler always starts execution at main() — this is mandated by the C standard. Other functions execute only when explicitly called from main() or from a function that was called from main(). The linker sets the program's entry point to the address of main().
Summary
A C program's structure is straightforward but must follow specific rules: preprocessor directives at the top, followed by global declarations, function prototypes, the mandatory main() function, and finally user-defined function implementations. Understanding this structure ensures your programs compile correctly and remain organized as they grow in complexity. The key takeaway is that main() is the heart of every C program — everything else exists to support and organize the code that runs from within main().
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Structure of a C Program.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, basics, structure, program, structure of a c program
Related C Programming Topics
Continue learning this concept
BasicsC Syntax Rules — Complete GuideLearn the fundamental syntax rules of C programming — statements, expressions, semicolons, code blocks, whitespace handling, and common syntax errors explained with examples.BasicsComments in C ProgrammingLearn about comments in C — single-line comments, multi-line comments, best practices, nested comments, and when to use comments effectively in your code.BasicsConstants in C ProgrammingLearn about constants in C programming — const keyword, #define macro, enum constants, and literal constants with practical examples and best practices.BasicsData Types in CComplete guide to C data types — primary types (int, char, float, double), derived types (arrays, pointers, structures), type modifiers (short, long, signed, unsigned), sizeof operator, type conversion, and memory representation with examples.BasicsIdentifiers in C ProgrammingComplete guide to identifiers in C — naming rules, conventions, valid and invalid examples, and the difference between identifiers and keywords.BasicsKeywords in C ProgrammingComplete guide to all 32 keywords in C programming — categorized by purpose with explanations, usage examples, and comparison tables.