C Programming Notes (हिंदी + English)

English

What is C? C is a general-purpose, procedural programming language developed by Dennis Ritchie at Bell Labs in 1972. It was created to write the UNIX operating system. C is often called a "middle-level" language because it combines high-level language features with low-level (assembly-like) capabilities.

Key Features:

• Simple and efficient
• Rich set of operators and data types
• Supports structured programming (functions, loops, decisions)
• Provides low-level memory access via pointers
• Portable – programs written in C can run on different machines with little or no modification

Basic Structure of a C Program:

1. Documentation (optional)
2. Preprocessor directives (#include, #define)
3. Global declarations
4. The main() function – every C program must have one
5. User-defined functions (optional)

English

Basic Syntax Rules:

• Semicolons (;) – Every statement in C must end with a semicolon. It tells the compiler that the statement has ended.
• Comments – Used to add notes in the code. Single-line: // comment. Multi-line: /* comment */.
• Braces {} – Used to group statements into a block (e.g., function body, loop body).
• Case Sensitivity – C is case‑sensitive; main, Main, and MAIN are different.
• Whitespace – Spaces, tabs, and newlines are ignored (except in strings). They make code readable.

Tokens in C: A C program consists of various tokens. Tokens can be:

• Keywords – Reserved words like int, return, if, etc.
• Identifiers – Names given to variables, functions, etc. (e.g., age, sum).
• Constants – Fixed values like 10, 3.14, 'A'.
• String literals – Text enclosed in double quotes, e.g., "Hello".
• Operators – Symbols that perform operations, e.g., +, -, *.

English

What are Data Types? Data types define the type of data a variable can store (e.g., integer, floating-point, character). They also determine how much memory is allocated and what operations can be performed.

Primary Data Types in C:

• int – Used to store integers (whole numbers) like 10, -5, 0. Size: typically 2 or 4 bytes.
• float – Used to store single-precision floating-point numbers (decimals) like 3.14, -0.5. Size: 4 bytes.
• double – Used to store double-precision floating-point numbers (more precision) like 3.14159. Size: 8 bytes.
• char – Used to store a single character like 'A', 'b', '5'. Size: 1 byte.
• void – Represents absence of type, used for functions that return nothing.

Derived and User-defined Types:

• Arrays, pointers, structures, unions, enums.

Type Modifiers: Used with primary types to alter size or range: short, long, signed, unsigned.

English

Variables: A variable is a named memory location that stores a value. The value can change during program execution. Variables must be declared before use.

Variable Declaration Syntax: data_type variable_name; or data_type variable_name = initial_value;

Rules for Naming Variables (Identifiers):

• Can contain letters (both uppercase and lowercase), digits, and underscore (_).
• Must begin with a letter or underscore (not a digit).
• Cannot use C keywords (like int, float, return).
• Case-sensitive: age and Age are different.
• Should be meaningful (e.g., student_age is better than a).

Constants: Constants are fixed values that cannot be changed during program execution. There are two ways to define constants:

• Using #define preprocessor: #define PI 3.14159 (no semicolon, usually placed at top).
• Using const keyword: const int DAYS = 7; (like a variable but read-only).

Scope and Lifetime: Variables have scope (where they are accessible) and lifetime (how long they exist). Local variables are declared inside a function and exist only while the function runs. Global variables are declared outside all functions and exist for the entire program.

English

Input and Output in C: Input means giving data to the program, output means displaying data from the program. C provides functions for input/output through the standard library <stdio.h>.

Common Output Functions:

• printf() – Prints formatted output to the screen (console).
• puts() – Prints a string followed by a newline.
• putchar() – Prints a single character.

Common Input Functions:

• scanf() – Reads formatted input from the keyboard.
• gets() – Reads a line of text (unsafe, avoid in modern C).
• getchar() – Reads a single character.

Format Specifiers in printf() and scanf(): They specify the type of data to be printed or read.

Specifier	Data Type	Example
%d or %i	int	printf("%d", 10);
%f	float	printf("%f", 3.14);
%lf	double	printf("%lf", 3.14159);
%c	char	printf("%c", 'A');
%s	string (char array)	printf("%s", "Hello");
%u	unsigned int	printf("%u", 100);

Important: In scanf(), you must use the & (address-of) operator before variable names (except for strings/arrays).

English

What are Operators? Operators are symbols that perform operations on operands (variables and values). C provides a rich set of operators.

Types of Operators in C:

• Arithmetic Operators: +, -, *, /, %
• Relational Operators: ==, !=, <, >, <=, >=
• Logical Operators: && (AND), || (OR), ! (NOT)
• Assignment Operators: =, +=, -=, *=, /=, %=
• Increment/Decrement: ++, --
• Bitwise Operators: &, |, ^, ~, <<, >>
• Conditional (Ternary) Operator: ? :
• Special Operators: sizeof(), & (address-of), * (dereference), etc.

Operator Precedence and Associativity: Determines the order in which operators are evaluated in an expression. For example, multiplication (*) has higher precedence than addition (+). Use parentheses to override precedence.

English

What are Control Structures? Control structures determine the flow of execution in a program. They allow you to make decisions and execute different blocks of code based on conditions.

Types of Control Structures in C:

• if statement – Executes a block if a condition is true.
• if-else statement – Executes one block if true, another if false.
• else-if ladder – Tests multiple conditions sequentially.
• Nested if – if inside another if.
• switch statement – Multi-way branching based on an integer expression.

English

What are Loops? Loops are used to execute a block of code repeatedly as long as a given condition is true. They are essential for tasks that require repetition, like processing arrays or performing iterative calculations.

Types of Loops in C:

• while loop – Entry‑controlled loop. Checks condition before each iteration.
• do-while loop – Exit‑controlled loop. Executes at least once, then checks condition.
• for loop – Compact loop that includes initialization, condition, and increment/decrement in one line.
• Nested loops – Loop inside another loop.

Loop Control Statements:

• break – Terminates the loop immediately and transfers control to the next statement after the loop.
• continue – Skips the rest of the current iteration and jumps to the next iteration.

English

What are Arrays? An array is a collection of elements of the same data type stored in contiguous memory locations. It allows you to store multiple values under a single variable name, accessed by an index.

Key Points:

• Array indices start from 0.
• Declaration: data_type array_name[size];
• Initialization: int numbers[5] = {10, 20, 30, 40, 50};
• If size is omitted, it is determined by the number of initializers.
• Access: array_name[index]

Types of Arrays:

• One-dimensional arrays – A single list of elements.
• Multi-dimensional arrays – Arrays with rows and columns (e.g., 2D arrays).

English

What are Strings? In C, a string is a sequence of characters stored as an array of characters terminated by a null character '\0'. The null terminator marks the end of the string.

String Declaration and Initialization:

• As a character array: char str[6] = "Hello"; (size includes the null terminator)
• Omitting size: char str[] = "Hello"; (compiler calculates size)
• Character by character: char str[] = {'H','e','l','l','o','\0'};
• Using pointer: char *str = "Hello"; (string literal – usually read-only)

Important String Functions (from <string.h>):

• strlen(str) – Returns length of string (excluding null).
• strcpy(dest, src) – Copies src to dest.
• strncpy(dest, src, n) – Copies at most n characters.
• strcat(dest, src) – Appends src to dest.
• strncat(dest, src, n) – Appends at most n characters.
• strcmp(str1, str2) – Compares two strings lexicographically. Returns 0 if equal, <0 if str1 < str2, >0 if str1 > str2.
• strncmp(str1, str2, n) – Compares first n characters.
• strchr(str, ch) – Finds first occurrence of ch in str.
• strstr(str, substr) – Finds first occurrence of substr in str.
• strtok(str, delimiters) – Splits string into tokens.

Input/Output for Strings:

• printf("%s", str); – Prints string.
• scanf("%s", str); – Reads a word (stops at whitespace).
• fgets(str, size, stdin); – Reads a line including spaces (safer).
• puts(str); – Prints string followed by newline.
• gets(str) – Unsafe, never use.

English

What are Functions? A function is a self-contained block of code that performs a specific task. Functions help in modular programming – breaking a large program into smaller, manageable pieces. They promote code reusability and easier debugging.

Types of Functions:

• Library Functions – Predefined functions in C (e.g., printf(), scanf(), strlen()).
• User-defined Functions – Functions created by the programmer to perform specific tasks.

Function Components:

• Function Declaration (Prototype): Tells the compiler about the function's name, return type, and parameters. Syntax: return_type function_name(parameter_list); Example: int add(int a, int b);
• Function Definition: Contains the actual body of the function. Syntax:
  return_type function_name(parameter_list) {
    // body
    return value;
}
• Function Call: Invokes the function to execute its code. Example: result = add(5, 3);

Parameter Passing: In C, parameters are passed by value – a copy of the argument is passed to the function. Changes inside the function do not affect the original variable.

Return Statement: Returns a value from the function to the caller. The return type must match the function's declared return type. If a function does not return anything, its return type is void.

Recursion: A function that calls itself. Useful for problems that can be broken into smaller, similar subproblems (e.g., factorial, Fibonacci).

English

What are Pointers? A pointer is a variable that stores the memory address of another variable. Pointers are one of the most powerful features of C, allowing direct memory access and manipulation. They are essential for dynamic memory allocation, array handling, and passing parameters by reference.

Pointer Declaration: data_type *pointer_name;
Example: int *ptr; declares a pointer to an integer.

Pointer Initialization: Assign the address of a variable to the pointer using the address-of operator &.
Example: int x = 10; int *ptr = &x;

Dereferencing: Access the value stored at the address pointed to by the pointer using the dereference operator *.
Example: printf("%d", *ptr); prints the value of x (10).

Pointer Arithmetic: Pointers support arithmetic operations like increment (++), decrement (--), addition, and subtraction. The arithmetic is based on the size of the data type. For an integer pointer, ptr++ moves to the next integer (4 bytes ahead on most systems).

Pointers and Arrays: Array names act as constant pointers to the first element. arr[i] is equivalent to *(arr + i).

Pointers as Function Parameters: Passing pointers to functions allows the function to modify the original variables (pass by reference).

Null Pointer: A pointer that points to nothing. Assigned as ptr = NULL; It's good practice to initialize pointers to NULL and check for NULL before dereferencing.

Pointer to Pointer: A pointer that stores the address of another pointer. Declared as data_type **ptr;

Void Pointer: A generic pointer that can point to any data type. Declared as void *ptr; Must be typecast before dereferencing.

English

What are Structures? A structure is a user-defined data type in C that allows grouping of variables of different data types under a single name. It is used to represent a record (e.g., a student, an employee, a point in 2D space).

Defining a Structure: Use the struct keyword followed by the structure name and a list of members inside curly braces.

struct structure_name {
    data_type member1;
    data_type member2;
    ...
};

Declaring Structure Variables: You can declare variables at the time of definition or later.

Accessing Members: Use the dot operator (.) to access members of a structure variable.

Initialization: You can initialize structure variables at declaration.

Arrays of Structures: You can create an array of structures to store multiple records.

Nested Structures: A structure can contain another structure as a member.

Pointers to Structures: You can have pointers pointing to structure variables. Use arrow operator -> to access members via pointer.

typedef with Structures: typedef can be used to create an alias for a structure, making code cleaner.

struct स्ट्रक्चर_नाम {
    डेटा_टाइप मेंबर1;
    डेटा_टाइप मेंबर2;
    ...
};

English

What is File Handling? File handling in C allows you to create, read, write, and manipulate files on the disk. Files are used to store data permanently, unlike variables which lose data when the program ends.

File Operations: The basic operations on files are:

• Creating a new file
• Opening an existing file
• Reading from a file
• Writing to a file
• Closing a file

File Pointer: C uses a pointer of type FILE to handle files. The FILE structure is defined in <stdio.h>.

Opening a File: The fopen() function opens a file and returns a file pointer. Syntax: FILE *fopen(const char *filename, const char *mode);

File Modes:

Mode	Description
"r"	Open for reading. File must exist.
"w"	Open for writing. Creates new file or truncates existing to zero length.
"a"	Open for appending. Creates new file if it doesn't exist.
"r+"	Open for reading and writing. File must exist.
"w+"	Open for reading and writing. Creates new file or truncates existing.
"a+"	Open for reading and appending. Creates new file if it doesn't exist.
"rb", "wb", "ab"	Binary modes.

Closing a File: Always close a file after operations using fclose(). Syntax: int fclose(FILE *stream);

Reading from a File: Common functions:

• int fgetc(FILE *fp); – Reads a character.
• char *fgets(char *str, int n, FILE *fp); – Reads a line.
• int fscanf(FILE *fp, const char *format, ...); – Reads formatted input.
• size_t fread(void *ptr, size_t size, size_t nmemb, FILE *fp); – Reads binary data.

Writing to a File: Common functions:

• int fputc(int ch, FILE *fp); – Writes a character.
• int fputs(const char *str, FILE *fp); – Writes a string.
• int fprintf(FILE *fp, const char *format, ...); – Writes formatted output.
• size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *fp); – Writes binary data.

Error Handling: Check if fopen() returns NULL (indicates failure). Use feof() to check for end-of-file and ferror() to check for errors.

Random Access: Functions like fseek(), ftell(), and rewind() allow moving to specific positions in a file.