Introduction to Programming CS201

Lecture No. 1: Introduction to Programming

What is Programming

Definition: "A program is a precise sequence of steps to solve a particular problem."
Programming involves knowing a complete set of activities to be performed in a specific order to solve a problem.
Alan Perlis's sarcastic statement highlights that modern education often neglects critical skills like planning, organizing, attention to detail, and self-criticism, which are essential for programming.
Steve Summit defines computer programming as simply "telling it what to do," with everything else being artificial mechanisms for communication with the computer. The challenge lies in accepting these mechanisms.

Why Programming is Important

Programming is important because it develops analytical and problem-solving abilities.
It is a creative activity that allows expressing abstract ideas.
It teaches skills valuable across all professions:
- Critical reading
- Analytical thinking
- Creative synthesis

What Skills are Needed for Programming

Paying attention to detail: Crucial for analyzing problem statements, calculations, flow, and logic. Grammatically correct code can still be illogical.
Think about reusability: Write programs that can be adapted to solve related problems or reused in different contexts (e.g., a circle area function for a ring area calculation).
Think about user interface: Never assume computer literacy. Provide self-explanatory and easy-to-use interfaces.
Understand that computers are stupid: Computers execute instructions exactly as given, without inferring meaning. Instructions must be explicit.
Comment the code liberally: Comments explain program functionality, aiding other programmers and the original author in understanding the code without affecting performance or memory.

Program Design Recipe

To design a program effectively, a recipe should be followed, similar to learning a skill like soccer or architecture.
Steps:
1. Analyze a problem statement: Typically expressed as a word problem, abstractly and with examples.
2. Formulate statements and comments: Use a precise language (e.g., pseudo-code, flowcharting).
3. Evaluate and revise: Test and check activities; repeat the process if changes are identified to achieve a refined solution.
4. Pay attention to detail: Essential throughout the process.
Example (Payroll System):
- Problem: Develop a payroll system for a company with different employee categories (permanent, contractual, hourly, per-unit) and varying deductions/benefits/bonuses.
- Analysis: Identify employee categories, their specific rules (e.g., permanent staff benefits/deductions by designation, per-unit bonus for >10 pieces/day, contractual overtime).
- Segmentation: Divide into smaller segments and calculations. Include examples for each category (e.g., Mr. Ahmad, Finance Manager, Rs. 20000 salary, Rs. 4000 benefits, Rs. 1200 deductions).
- Formulation: Translate analysis into pseudo-code and flowcharts, then into a computer language.
- Evaluation: Test and check the program; revise as needed.

Points to Remember (Lecture 1)

Don’t assume on the part of the users.
User Interface should be friendly.
Don’t forget to comment the code.
PAY ATTENTION TO DETAIL.
Program, program and program, not just writing code, but the whole process of design and development.

Lecture No. 2: Software Categories, C Language History, Development Environment

Software Categories

Software is broadly categorized into two main types:
- System Software
- Application Software

Diagram showing Computer Hardware at the base, System Software layer above it (Assembler, Debugger, Compilers, File Mgmt Tools, Operating System, Utilities), and Application Software layer at the top (Word processing, Graphics, Spreadsheets, Communications, Databases, Games).

System Software

Controls the computer and communicates with its hardware (keyboard, mouse, modem, sound card, etc.).
Controls different aspects of operations.
Subcategories:
- Operating System (OS):
  - Manages all other programs in a computer.
  - An integrated collection of routines servicing program sequencing and processing.
  - Provides services like resource allocation, scheduling, input/output control, and data management.
  - Definition (Microsoft): "Operating system is the software responsible for controlling the allocation and usage of hardware resources such as memory, central processing unit (CPU) time, disk space, and peripheral devices. The operating system is the foundation on which applications, such as word processing and spreadsheet programs, are built."
- Device Drivers:
  - Software used for communication between devices (monitor, keyboard, mouse, CD-ROM, sound card, modem, scanner) and the computer.
  - Provided by device manufacturers (e.g., TWAIN Drivers for scanners).
- Utility Software:
  - Performs specific tasks related to managing system resources.
  - Examples:
    - Disk Compression: Reduces file size when saving to disk, uncompresses when requested.
    - Disk Defragmentation: Rearranges fragmented data chunks on disk to be closer, improving read speed.
  - Compilers and interpreters also fall under System Software.

Application Software

Programs or groups of programs designed for end-users.
Examples: Accounting, Payroll, Inventory Control Systems, guided systems for planes (GPS).

History of C Language

Developed in the late 1960s and early 1970s at Bell Laboratories.
Evolved from BCPL (1967, Martin Richards) and B (1970, Ken Thompson), which were used for writing operating systems and compilers.
BCPL and B were 'typeless' languages, where the programmer was responsible for interpreting data types.
Dennis Ritchie developed C by incorporating features from BCPL and B, adding data typing.
C became widely known as the development language for the UNIX operating system.
C is powerful, allowing low-level control over computer devices. Caution is advised due to its power (e.g., a C program can stop a computer).
Widespread adoption in educational and research institutions led to variations.
Standardization: ANSI (American National Standards Committee on Computer and Information Processing) created a technical committee in 1983 to provide an unambiguous, machine-independent definition. The standard was approved in 1989, and ISO standardized C worldwide.

Tools of the Trade (Development Environment of 'C')

Editors:
- Used for writing program code.
- Simple text editors are preferred over word processors (which add formatting information).
Compiler and Interpreter (Translators):
- Translate human-readable code (like C) into machine language (0s and 1s).
- Interpreter: Translates and executes code line by line.
  - **Benefit:** Errors are found as they occur, easy to correct.
  - **Drawback:** Slower execution, cannot optimize the whole program.
- Compiler: Reads the entire program and translates it into machine language.
  - **Behavior:** Stops translation upon finding an error, no executable code generated until syntactically correct.
  - Used in this course.
Debugger:
- Used to correct logical errors (bugs) in a program.
- Allows controlling program execution, stopping at points, checking/changing variable values to trace errors.
- Powerful but complex tool.
Linker:
- Combines executable code from different files (routines, functions) used by a program.
- Creates a standalone executable code.
Loader:
- Loads the linked executable program into memory.
- Instructs the processor to start execution from the first instruction (main function in C).
- Linker and loader are part of the system software and development environment.

Flowchart showing the steps from Editor to CPU: Editor -> Disk (Source Code), Preprocessor -> Disk (Processed Code), Compiler -> Disk (Object Code), Linker -> Disk (Executable Code), Loader -> Primary Memory (Program in Memory), CPU -> Executes.

Lecture No. 3: First C Program, Variables, Data Types, Operators

First C Program

Learning C is best done by coding immediately.

Example:

# include <iostream.h>main(){ cout << "Welcome to Virtual University of Pakistan";}

Line-by-line explanation:
- # include <iostream.h>:
- main():
- { }:
- cout << "Welcome to Virtual University of Pakistan";:

Variables

During programming, data needs to be stored. Variables are named locations in memory for storing data.
Memory can be thought of as blocks or "pigeon-holes," each with a numerical address. Variables provide symbolic names to these locations, making them easier to manage than numerical addresses.
Variables are called "variables" because they can hold different values at different times.
Variable properties:
- Name: Symbolic identifier. In C, names can start with a character or an underscore (_). Avoid starting with _ to prevent conflicts with library variables/functions.
- Type: Data type (e.g., integer, decimal, character).
- Size: Memory occupied, dependent on data type, machine, and compiler.
- Value: The data stored in the memory location.

Assignment Operator

In C, the equal-to sign (=) is used as the assignment operator.
Distinction from algebraic equality: In algebra, X = 2 means X's value is 2. In C, X = 2 means store the value 2 into the memory location named X. The value of X can be changed later (e.g., X = 10 overwrites the previous value).
Binary operator: The assignment operator is a binary operator, requiring two operands.
Syntax: Must have a variable on the left-hand side and an expression (evaluating to a single value) on the right-hand side (e.g., X = 5, X = 10 + 5).
Increment/Decrement: X = X + 1 means add 1 to X's current value and store the result back in X. This is a common practice for incrementing. Similarly for decrementing (X = X - 1).
An expression on the left-hand side of = (e.g., X + 5 = Y + 7) is incorrect in C.

Data Types

Every variable must have a data type, such as integer, decimal numbers, or characters.
Data types determine the memory size allocated for a variable and how its value is displayed.
cout automatically knows how to display different data types.
Data types are reserved words in C and cannot be used as variable names.

Whole Numbers

C provides three data types for whole numbers (integers):
- int
- short
- long
int Data Type:
- Used to store whole numbers.
- Typically occupies 4 bytes (32 bits) on Windows operating systems.
- int is a reserved word.
- Declaration: Before using a variable, it must be declared with its data type (e.g., int i;). This reserves memory space and labels it.
Sample Program 1 (int data type):
```
#include <iostream.h>main(){ int x; int y; int z; x = 5; y = 10; z = x + y; cout << "x = "; cout << x; cout << " y="; cout << y; cout << " z = x + y = "; cout << z;}
```
- Declarations can be on separate lines (int x; int y; int z;) or a single line using a comma separator (int x, y, z;). Good practice suggests one declaration per line.
- Assignment statements (x = 5; y = 10;) store values.
- Arithmetic operations (z = x + y;) evaluate the right-hand side expression and store the result. Values of variables on the right-hand side are not affected, except in cases like x = x + 1;.
- cout << "x = "; displays the literal string.
- cout << x; displays the *value* of variable x, interpreting its integer type.
- Output: x = 5 y = 10 z = x + y = 15
short Data Type:
- Used for small whole numbers.
- Typically occupies 2 bytes.
- Range: -32768 to 32767.
- Useful for variables known to stay within this range (e.g., age).
long Data Type:
- Used for very large whole numbers that cannot be stored in an int.
- Example: long x = 300500200;

Real Numbers

C provides data types for real numbers (numbers with decimal points, also known as floating-point numbers):
- float
- double
float Data Type:
- Used to store real numbers.
- Typically occupies 4 bytes.
double Data Type:
- Used for large real numbers that cannot be stored in a float.
- Typically twice the size of a float.
- Example: double x = 345624.769123;

`char` Data Type

Used to store single characters (e.g., 'a', 'b', 'c').
Character values are assigned using single quotes (e.g., x = 'a';).

Arithmetic Operators

C language includes standard arithmetic operators:
- Addition: + (e.g., x + y)
- Subtraction: - (e.g., x - y)
- Multiplication: * (e.g., x * y)
- Division: / (e.g., x / y)
- Modulus: % (returns remainder after division)
All are binary operators, requiring two operands.
Integer Division: When both operands of division (/) are integers, the result is an integer (fractional part is truncated). Use float or double data types for correct decimal results.
Modulus Operator (%):
- Returns the remainder of an integer division.
- Can only be used with integer operands.
- Example: 5 % 2 is 1; 23 % 5 is 3; 107 % 10 is 7.

Precedence of Operators

Arithmetic operators are evaluated according to their precedence.
Parentheses (): Evaluated first. If nested, the innermost are evaluated first.
Multiplication *, Division /, Modulus %: Evaluated second. If multiple, evaluated from left to right.
Addition +, Subtraction -: Evaluated last. If multiple, evaluated from left to right.
Example: 10 + 10 * 5 evaluates to 60 (10 * 5 first, then + 10). To force 10 + 10 first, use parentheses: (10 + 10) * 5 results in 100.
Careful use of parentheses is crucial for correct arithmetic expressions.

Tips (Lecture 3)

Use spaces in coding for readability.
Reserved words cannot be used as variable names.
A main() function is always the starting point of execution in a C program.
Write one statement per line for clarity.
Type parentheses () and braces { } in pairs.
Use parentheses for clarification in arithmetic expressions.
Don’t forget a semicolon at the end of each statement.
C language is case-sensitive (x and X are different variables).

Lecture No. 4: Sample Programs with Operators

Sample Program: Calculate Average Age

Problem Statement: Calculate the average age of ten students, prompting the user for each age.
Solution Analysis:
- Need ten variables for ages (int age1, ..., age10;).
- A single line declaration with comma separators is possible (int age1, age2, ..., age10;).
- A variable for total age (int TotalAge;) and average age (int AverageAge;).
- Ages are whole numbers, so int is appropriate.
- Integer Division Issue: If TotalAge is 173, 173 / 10 (integer division) yields 17, truncating the decimal part. To get the actual average (17.3), use float or double data types for average calculation.
- User Input: Use cout to prompt the user and cin to read input.
- cout << "Please enter the age of first student : "; displays a prompt.
- cin >> age1; reads user input and assigns it to age1.
- The >> operator indicates data flow from the user to the variable.
- cin stops execution and waits for user input, which is confirmed by pressing 'enter'.
- Similar to assignment, cin >> variable; requires a single variable on the right-hand side; expressions are incorrect.
- Summation: Add all ten age variables to TotalAge (e.g., TotalAge = age1 + age2 + ... + age10;). Operators with same precedence are evaluated left-to-right.
- Average: AverageAge = TotalAge / 10;
- Display Result: cout << "The average age of the students is : " << AverageAge;
Sample Output: If total age is 123, Average age of class is: 12 (due to integer truncation).

Examples of Expressions

Quadratic Equation: Algebraic y = ax^2 + bx + c becomes C expression y = a * x * x + b * x + c. Parentheses can be used for clarity: y = a * (x * x) + (b * y) + c. C does not have a power operator.
Operator Precedence: Remember *, /, % have higher precedence than +, -. Parentheses override precedence.
C uses only () for grouping expressions, unlike algebra which uses {} and [].

Use of Operators: Separate Digits of an Integer

Problem Statement: Take a four-digit integer from the user (e.g., 7531) and display its digits separately (1, 3, 5, 7).
Analysis:
- Extracting Last Digit: The modulus operator (% 10) gives the last digit (remainder when divided by 10). E.g., 1234 % 10 is 4.
- Removing Last Digit: Integer division (/ 10) removes the last digit. E.g., 1234 / 10 is 123.
- Variable Reuse: Instead of declaring new variables for each remaining number, reuse the same variable (e.g., number = number / 10;).
Program Logic:
- Declare int number, digit;
- Prompt user for input: cout << "Please enter 4-digit number:"; cin >> number;
- Loop to extract and display digits:
  - digit = number % 10; (gets last digit)
  - cout << digit << ", "; (displays digit)
  - number = number / 10; (updates number for next iteration)
- Repeat for all digits.
Sample Output: For input 5678, output is 8, 7, 6, 5.

Use of Operators: Circle Calculations

Problem Statement: Take radius from user, calculate and display diameter, circumference, and area of a circle.
Solution Analysis:
- Input: Use cin for radius.
- Data Types: Diameter, circumference, and area can be decimal, so use float or double.
- Formulas:
  - Diameter = 2 * radius
  - Circumference = 2 * Pi * radius (Pi = 3.14)
  - Area = Pi * radius * radius
- Constants: Use 3.14 for Pi.
Program Logic:
- Declare float radius, diameter, circumference, area;
- Prompt for radius: cout << "Please enter the radius of the circle "; cin >> radius;
- Calculate: diameter = radius * 2;, circumference = 2 * 3.14 * radius;, area = 3.14 * radius * radius;
- Display results: cout << "The diameter of the circle is : " << diameter; (and similarly for circumference and area).
Sample Output: For radius 5, diameter 10, circumference 31.4, area 78.5.

Tips (Lecture 4)

Use descriptive names for variables.
Indent code for readability.
Use parentheses for clarity and to force evaluation order in expressions.
Reuse variables for better memory usage.
Take care of division by zero.
Analyze the problem properly, then start coding (think first, then write).

Lecture No. 5: Conditional Statements (Decision Making)

Conditional Statements (Decision Making)

Decision making is a fundamental concept in daily life and programming.
Example: "If the milk shop is open, bring one liter of milk." This involves a condition (shop open) and an action (bring milk).
Programming languages provide structures for decision making. In C, this is the if statement.
Basic Structure of if statement:
```
if ( condition ) Statement (or group of statements)
```
- If the condition is true, the Statement (or block of statements) is executed.
- The condition is an expression that evaluates to true or false.
- Block of Statements: Multiple statements to be executed are enclosed in curly braces { }.
- Indentation and semicolons are crucial for readability and syntax.
Example (Comparing Ages):
- Declare int age1, age2;
- Assign values: age1 = 12; age2 = 10;
- Condition: if (age1 > age2) cout << "Student 1 is older than student 2";
- If age1 is indeed greater than age2, the message is displayed.

Relational Operators

Used for making decisions by comparing values.
Similar to algebraic relational operators.

Operators:

Algebraic	C Language	Example	Meaning
>	>	`x > y`	x is greater than y
=	`==`	`x == y`	x is equal to y
<	<	`x < y`	x is less than y
>=	`>=`	`x >= y`	x is greater than or equal to y
<=	`<=`	`x <= y`	x is less than or equal to y
≠	`!=`	`x != y`	x is not equal to y

Important Note: No space between characters for ==, >=, <=, !=.
= (Assignment) vs. == (Equality): Do not confuse them. Using = in an if condition (e.g., if (x = 2)) is a logical error, not a syntax error, because the assignment itself returns a value (which might be interpreted as true).

Flow Charting

A technique for analyzing and designing programs.
A pictorial representation of a program using labeled geometrical symbols connected by arrows.
Helps visualize the sequence of instructions and rectify logical errors by simulating the flow.
Flow Chart Symbols:
- Start/Stop: Oval shape.
- Process: Rectangle shape.
- Decision: Diamond shape.
- Flow Line: Arrow.
Flowchart for if structure: A diamond for the condition, with "True" and "False" paths leading to different processes or exits.

Flowchart for if structure: Start -> If condition is true? (Diamond) -> Yes -> Process -> Then -> Stop. No path from False.

Sample Program 1 (Conditional Statements)

Problem: Take ages of two students (Amer, Amara) from the user, compare them, and display who is older.
Variables: int AmerAge, AmaraAge; (variable names cannot contain spaces).
Initialization: Good practice to initialize variables (e.g., int x = 0;).
Input: Prompt user for ages and store in AmerAge and AmaraAge.
Condition: if (AmerAge > AmaraAge) cout << "Amer is older than Amara";
Flowchart: Shows input, decision (AmerAge > AmaraAge), and output if true.

Flowchart for Sample Program 1: Start -> Input AmerAge, AmaraAge -> If (AmerAge > AmaraAge) (Diamond) -> Yes -> Display "Amer is older than Amara" -> Stop. No path from No.

Issue with single if: If the condition is false (Amer is younger or same age), the program does nothing.
Solution with multiple if statements: Add another if statement for AmerAge < AmaraAge.

If/else Structure

Allows specifying a different block of statements to execute when the if condition is false.

Structure:

if ( condition ){ statement(s);}else{ statement(s);}

If condition is true, the if block executes. Otherwise, the else block executes.

Example (Comparing Ages with if/else):

if (AmerAge > AmaraAge){ cout << " Amer is older than Amara";}else{ cout << " Amer is younger than Amara";}

Logical Correction: The else part covers both "less than" and "equal to" cases. To be logically correct, the message should be "Amer is younger than or is of the same age as Amara".
Using >=: For "Amer is greater than or is of the same age", use >= in the if condition.
if/else saves from writing multiple single if statements for mutually exclusive conditions.
It is crucial to check all conditions for complete and logical results.

Flowchart for if/else structure: Start -> If (AmerAge > AmaraAge) (Diamond) -> Yes -> Display "Amer is older than Amara" -> Stop. No -> Display "Amer is younger than Amara" -> Stop.

Logical Operators

Used for complex conditions involving multiple criteria (AND, OR, NOT).
AND (&&): Both conditions must be true. (e.g., `age > 18 && height > 6` for basketball team selection).
OR (||): At least one condition must be true. (e.g., `BCS degree || BSC degree` for university admission).
Binary operators, taking two logical expressions as operands, returning TRUE or FALSE.
Truth Table for && and ||:
Expression 1 Expression 2 Expression 1 && Expression 2 Expression 1 || Expression 2
True False false True
True True true True
False False false False
False True false True
Precedence: && has higher precedence than ||. Both associate from left to right.
Short-circuit evaluation: Evaluation stops as soon as the truth or falsehood of the entire expression is known (e.g., if `age > 18` is false in `(age > 18) && (height > 6)`, the second part is not evaluated).
Logical Negation (!):
- Unary operator that reverses the meaning of a condition.
- Placed before a condition (e.g., `! (age > 18)`).
- If the original condition is false, `!` makes it true, and vice versa.
Truth Table for !:
Expression ! Expression
True False
False True

Sample Program 2 (Logical Operators)

Problem: Shopkeeper offers 10% discount on all bills, but 15% if bill amount > 5000. Calculate payable amount.
Solution Analysis:
- Use if/else structure based on bill amount.
- Declare double amount, discount, netPayable; and initialize.
- Prompt user for bill amount.
- Condition: if (amount > 5000)
  - If true: discount = amount * (15.0 / 100);
  - If false (else block): discount = amount * (10.0 / 100);
- Important: Use decimal values (e.g., 15.0 / 100) in division to avoid integer truncation. Declare variables as float or double.
- Calculate netPayable = amount - discount;
- Display results.
Flowchart: Shows decision based on `amount > 5000`, leading to different discount calculations.

Flowchart for Sample Program 2: Start -> If (amount > 5000) (Diamond) -> Yes -> Calculate discount at 15% -> Display net payable amount -> Stop. No -> Calculate discount at 10% -> Display net payable amount -> Stop.

Tips (Lecture 5)

Always put braces in an if/else structure.
Type beginning and ending braces before typing inside them.
Indent both body statements of an if and else structure.
Be careful while combining conditions with logical operators.
Use if/else structure instead of multiple single-selection if statements.

Lecture No. 6: Repetition Structures (Loops)

Repetition Structure (Loop)

Repetition is common in daily life (days, seasons) and programming (payroll procedures).
Problem: Calculate the sum of the first 10 whole numbers (1 to 10).
Inefficient Method: cout << "Sum..." << 1 + 2 + ... + 10; (becomes cumbersome for large numbers like 1000).
Efficient Method (Repetition):
- Start with sum = 0; and number = 1;
- Repeatedly add number to sum and increment number by 1 until number reaches 10.
- This requires a repetition structure or loop.
C language provides several looping constructs; this lecture focuses on the while loop structure.
while is a keyword and cannot be used as a variable name.
Meaning of while: "Do it until the condition is true."
Syntax of while construct:
```
while ( Logical Expression ){ statement1; statement2; ...}
```
- The Logical Expression (condition) is evaluated. If true, the statements within the braces are executed repeatedly.
- If the condition becomes false, the loop terminates, and control goes to the statement after the while block.
- Always use braces with while for good practice, even for a single statement, and indent the code for readability.
Example (Sum of first 1000 integers):
- Declare and initialize: int sum = 0; int number = 1;
- Condition: while ( number <= 1000 )
- Actions inside loop:
```
sum = sum + number;number = number + 1;
```
- The loop continues as long as number is 1000 or less. When number becomes 1001, the condition is false, and the loop terminates.
- Output: The sum of first 1000 integers is 500500.

Overflow Condition

Occurs when a number exceeds the maximum value a data type can store (e.g., an int variable, typically 32 bits, cannot store a number requiring more than 32 bits).
Consequences: Either a run-time error is generated, or a wrong value is stored (due to truncation of extra bits).
Example: If calculating the sum of 20000 integers, an int might overflow.
Reusability: To make programs generic and reusable (e.g., sum of any `upperLimit` integers), replace hardcoded limits with variables and get input from the user.

Sample Program 2: Sum of Even Numbers

Problem: Calculate the sum of even numbers for a given upper limit.
Solution Analysis:
- Use a while loop.
- Even Number Check: A number is even if its remainder when divided by 2 is zero (number % 2 == 0).
- Program Logic:
  - Declare int sum = 0, number = 1, upperLimit;
  - Prompt user for upperLimit.
  - while (number <= upperLimit)
    - Inside loop: if ( (number % 2) == 0 ) { sum = sum + number; } (adds even numbers to sum)
    - number = number + 1; (increments number for next iteration)
  - Display sum.
- Output Example: For upperLimit = 10, sum of even numbers is 30.

Infinite Loop

Occurs when the loop condition always remains true, causing the loop to execute forever.
Cause: The variable used in the loop condition is not changed within the loop body in a way that would eventually make the condition false (e.g., forgetting number = number + 1;).

Property of `while` loop

A while loop may execute zero or more times. If the condition is false initially, the loop body is never executed.
The loop terminates when the condition becomes false.
Always ensure the loop test has an adequate exit condition.
Always use braces for the loop structure; otherwise, only the first statement after while is considered part of the loop.

Flow Chart (`while` loop)

Represents the basic structure of a while loop: Start -> Process (initialization) -> Decision (Loop Condition, diamond) -> True path leads to Process (loop body) -> back to Decision. False path leads to Exit.

Flowchart for while loop: Start -> While (Rectangle) -> Is Loop Condition true? (Diamond) -> Yes -> Process -> (Loop back to While) -> No -> Exit.

Sample Program 3: Factorial Calculation

Problem: Calculate the factorial of a given number N (N! = N * (N-1) * ... * 2 * 1).
Solution Analysis:
- Repetitive multiplication, so a loop is needed.
- To make it generic, prompt the user for N.
- Multiply number (starting from N) by the decremented number until it reaches 1.
- Variables: int factorial, number;
- Initialization: factorial = 1; (for multiplication identity), number = user_input;
- Condition: while (number > 1)
- Actions inside loop:
```
factorial = factorial * number;number = number - 1;
```
- Display factorial.
Flowchart: Start -> factorial = 1, number = User input -> While (number > 1) (Diamond) -> Yes -> factorial = factorial * number, number = number - 1 -> (Loop back to While) -> No -> Display result -> Stop.

Flowchart for factorial calculation: Start -> factorial = 1, number = User input -> While (number > 1) (Diamond) -> Yes -> factorial = factorial * number, number = number - 1 -> (Loop back to While) -> No -> Display result -> Stop.

Tips (Lecture 6)

Always use self-explanatory variable names.
Practice a lot.
A while loop may execute zero or more times.
Make sure that the loop test (condition) has an acceptable exit.

Lecture No. 7: Do-While Statement, Increment/Decrement Operators

Do-While Statement

The while loop tests its condition at the beginning, so its body may execute zero or more times.
The do-while structure guarantees that the loop body executes at least once before the condition is tested.
Syntax of do-while:
```
do{ statement(s);} while ( condition ) ;
```
- The statements in the do block are executed first.
- Then, the condition in the while clause is tested. If true, the loop body repeats. If false, the loop terminates.
Flowchart of do-while: Process -> Condition (Diamond) -> Yes -> Process -> (Loop back to Process) -> No -> Exit.

Flowchart for do-while loop: Do While (Rectangle) -> Process -> Condition is true? (Diamond) -> Yes -> (Loop back to Process) -> No -> Exit.

Example (Guessing Character)

Problem: User guesses a character ('z') within five tries.
Variables: int tryNum = 0; char c;
Logic with do-while:
- do block:
  - Prompt user to enter a character (cout << "Please enter a character between a-z for guessing : "; cin >> c;).
  - Check if guess is correct: if (c == 'z') { cout << "Congratulations, Your guess is correct"; tryNum = 6; } (tryNum = 6 forces loop exit).
  - Else (incorrect guess): else { tryNum = tryNum + 1; }
- while (tryNum <= 5); (loop continues as long as tries are within limit and character not guessed).
Elegant Loop Exit: Instead of setting tryNum = 6, modify the while condition to a compound condition: while (tryNum <= 5 && c != 'z');. The loop exits if tries exceed 5 OR the correct character is guessed.

Flowchart for guessing game with do-while: Start -> Do While (Rectangle) -> Prompt user for input, check character, increment tryNum -> If counter <= 5 (Diamond) -> Yes -> (Loop back to Do While) -> No -> Exit.

For Loop

The for loop is a repetition structure used for a known number of repetitions.
It combines initialization, continuation/termination condition, and increment/decrement into a single line.
Syntax of for loop:
```
for ( initialization condition ; continuation condition ; incrementing condition ){ statement(s) ;}
```
- Initialization: Executed once at the beginning (e.g., counter = 0).
- Continuation Condition: Evaluated before each iteration. If true, loop body executes. If false, loop terminates.
- Incrementing Condition: Executed after each iteration of the loop body (e.g., counter = counter + 1).
Example (Printing 0-9):
```
for ( counter = 0 ; counter < 10 ; counter = counter +1 ){ cout << counter << endl;}
```
- Initializes counter to 0.
- Continues as long as counter < 10.
- Increments counter by 1 after each iteration.
- Output: 0, 1, 2, ..., 9.
Property of for loop: Like while, a for loop may execute zero or more times if the initial condition is false.
The increment statement is executed *after* the loop body.

Sample Program 1 (`for` loop: Multiplication Table)

Problem: Print the multiplication table of 2 up to 10.
Solution:
- Declare int counter;
- for ( counter = 1 ; counter <= 10 ; counter = counter + 1) { cout << "2 x " << counter << " = " << 2 * counter << "\n" ; }
- Initializes counter to 1, loops until 10, increments by 1.
- Output: 2 x 1 = 2, ..., 2 x 10 = 20.
Reusability: To make the program generic (table of any number up to any multiplier), replace hardcoded values with variables (e.g., number, maxMultiplier) and get user input.

Increment Decrement Operators

C provides unary operators for incrementing (++) and decrementing (--) a variable by 1.
Increment Operator (++): Replaces counter = counter + 1; with counter++; or ++counter;.
Decrement Operator (--): Replaces counter = counter - 1; with counter--; or --counter;.
Pre-increment (++j) vs. Post-increment (j++):
- Pre-increment: Value is incremented *first*, then used in the expression. (e.g., x = ++j; if j=5, then j becomes 6, and x becomes 6).
- Post-increment: Value is used in the expression *first*, then incremented. (e.g., x = j++; if j=5, then x becomes 5, and j becomes 6).
- Same logic applies to pre/post decrement.
Compound Assignment Operators: For incrementing/decrementing by a number other than 1 (e.g., counter = counter + 5;), C provides shorthand operators:
- += (addition assignment)
- -= (subtraction assignment)
- *= (multiplication assignment)
- /= (division assignment)
- %= (modulus assignment)
Example: counter = counter + 5; is equivalent to counter += 5;.
No space between operator characters (e.g., +=, not + =).

Example Program 2 (`for` loop: Sum of Squares)

Problem: Find the sum of squares of integers from 1 to n, where n is user-entered.
Solution:
- Declare int i, n, sum; and initialize sum = 0;
- Prompt user for n.
- for ( i = 1 ; i <= n ; i ++) { sum += i * i ; } (sum += i * i; is equivalent to sum = sum + (i * i);).
- Display sum.
- Output example: For n=5, sum of squares is 55.

Tips (Lecture 7)

Comments should be meaningful.
Don’t forget to affect the value of loop variable in while and do-while loops to ensure termination.
Make sure the loop is not an infinite loop.
Don’t affect the value of loop variable in the body of for loop, as for handles it.
Use pre and post increment/decrement operators cautiously in expressions.

Lecture No. 8: Switch Statement, Break/Continue, Structured Programming Rules

Switch Statement

Used for multi-way decisions where multiple conditions lead to different actions.
Example: Assigning descriptions to student grades (A, B, C, D, F).
Using multiple if statements (e.g., `if (grade == 'A') ... if (grade == 'B') ...`) is computationally expensive as each `if` condition is evaluated.
Nested if/else if statements are more efficient than separate `if` statements.
The switch structure is a multiple-selection construct that is more efficient and readable for such cases.
Syntax of switch statement:
```
switch ( variable/expression ){ case constant1 : statementList1 ; case constant2 : statementList2 ; ... case constantN : statementListN ; default : statementList ;}
```
- The variable/expression must evaluate to an integer type (including char, as characters have ASCII numeric values). Compound conditions (using && or ||) are not allowed in switch or case statements.
- constant1, constant2, etc., must be integer constants (including char literals). Variable names are not allowed with case.
- If the variable/expression matches a case constant, the corresponding statementList is executed.
- The default statement is optional and executes if no case matches.
Case Fall-through: Without a break statement, execution "falls through" to subsequent case statements after a match. This is usually undesirable.
Case Sensitivity: C is case-sensitive. 'A' is different from 'a'. To handle both, separate case statements are needed (e.g., `case 'A': case 'a': ...`).

Break Statement

Interrupts the flow of control.
Purpose in switch: After a case statement's code is executed, break; is used to exit the switch block, preventing fall-through to other cases.
Purpose in Loops: Can be used to exit a loop (while, do-while, for) immediately, even if the loop condition is still true. Control passes to the statement after the loop.
Example (Guessing Game): If the correct character is guessed, a break; statement can exit the loop early.

Continue Statement

Forces the immediate next iteration of the loop.
Statements after continue; within the current loop iteration are skipped.
In while and do-while loops, ensure the loop control variable is updated *before* continue; to avoid infinite loops.
In for loops, the increment/decrement part is executed automatically before the next iteration, even if continue; is encountered.

Goto Statement

An unconditional branch of execution, allowing control to jump anywhere in a program.
Historically led to "spaghetti code" that was difficult to read, understand, trace, debug, and modify.
Structured programming principles (sequences, decisions, loops) are sufficient for any program.
Recommendation: Avoid using goto statement.

Guide Lines for Programming

Minimize the use of break and continue statements in loops (except where necessary, like break in switch). Use if statements instead of continue where possible.
Never use goto statement.
Modular Programming: Divide large programs into smaller, manageable parts (modules/functions).
Single Entry, Single Exit: Each module or construct should have one entry point and one exit point. Using break in a loop violates this rule by creating multiple exit points. This approach simplifies execution flow.
Flowcharting: Structured flowcharts (vertical flow, no leftward movement) should correspond directly to code structure, aiding debugging.

Rules for Structured Programming/Flow Charting

Start with simple flowchart: Draw a start symbol, a process rectangle, and a stop symbol.
Replace rectangles with two rectangles: Break complex processes into simpler ones (divide and conquer).
Replace rectangles with structured constructs: Any rectangle can be replaced by a decision (if, if/else, switch) or loop (while, do-while, for) construct. This highlights the single entry/single exit advantage.
Repeat rules 2 and 3: Apply iteratively to refine the design.

This approach simplifies problem-solving and debugging by creating a clear correspondence between flowchart segments and code.

Sample Program (Grade Description with `switch`)

Problem: Take a student's grade (A, B, C, D, F) and print its description (Excellent, Very Good, Good, Poor, Fail).
Solution:
- Declare char grade;
- Prompt user for grade.
- Use a switch statement with case for each grade ('A', 'a', 'B', 'b', etc.).
- Each case block prints the description and includes a break; statement.
- A default case handles invalid input.
Flowchart: Shows a switch symbol, leading to multiple case paths, each with a process and a break, and a default path.

Flowchart for grade description using switch statement: Start -> switch (grade) (Diamond) -> case 'A' -> Display "Excellent" -> break -> case 'B' -> Display "Very Good" -> break -> ... -> default -> Display error message -> break -> Stop.

Tips (Lecture 8)

Try to use the switch statement instead of multiple if statements for multi-way decisions.
Missing a break statement in a switch statement may cause a logical error (fall-through).
Always provide a default case in switch statements to handle unexpected inputs.
Never use goto statement in your programs.
Minimize the use of break and continue statements where possible.

Lecture No. 9: Functions

Introduction

Programming toolkit now includes sequence, decision making, and loops.
Functions are a major programming construct in C, which is a function-oriented language.
Functional Design / Top-Down Designing: Breaking down a large task into smaller, manageable sub-tasks. This continues until tasks are easily doable.
Example (Stool Construction): Main task (make stool) -> sub-tasks (make seat, make legs) -> sub-sub-tasks (fashion one leg, reuse for two more).
Example (LMS Login Count): Request (number of logged-in students) -> delegated to network administrator (performs function) -> result returned. This demonstrates information hiding and parallel processing.

Functions

Functions are like sub-tasks: they receive information, process it, and provide a result.
A calling program invokes a function, provides information (arguments), and receives a result. It doesn't need to know the internal workings of the function (information hiding).
main() is also a function.
Functions are crucial for code reuse.
Categories of Functions:
1. Functions that return a value.
2. Functions that do not return a value (e.g., a function that displays information).

Structure of a Function

Declaration Syntax:

return-value-type function-name( argument-list ){ declarations and statements}

The first line is the function header; the rest is the body.

return-value-type:
- Specifies the data type of the value the function returns. Can be int, float, char, etc.
- A function can return only one value of a specific data type.
- The return keyword is used to return a value and exit the function. The data type of the returned value must match the return-value-type.
- If a function does not return any value, its return-value-type is void (a C keyword).
- Default return-value-type is int if not specified.
function-name:
- Follows variable naming conventions.
- Should be self-explanatory (e.g., square, squareRoot, circleArea).
argument-list:
- Contains information passed to the function. Can be empty if no information is needed.
- Arguments have valid data types (e.g., int number, double radius).
Declarations and Statements: The function body, where its task is performed.

Example (Square Function):

//This function calculates the square of a number and returns it.int square(int number){ int result = 0; result = number * number; return result;}

Calling Mechanism

To use a function, the calling program writes the function name and provides its arguments (without data types).

Example (Calling Square Function):

//This program calculates the square of a given number#include <iostream.h>main(){ int number, result; result = 0; number = 0; cout << " Please enter the number to calculate the square "; cin >> number; // Calling the function square(int number) result = square(number); cout << " The square of " << number << " is " << result;}

result = square(number); calls the square function, passing the value of number. The returned value is assigned to result.

Declaration and Definition of a Function

Declaration (Prototype/Signature): A one-line statement specifying the return type, function name, and data types of arguments. Argument names are optional.
Definition: The complete function code, including the header (with argument names) and the body (statements enclosed in braces).
If a function is defined *before* its first call, a separate declaration is not strictly needed (the definition acts as a prototype).
If a function is defined *after* its first call (or in a separate file), its prototype must be declared *before* any calls to it.

Example (Declaration and Definition):

// Declaration:int square ( int ); // Definition:int square ( int number){ return (number * number ) ;}

Sample Program 1 (Power Function)

Problem: Calculate the integer power of some number (x^n).
Solution Analysis:
- No built-in power operator in C.
- Need a loop to multiply x by itself n times.
- Arguments: Base (double x), exponent (int power).
- Return Type: double (result can be real).
- Function Name: raiseToPow (descriptive).
- Prototype: double raiseToPow ( double x, int power ) ;
- Definition Logic:
  - Initialize double result = 1.0;
  - Loop for (i = 1; i <= power; i++) { result *= x; }
  - Return result.
- Calling Mechanism: cout << x << " raise to power " << i << " is equal to " << raiseToPow ( x , i ) ;
Call by Value: By default, C passes arguments by value. Copies of x and i are passed to raiseToPow, so their original values in the calling program remain unchanged.

Sample Program 2 (Area of a Ring)

Problem: Calculate the area of a ring given outer and inner radii.
Solution Analysis:
- Ring area = Area of outer circle - Area of inner circle.
- Area of circle = Pi * r^2.
- Write a function circleArea(double radius).
- Prototype: double circleArea ( double);
- Definition: return ( 3.1415926 * radius * radius ) ;
- Calling Logic: ringArea = circleArea ( rad1 ) – circleArea (rad2 ) ;

Sample Program 3 (Even/Odd Check)

Problem: Write a function to test if a number is even, returning true (1) or false (0).
Solution Analysis:
- Even number check: number % 2 == 0.
- Function Name: isEven.
- Return Type: int (0 for false, non-zero for true).
- Argument: int number.
- Prototype: int isEven ( int ) ;
- Definition: if ( 2 * ( number / 2 ) == number ) { return 1; } else { return 0; }
- Usage in conditional statements: if ( isEven ( number ) ).

Summary (Lecture 9)

Functions are excellent for code reuse and encapsulation.
A function performs a specific task.
Function declaration (prototype/signature) must occur before usage if the definition is after the calling program.
Top-down methodology: Break programs into smaller, self-contained modules.

Tips (Lecture 9)

Use functions for top-down structured approach.
Each function should be a small, self-contained module solving a well-defined problem.
Variable and function names should be self-explanatory.
Always comment the code.

Lecture No. 10: Header Files, Scope of Identifiers, Call by Value/Reference (continued)

Header Files

Header files (e.g., iostream.h) contain function prototypes and constant definitions.
Purpose: To avoid explicitly writing all function prototypes before their usage, especially for frequently used functions or when functions are in separate files.
Mechanism: The #include directive replaces the directive line with the content of the specified file during preprocessing.
Custom Header Files: Programmers can create their own .h files for prototypes and constants.
#include Syntax:
- #include <filename.h>: Compiler searches in specific system directories.
- #include "filename.h": Compiler searches in the current working directory first, then system directories.
#define Directive:
- Used to define macros (symbolic names mapped to values or expressions).
- Example: #define PI 3.1415926.
- The preprocessor replaces all occurrences of the macro name (e.g., PI) with its definition before compilation.
- Benefits: Centralized modification of constants, improved readability (using meaningful names like PI instead of raw numbers).
- Macros are not variables; they cannot be assigned new values.

Scope of Identifiers

An identifier is any name created by the user (variables, functions, labels).
Scope refers to the visibility of an identifier.
Levels of Scope:
- Block Level Scope: Variables declared inside a code block (enclosed by { }) are local to that block and not visible outside it.
- Function Level Scope: Variables declared inside a function (but not within an inner block) are local to that function.
- File Level Scope (Global Variables): Variables declared outside any function body are visible and accessible from all functions within that file.
Shadowing: If a variable with the same name is declared in an inner scope, it "overrides" or hides the variable from the outer scope within that inner block.
Best Practice: Minimize global variables; use local variables as much as possible. Avoid re-declaring variables with the same name in inner blocks to prevent confusion.
Encapsulation and Data Hiding: This philosophy encourages local declaration and use of data.

Function Calling (Call by Value vs. Call by Reference)

Call by Value (Default in C for simple variables):
- When arguments are passed, a *copy* of their values is made and passed to the function.
- The function manipulates these copies, leaving the original variables in the calling program unchanged.
- Analogy: Giving someone a photocopy of a letter to correct; the original remains untouched.
Call by Reference:
- Allows a function to change the values of the original variables passed as arguments.
- Instead of values, the *memory address* of the variable is passed.
- Mechanism: In C, this is achieved using pointers (& operator to get address, * operator to dereference).
- Analogy: Giving someone the original letter to correct; changes are made directly to the original.
- Used when the called function needs to modify the original variable or for efficiency when passing large data structures (to avoid copying).
Arrays and Call by Reference (Default in C for arrays):
- When an array is passed to a function, its name (which is the starting memory address of its first element) is passed. This is a call by reference.
- Any modifications to the array elements within the function affect the original array in the calling program.
- To pass an array, specify its name (without brackets) and its size in the function call. The function's parameter list must specify it as an array (e.g., char arr[], int arraySize).

Lecture No. 11: Arrays, Initialization, Copying, Linear Search, `const` Keyword

Introduction to Arrays

Arrays are a crucial component in programming, especially for handling collections of data of the same type.
Problem: Calculating the average age of 100 students would require 100 individual variables, which is inefficient. Arrays offer a solution.

Arrays

Definition: A data structure that stores a collection of data items of the same type in contiguous memory locations.
Properties:
- Data Type: All elements must be of the same valid data type.
- Name: Follows variable naming conventions.
- Size: A precise number indicating the number of elements.
- Memory: Occupies a contiguous area in memory.
Declaration: data_type array_name [size]; (e.g., int ages[10];).
Indexing (Subscript): Elements are accessed using an index (subscript) enclosed in square brackets [].
Zero-based Indexing: In C, array indices start from 0 and go up to size - 1. (e.g., for int C[10], indices are C[0] to C[9]).

Memory image of an array C with elements C[0] to C[9] and their corresponding values. C[0] has value 24, C[1] has 59, etc.

Usage of Arrays

Arrays can be declared with other simple variables on a single line (e.g., int i, age[10];).
Individual array elements are treated like simple variables and can be used in assignment statements, expressions, etc. (e.g., age[5] refers to the 6th element).
Example (Calculating Average Age with Loop):
- Use a for loop to read 10 student ages into an array:for (i = 0; i < 10; i++) { cout << "Please enter the age of student "; cin >> age[i]; }
- Use another for loop to sum the ages:int totalAge = 0; for (i = 0; i < 10; i++) { totalAge += age[i]; }

Initialization of Arrays

Explicit Initialization:
- Using a loop:for (i = 0; i < 10; i++) { age[i] = 0; }
- At declaration time with an initializer list:int age[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- Shorthand for initializing all elements to zero:int age[10] = {0};
- Omitting size (compiler infers from initializer list):int age[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

Copying Arrays

To copy one array to another, both arrays must have the same data type and size.
Method: Use a loop to copy elements one by one:for (i = 0; i < 10; i++) { b[i] = a[i]; }
This method is efficient and adaptable to different array sizes by changing the loop condition.

Sample Program 1 (Sum of Squares in Array)

Problem: Calculate the sum of squares of 10 different numbers stored in an array.
Solution:
- Declare int a[10]; int sumOfSquares = 0;
- Use a loop to get 10 numbers from the user into array a.
- Use another loop to calculate sum of squares:for (i = 0; i < 10; i++) { sumOfSquares = sumOfSquares + a[i] * a[i]; }
- Display sumOfSquares.

Linear Search

Problem: Find a specific number in a list of numbers (array).
Technique: Compare the target number with each element of the array sequentially.
Logic:
- Declare an array (e.g., int a[100];) and populate it.
- Declare a variable for the number to search (int z;) and a flag (int found = 0;).
- Use a for loop to iterate through the array:for (i = 0; i < 100; i++) { if (z == a[i]) { found = 1; break; } }
- If found is 1, the number was found at index i; otherwise, it was not found.
- Using break exits the loop early once the number is found, improving efficiency.
Random Number Generation (Guessing Game):
- Use rand() function (from stdlib.h) to generate random numbers (0 to 32767).
- To limit the range (e.g., 1-6 for a die), use modulus: 1 + rand() % 6;.
- The srand(time(0)) function (from time.h) seeds the random number generator with a different value each time, producing a different sequence of "random" numbers.

The Keyword `const`

Used to declare an identifier as a constant, meaning its value cannot be changed after initialization.
Syntax: const int arraySize = 100;
Benefit for Arrays: Use const for array sizes (e.g., int age[arraySize];). If the size needs to change, only the const declaration needs modification, making the program more maintainable.
Assigning another value to a const variable is a syntax error.

Tips (Lecture 11)

Initialize arrays explicitly.
Array indices start from 0 and end at size - 1.
To copy an array, both arrays must have the same size and data type.
Array subscripts can be integers or integer expressions.
Assigning another value to a const is a syntax error.

Lecture No. 12: Character Arrays, Multidimensional Arrays, Sorting, Searching

Character Arrays

Used to store words and sentences (strings of characters).
A simple char variable stores only a single character.
Declaration: char name[100]; declares a character array (string) of size 100.
Special Property: Null Character (` `):
- C uses the null character (represented as "\0", ASCII code 0) to terminate strings.
- When a string is placed in a character array, the computer automatically appends "\0" to mark its end.
- The actual memory occupied by a string is the number of characters plus one for the null terminator.
- If a string larger than the array size is placed without a null terminator, it can lead to logical errors as the program won't know where the string ends.
Storing Strings: Use cin >> name; to read a whole string until the user presses Enter. cin is intelligent enough to handle character arrays.
Displaying Strings: Use cout << name; to display the string. cout reads up to the null character.
Displaying Character by Character: A for loop can iterate through the array and print each character until "\0" is encountered.

Initialization Of Character Arrays

Integer Array Initialization:int age[5] = {12, 13, 16, 13, 14}; (compiler infers size if not specified).
Character Array Initialization:
- Character by character: char name[100] = {'i', 'm', 'r', 'a', 'n', '\0'}; (explicit null terminator).
- Using a string literal (double quotes): char name[100] = "imran"; (compiler automatically adds "\0").
- Omitting size: char name[] = "Hello World"; (compiler allocates memory for string + null terminator).

Arrays Comparison

To compare two arrays for equality:
- First, check if their sizes are equal.
- Then, compare elements one by one using a loop.
- Use a flag (e.g., int equals = 0;) to track equality.
- If any elements are not equal, set the flag and break the loop (using != operator).
- If the loop completes and the flag is still 0, arrays are identical.
Case Sensitivity: C language is case-sensitive, so "AZMAT" is not equal to "azmat".

Sorting

Problem: Sort an array in ascending order.
Technique: Swapping:
- To interchange two values, a temporary variable is used.
- x = num[0]; num[0] = num[15]; num[15] = x; (swaps num[0] and num[15]).
Sorting Process (Selection Sort concept):
- Find the smallest number in the array (starting from index 0).
- Swap it with the element at the current first position.
- Repeat for the rest of the array (starting from index 1).
This is a brute-force method; large arrays can be slow.

Searching

Linear Search:
- Compares the target value with each element in the array sequentially.
- Can be inefficient for large arrays.
Binary Search Algorithm:
- More efficient than linear search.
- Applies the "divide and conquer" strategy.
- Requirement: Array must be sorted (ascending or descending).
- Process:
  - Compare target value with the middle element of the array.
  - If no match, discard half of the array (left if target is greater, right if target is smaller for an ascending array).
  - Repeat the process on the remaining half.
- Each iteration reduces the search space by half.
- Efficiency: For 1000 elements, linear search might take 1000 iterations, binary search takes at most 10 (since 2^10 = 1024).

Functions and Arrays

Default Mechanism: Call by Value for simple variables, Call by Reference for arrays.
When passing an array to a function, the array's name (which is its starting memory address) is passed. This is a call by reference.
Any changes made to the array elements within the function will affect the original array in the calling program.
To pass an array, specify its name (without brackets) and its size. The receiving function's parameter list must specify it as an array (e.g., int num[], int arraysize).
Passing a single element of an array (e.g., x[3]) to a function is a call by value, as it's treated as a simple variable.

Multidimensional Arrays

Used for data structures like vectors and matrices (rows and columns).
Declaration: data_type array_name [rows][columns]; (e.g., int numbers[2][3]; for 2 rows, 3 columns).
Accessing Elements: Use row and column numbers (e.g., a[1][2]).
Populating: Use nested for loops. The outer loop iterates through rows, the inner loop through columns.
C language supports arrays of any number of dimensions (e.g., int num[3][5][7];).

Example 2 (Multidimensional Array Input/Output)

Problem: Fill a 2x3 matrix with user values and display it in row-column format.
Solution:
- Declare int matrix[2][3], row, col, maxrows = 2, maxcols = 3;
- Input (Nested Loops):
```
for (row = 0; row < maxrows; row ++){ for(col=0; col < maxcols; col ++){ cout << "\n" << "Enter " << row << ", " << col << " element: "; cin >> matrix[row][col]; }}
```
- Display (Nested Loops): Similar structure, using cout << matrix[row][col] << '\t'; and cout << '\n'; for formatting.

Tips (Lecture 12)

A character array can be initialized using a string literal.
Individual characters in a string stored in an array can be accessed directly using array subscript.
Arrays are passed to functions by reference.
To pass an array to a function, the name of the array (without any brackets) is passed along with its size.
To receive an array, the function’s parameter list must specify that an array will be received.
Including variable names in function prototype is unnecessary; the compiler ignores these names.

Lecture No. 13: Array Manipulation (Multidimensional), Real World Problem & Design Recipe

Array Manipulation

Arrays store identical or similar values (e.g., heights in one array, ages in another).
Processing arrays often involves iterative structures (loops).
Two-dimensional arrays: Can be understood as matrices with rows and columns.
Example (Inputting a 3x3 Matrix):
- Declare const int maxRows = 3; const int maxCols = 3; int a[maxRows][maxCols];
- Use nested for loops to input values: outer loop for rows, inner loop for columns.
- cout << "\n" << "Enter " << row << ", " << col << " element: "; cin >> a[row][col];
Example (Displaying Flipped Matrix - Reverse Row Order):
- Instead of incrementing row counter, decrement it: for ( row = maxRows-1; row >= 0; row --)
- Inner loop for columns remains the same: for ( col = 0; col < maxCols; col ++)
- Use '\t' for tab and '\n' for newline characters for formatting.

Real World Problem and Design Recipe

Problem: Identify "unlucky employees" who earn less net salary than colleagues with lower gross salaries due to tax brackets.
Design Recipe Steps:
1. Analysis: Precisely state the problem, identify inputs, constants, and data structures.
2. Design: Break problem into functional units, detailed design.
3. Implementation: Translate pseudo-code to computer language, compile, run.
4. Testing: Verify behavior in all scenarios, fix bugs.
Problem Statement (Precise): "Given tax brackets and given employees gross salaries, determine those employees who actually get less take-home salary than others with lower initial income."
Tax Deduction Rules:
- Rs. 0-5,000: 0% tax.
- Rs. 5,001-10,000: 5% tax (e.g., 10,000 gross -> 9,500 net).
- Rs. 10,001-20,000: 10% tax (e.g., 10,001 gross -> 9,000.9 net, which is less than 9,500, highlighting the "unlucky" scenario).
- Rs. 20,001+: 15% tax.

Problem Analysis (Continued)

Inputs: Number of employees, gross salary for each.
Data Structures:
- Two-dimensional array (e.g., double sal[arraySize][2];) to store gross salary (column 0) and net salary (column 1).
- One-dimensional array (e.g., int lucky[arraySize] = {0};) to mark unlucky employees (0 for lucky, 1 for unlucky).
Interface Issues: Program should be user-friendly, with clear prompts for input.
Program Parts (Functions): Get input, calculate salary, identify unlucky individuals, display output.

Design Issues and Class Interface

Matrix Size: Specify at creation time, allocate memory dynamically.
Constructor: Matrix ( int rows, int cols ) ; will handle memory allocation.
Display Function: void display ( Matrix & ); to show elements.
Operator Overloading:
- + operator for matrix addition (member function).
- - operator for matrix subtraction (member function).
- + operator for scalar addition (member function for Matrix + scalar, friend function for scalar + Matrix).
- - operator for scalar subtraction (member function for Matrix - scalar, friend function for scalar - Matrix).
- * operator for matrix multiplication (member function).
- * operator for scalar multiplication (member function for Matrix * scalar, friend function for scalar * Matrix).
- / operator for scalar division (member function).
- += and -= operators (member functions).
- transpose() function (member function).
- Stream insertion (<<) and extraction (>>) as friend functions.
Return Types: Operators returning a new matrix should return by value. Operators modifying the calling object (like +=) should return a reference to the calling object.
Error Checking: Implement checks for conformability (e.g., for matrix addition/multiplication) and division by zero.
Data Hiding: Data members (numRows, numCols, elements) should be private.

Lecture No. 14: Pointers (continued), Declaration, Bubble Sort, Pointers & Call By Reference

Pointers

Definition: A special type of variable that stores a memory address, not a value.
Analogy: Referring to a person by their name (direct reference) vs. by their house number (indirect reference via address).
Direct Reference: Accessing a value using a variable name (e.g., x = 10;).
Indirect Reference: Accessing a value through its memory address, typically stored in a pointer.

Diagram showing direct and indirect referencing. 'x directly references a variable whose value is 10'. 'xptr indirectly references a variable whose value is 10'.

Declaration of Pointers

Pointers are associated with a specific data type they point to (e.g., pointer to an integer, double, character).
Syntax: data_type *name; (e.g., int *myptr;).
The asterisk * is associated with the variable name, not the data type (e.g., int *ptr1, *ptr2, *ptr3; declares three integer pointers).
Pointers can be mixed with simple variables and arrays in a single declaration (e.g., int *ptr, x, a[10];).
Pointers hold whole numbers representing memory addresses.
Address Operator (`&`): Used to get the memory address of a variable (e.g., ptr = &x; assigns the address of x to ptr).

Diagram showing a variable 'x' with value 10 at address 400000, and a pointer 'ptr' at address 500000, pointing to x's address (400000).

Dereferencing Operator (`*`): Used to get the value stored at the memory address pointed to by a pointer (e.g., z = *ptr; assigns the value at ptr's address to z).
Initialization: Pointers should be initialized when declared, either to a valid memory address, 0, or NULL (a global variable defined in stdlib.h/stddef.h, representing an invalid memory address).

Pointers and Call By Reference

Pointers are used to simulate call by reference in functions.
When calling a function, pass the address of the variable using & (e.g., fn(&x)).
The receiving function's parameter must be a pointer to the appropriate data type (e.g., void fn(int *num)).
Inside the function, use the dereferencing operator * to manipulate the value at the address (e.g., cin >> *num;).
This allows the function to modify the original variable in the calling program.

Example (Bubble Sort)

Bubble Sort: Compares adjacent values and swaps them to sort an array.
Swapping Technique: Uses a temporary variable (tmp) to interchange values of two variables (x, y):
```
tmp = x;x = y;y = tmp;
```
Call by Value Issue: If a swap(int x, int y) function is called by value, it only swaps copies, leaving original variables unchanged.
Call by Reference Solution (using Pointers):
- Pass addresses to the swap function: swap(&x, &y);
- Function prototype: void swap(int *xptr, int *yptr);
- Inside function, use dereferencing: tmp = *xptr; *xptr = *yptr; *yptr = tmp;
This technique is used in bubble sort to interchange array elements.

Lecture No. 15: Pointers & Arrays Relationship, Pointer Arithmetic, Comparison, Strings

Relationship between Pointers and Arrays

An array name (e.g., y in int y[10];) is a constant pointer that holds the memory address of the first element of the array (y[0]).
A constant pointer cannot be reassigned to point to another memory location.
A pointer variable (e.g., int *yptr;) can be assigned the address of an array's first element (yptr = y;), making both point to the same location. However, yptr is a variable pointer and can be changed.

Pointer Expressions and Arithmetic

Pointers can be manipulated with arithmetic operations.
Accessing Array Elements:
- Using array indexing: y[3].
- Using pointer arithmetic: *(yptr + 3) (dereferences the address 3 elements past yptr).
Pointer Increment/Decrement (`yptr++`):
- Increments the pointer's value by the number of bytes occupied by the data type it points to.
- Example: If yptr points to an int (4 bytes), yptr++ increases its address by 4, making it point to the next int element in memory.
Accessing Addresses: yptr = &y[0]; assigns the address of the first element to yptr.
Dereferencing: cout << *yptr; displays the value at the address yptr points to.
Warning: Incrementing a pointer beyond the array bounds can lead to accessing garbage memory.
Important Rule: When a pointer holds the address of a simple variable, do not increment/decrement the pointer itself. When it holds an array's address, incrementing/decrementing makes sense to move between elements.
Pointer Subtraction: Subtracting two pointers (pointing within the same array) yields the number of elements between them, in units of the data type. Pointer addition is generally not allowed.

Diagram showing an array 'y' in memory with addresses 3000, 3004, 3008, etc. A pointer 'yptr' initially points to 3000. After 'yptr++', it points to 3004.

Pointer Comparison

Two pointers can be compared using relational operators (<, >, ==, etc.).
Comparing *yptr1 > *yptr2 compares the *values* at the addresses they point to.
Comparing yptr1 > yptr2 compares the *addresses* themselves.

Pointer, String and Arrays

Character strings are character arrays, terminated by a null character ("\0").
Initialization: Can be initialized character by character (name[0] = 'A';) or using string literals (char name[20] = "Amir";, where "\0" is automatically appended).
Rule: A character array must be at least one character larger than the number of printable characters to store the null terminator.
Example (String Copy with Pointers):
- Declare source and destination character arrays (char strA[80] = "A test string"; char strB[80];) and character pointers (char *ptrA, *ptrB;).
- Assign starting addresses: ptrA = strA; ptrB = strB;
- Loop to copy character by character:while(*ptrA != '\0') { *ptrB++ = *ptrA++; }
- Explicitly add null terminator to destination: *ptrB = '\0';
- This is a call by reference mechanism, as pointers directly manipulate memory.
`const` with Pointers:
- int *const myptr = &x;: myptr is a constant pointer to an integer. It must be initialized and cannot be changed to point to another address. The value it points to (*myptr) *can* be changed.
- const int *myptr = &x;: myptr is a pointer to a constant integer. It can be changed to point to another address, but the value it points to (*myptr) *cannot* be changed.
- Useful for passing arguments by reference to a function without allowing the function to modify the original data.

Lecture No. 16: Pointers (continued), Multidimensional Arrays, Pointers to Pointers, Command-line Arguments

Pointers (continued)

Character Arrays vs. Pointers to Strings:
- char myName[] = "Full Name";: myName is a constant pointer to the string literal "Full Name". Its address cannot be changed.
- char *myNamePtr = "Full Name";: myNamePtr is a variable pointer to the string literal. It can be reassigned to point to other strings.
Array names can be used as pointers, but only as constant ones.

Multi-dimensional Arrays and Pointers

A two-dimensional array (e.g., char multi[5][10];) is stored contiguously in memory.
The array name (multi) points to the starting memory location of the entire array.
Pointer Arithmetic with Multidimensional Arrays:
- multi + 1: Increments by the size of one *row* (number of columns * size of element type). For char multi[5][10], multi + 1 jumps 10 bytes (10 chars * 1 byte/char).
- *(multi + 3): Dereferences to the starting address of the 4th row (row index 3).
- *(*(multi + 3) + 3): Double dereferencing to access an element. (multi + 3) points to the 4th row, *(multi + 3) dereferences to the content of the 4th row (which is itself a pointer to its first element), then + 3 moves 3 elements into that row, and the final * dereferences to the value of the element. This is equivalent to multi[3][3].
Accessing multidimensional arrays using pointer arithmetic can be complex and array indexing is often preferred for clarity.

Pointers to Pointers

A pointer to a pointer stores the address of another pointer.
Single Dereference: A pointer (e.g., ptr) contains the address of a variable (e.g., x), and *ptr gives the value of x.
Double Dereference: A first pointer contains the address of a second pointer, which in turn contains the address of the variable holding the desired value.
Example: In **multi, multi is a pointer to an array of pointers (rows), and *multi is a pointer to the first element of the first row. **multi accesses the value of the first element.

Command Line Arguments

Arguments passed to a program when it is executed from the command line.
Syntax of main() with arguments: main(int argc, char **argv)
- argc (argument count): An integer representing the number of command-line arguments, including the program name itself.
- argv (argument vector): A pointer to an array of character strings (pointers to char), where each string is a command-line argument. **argv can be read as "pointer to pointer to char".
Example: C: ool>Program-name argument1 argument2. Here, argc would be 3, and argv would point to an array containing "Program-name", "argument1", "argument2".
Error Handling: Programs using command-line arguments should check argc to ensure proper information is provided.
Conversion: Command-line arguments are always character strings. Functions like atoi() (from stdlib.h) convert strings to integers.
Limitations: Operating systems typically limit the maximum length of command-line arguments.
Professional Touch: Using command-line arguments makes programs more professional and facilitates use in batch files.

Case Study: A Card Shuffling and Dealing Simulation

Problem: Randomly shuffle a deck of 52 cards and deal them out.
Card Facts: 4 suits (Hearts, Spades, Diamonds, Clubs), 13 faces (Ace, Deuce, ..., King). Total 52 cards.
Data Structures:
- const char *suit[4] = {"Hearts", ...}; (array of pointers to char for suits).
- const char *face[13] = {"Ace", ...}; (array of pointers to char for faces).
- int deck[4][13] = {0}; (2D array to represent the deck, 0 for empty, 1-52 for cards).
Algorithm Analysis:
- Shuffle: Use a loop to randomly select a suit (0-3) and face (0-12) using rand() % 4 and rand() % 13. Store a card number (1-52) in deck[row][column]. Use a do-while loop to ensure no overwriting of already occupied slots.
- Deal: Iterate from card 1 to 52. Search for each card in the deck array. Once found, use the row and column to get the suit and face names from suit and face arrays and display.
Random Number Seeding: Use srand(time(0)) (from time.h) to initialize the random number generator with a different seed each time, ensuring true randomness.
Code Reuse: This problem demonstrates nested loops, arrays of pointers, variable-sized strings, and random number usage.

Lecture No. 17: String Handling, Manipulation, Character Handling, Conversion, Search Functions

String Handling

Strings are fundamental for text processing.
Historically, C language and UNIX development at Bell Labs led to text editors and processing programs for formatting articles.

String Manipulation Functions

Characters are represented as numbers (ASCII codes) internally.
char data type stores a single character (1 byte, 8 bits, 256 combinations).
int data type stores whole numbers (typically 4 bytes).
ASCII Table: Displays characters and their corresponding integer values. White spaces, digits, and symbols also have ASCII codes.
Example (Displaying ASCII Table): A loop from 0 to 255, assigning c = i; and printing both i and c.

Character Handling Functions (`ctype.h`)

Provide useful tests and manipulations for character data.
Require #include <ctype.h>.
Functions take an int (character or EOF) as an argument and return true/false (non-zero/zero) or a converted character.

Key Functions:

Prototype	Description
`int isdigit( int c )`	Returns true if `c` is a digit.
`int isalpha( int c )`	Returns true if `c` is a letter (a-z, A-Z).
`int isalnum( int c )`	Returns true if `c` is a digit or a letter.
`int isxdigit( int c )`	Returns true if `c` is a hexadecimal digit.
`int islower( int c )`	Returns true if `c` is a lowercase letter.
`int isupper( int c )`	Returns true if `c` is an uppercase letter.
`int isspace( int c )`	Returns true if `c` is a white-space character (newline, space, form feed, carriage return, horizontal tab, vertical tab).
`int iscntrl( int c )`	Returns true if `c` is a control character.
`int ispunct( int c )`	Returns true if `c` is a printing character other than space, digit, or letter.
`int isprint( int c )`	Returns true if `c` is a printing character including space.
`int isgraph( int c )`	Returns true if `c` is a printing character other than space.
`int tolower( int c )`	Converts uppercase `c` to lowercase; returns `c` unchanged otherwise.
`int toupper( int c )`	Converts lowercase `c` to uppercase; returns `c` unchanged otherwise.

Sample Program (Character Analysis)

Problem: Prompt user for a string, then count different types of characters (digit, upper/lowercase letters, white space, punctuation, others).
Solution:
- Declare counters: int lc, uc, dig, ws, pun, oth; (all initialized to 0).
- Use getchar() (from stdio.h) to read characters one by one until newline (Enter key).
- Inside a while loop, use if/else if statements with ctype.h functions (islower(), isupper(), isdigit(), isspace(), ispunct()) to categorize and increment counters.
- Display counts.

String Conversion Functions (`stdlib.h`)

Used to convert strings to different data types.
Require #include <stdlib.h>.

Key Functions:

Prototype	Description
`double atof( const char *nPtr )`	Converts string `nPtr` to `double`.
`int atoi( const char *nPtr )`	Converts string `nPtr` to `int`.
`long atol( const char *nPtr )`	Converts string `nPtr` to `long int`.
`double strtod( const char nPtr, char *endPtr )`	Converts string `nPtr` to `double`.
`long strtol( const char nPtr, char *endPtr, int base )`	Converts string `nPtr` to `long`.
`unsigned long strtoul( const char nPtr, char *endPtr, int base )`	Converts string `nPtr` to `unsigned long`.

Usage: Command-line arguments are strings; these functions convert them to numeric types for use in programs.
Example (atoi function): Prompts user for an integer (10-100) as a string, converts it to int using atoi(), and validates the range.

String Functions (`string.h`)

Provide functions for string comparison, copying, concatenation, and other manipulations.
Require #include <string.h>.

Key Functions:

Function prototype	Function description
`char strcpy( char s1, const char *s2 )`	Copies string `s2` (source) into `s1` (destination). Returns `s1`.
`char strncpy( char s1, const char *s2, size_t n )`	Copies at most `n` characters of `s2` into `s1`. Returns `s1`.
`char strcat( char s1, const char *s2 )`	Appends `s2` to the end of `s1`. The null terminator of `s1` is overwritten by the first character of `s2`. Returns `s1`.
`char strncat( char s1, const char *s2, size_t n )`	Appends at most `n` characters of `s2` to `s1`. Returns `s1`.
`int strcmp( const char s1, const char s2)`	Compares `s1` to `s2`. Returns negative if `s1 < s2`, zero if `s1 == s2`, positive if `s1 > s2`. Case-sensitive.
`int strncmp( const char s1, const char s2, size_t n )`	Compares up to `n` characters of `s1` to `s2`. Returns negative if first `n` chars of `s1 < s2`, zero if equal, positive if `s1 > s2`.
`int strlen ( const char *s)`	Determines the length of string `s` (number of characters before `"\0"`).

Search Functions (`string.h`)

Provide functions to search for characters or substrings within a string.

Key Functions:

Function prototype	Function description
`char strchr( const char s, int c );`	Locates the first occurrence of character `c` in string `s`. Returns pointer to `c` or `NULL`.
`size_t strcspn( const char s1, const char s2 );`	Length of initial segment of `s1` consisting of characters NOT in `s2`.
`size_t strspn( const char s1, const char s2 );`	Length of initial segment of `s1` consisting ONLY of characters in `s2`.
`char strpbrk( const char s1, const char *s2 );`	Locates first occurrence in `s1` of ANY character in `s2`. Returns pointer or `NULL`.
`char strrchr( const char s, int c );`	Locates the LAST occurrence of character `c` in string `s`. Returns pointer or `NULL`.
`char strstr( const char s1, const char *s2 );`	Locates the first occurrence of string `s2` in string `s1`. Returns pointer to `s2` in `s1` or `NULL`.
`char strtok( char s1, const char *s2 );`	Breaks string `s1` into "tokens" separated by characters in `s2`. Subsequent calls use `NULL` for `s1`. Returns pointer to current token or `NULL`.

Example 3 (String Manipulation)

Demonstrates strcpy(), strncpy(), strcat(), strncat(), strlen(), strcmp(), strncmp().
Shows how to copy, concatenate, and compare strings using these library functions.

Lecture No. 18: Files and File Handling (Text Files)

Files

Files are collections of characters, words, sentences, or paragraphs stored on disk.
Types of Files:
- Text Files: Contain readable characters.
  - Plain Text Files: Simple text, no formatting (e.g., .txt, source code files).
  - Formatted Text Files: Contain text with formatting information (e.g., word processor files, spreadsheets). These are not plain text files.
- Executable Program Files: Contain non-printable binary information, designed to run programs.
Utility of Files: Computer memory is volatile; data is lost on power off. Files provide permanent storage on disk, allowing data reuse and report generation.

Text File Handling

Basic Steps:
1. Open the file.
2. Read from or write to the file.
3. Close the file.
Streams in C++:
- cin (standard input stream, keyboard) and cout (standard output stream, screen) are predefined streams.
- File Streams: Require #include <fstream.h>.
  - ifstream: Input file stream (for reading from files).
  - ofstream: Output file stream (for writing to files).
  - fstream: For both reading and writing to the same file.
- Declaring File Streams: ifstream inFile; ofstream outFile; (these are objects/handles for files).
- Opening a File: myFile.open("filename", mode);
  - filename: String (e.g., "payroll.txt" or "C:\myprogs\payroll.txt").
  - mode: Specifies operation (e.g., ios::in for input, ios::out for output).
- Reading from File: Use stream extraction operator >> (e.g., myFile >> c;). Reads one word at a time (stops at space).
- Closing a File: myFile.close(); (no arguments). Releases the file handle.
Error Checking: Always check if a file opened successfully (e.g., if (!inFile) { cout << "Error opening file"; exit(1); }).

Example 1 (Reading from Text File)

Problem: Read employee name, salary, and department from "myfile.txt" and print to screen.
Solution:
- Declare char name[50], sal[10], dept[30]; and ifstream inFile;
- Open file: inFile.open("myfile.txt");
- Check for open error.
- Loop while (!inFile.eof()) (until end of file):
  - Read data: inFile >> name >> sal >> dept;
  - Print data: cout << name << "\t" << sal << " \t" << dept << endl;
- Close file: inFile.close();

Output File Handling

Options for Output Files:
- Create new file (default for ios::out, overwrites if exists).
- Append to existing file (ios::app).
- Write anywhere in file (ios::ate).
- Truncate existing file (ios::trunc, similar to default ios::out).
- Treat as binary (ios::binary).
Opening for Output: outFile.open("myfile.txt", ios::out);
Writing to File: Use stream insertion operator << (e.g., outFile << outputText;).

Example 2 (Writing to Text File)

Problem: Write "Welcome to VU" into "myfileOut.txt".
Solution:
- Declare ofstream outFile; char outputFileName[] = "myFileOut.txt"; char ouputText[] = "Welcome to VU";
- Open file: outFile.open(outputFileName, ios::out);
- Check for open error.
- Write: outFile << ouputText;
- Close: outFile.close();

Lecture No. 19: Sequential Access Files (continued), Random Access Files

Sequential Access Files (Continued)

Simple character files where data is written and read in sequence.
File Streams Recap:
- open() and close() functions.
- ifstream defaults to ios::in (reading).
- ofstream defaults to ios::out (writing, truncates existing file). Use ios::app to append.
- ios::trunc truncates file to 0 length.
- ios::ate opens file for writing at random positions, initially positioned at end.
Reading/Writing: Character by character (`get()`, `put()`) or using stream operators (`>>`, `<<`).

Random Access Files

Allow moving forward and backward within a file.
File Position: A pointer into the file indicating the current read/write location.
Functions to Determine Position:
- tellg(): Returns the current *get* (read) position (type long).
- tellp(): Returns the current *put* (write) position (type long).
Functions to Set Position:
- seekg(offset, origin): Sets the *get* (read) position.
- seekp(offset, origin): Sets the *put* (write) position.
- Arguments:
  - offset: A long integer representing bytes to move.
  - origin: Reference point (ios::beg for beginning, ios::cur for current, ios::end for end).
- Examples:
  - aFile.seekg(10L, ios::beg);: Moves 10 bytes forward from beginning.
  - aFile.seekg(20L, ios::cur);: Moves 20 bytes forward from current position.
  - aFile.seekg(-10L, ios::cur);: Moves 10 bytes backward from current position.
  - aFile.seekg(-100L, ios::end);: Moves 100 bytes backward from end.
- Important: Moving beyond file boundaries (before beginning, after end) can lead to undefined behavior.
Determining File Length: Open file, seek to end (seekg(0, ios::end)), then use tellg() to get current position (which is the file length in bytes).

Data Insertion in the Middle of a File

Challenge: Directly inserting data in the middle of a sequential file can corrupt it if the new data has a different length than the old data (overwriting subsequent data).
Traditional Solution (Merge Method):
- Open original file and a new empty file.
- Copy data from original to new file until insertion point.
- Insert new data into new file.
- Skip/jump over old data in original file.
- Copy remaining data from original to new file.
- Delete old file, rename new file.
- Drawback: Wasteful for large files (time and space).
Random Access File Solution:
- Requires fixed-length records to avoid disturbing file structure during updates.
- Store a unique key (e.g., student ID) with each record for quick location.
- To update a record (e.g., change city for student ID 43): Calculate offset ((ID - 1) * record_size), use seekg() to jump to position, then write new data.

Efficient Way of Reading and Writing Files

Character-by-character I/O (`get()`, `put()`) is inefficient due to slow disk access.
Block-based I/O: Reading/writing data in larger chunks (e.g., 64KB, 256KB) is more efficient.
Functions:
- read(buffer_address, number_of_bytes): Reads a block of binary data.
- write(buffer_address, number_of_bytes): Writes a block of binary data.
Benefits: Reduces disk access, improves performance.
Example (Copying File with `read()`/`write()`):
- Declare a large character array (e.g., char str[10000];) as a buffer.
- Use inFile.read(str, 10000); and outFile.write(str, 10000); within a loop to copy the file in chunks.
- sizeof() function can be used to determine the size of data types for portability.
Binary Files: Data is stored in internal formats, not human-readable text. Text editors cannot display them properly.

Copying a File in Reverse Order

Algorithm:
- Open input file.
- Seek to the end of the file (seekg(0, ios::end)).
- Move file pointer one byte backward (seekg(-1L, ios::end)).
- In a loop, read one byte, write it to output file, then move file pointer two bytes backward (seekg(-2L, ios::cur)) to read the next byte in reverse order.
- Continue until the beginning of the input file is reached.

Lecture No. 20: Structures and Unions

Structures

Definition: A collection of variables (data members) of different data types grouped under a single name.
Used to represent a single entity with multiple attributes (e.g., student with name, address, GPA; car with model, manufacturer, seats).
Declaration Syntax:
```
struct structure_name{ data_type member1; data_type member2; ...};
```
- struct is a keyword.
- Data members can be of any valid data type, including other structures or pointers.

Example (Student Structure):

struct student{ char name[60]; char address[100]; float GPA;};

Declaring Variables (Objects) of a Structure:student std1, std2; (similar to int x, y;).
Variables can also be declared immediately after the structure definition:
```
struct student{ ...} std1, std2;
```
Nested Structures: A structure can contain another structure as a data member (e.g., address stdAdd; inside student structure).
Pointers to Structures: student *sptr; (holds the memory address of a student object).
Limitations: Structures cannot directly use arithmetic operators (e.g., card1 + card2; is invalid).
Assignment: Structures can be assigned to each other (e.g., s2 = s1;) if they are of the same type, performing a member-wise copy.

Initializing Structures

At Declaration: student s1 = {"Ali", "CS201", 19, 2002 }; (values are assigned to data members in order).
Accessing Data Members: Use the dot operator (`.`) (e.g., s1.age = 20;, cout << s1.name;).
For string data members, use string copy functions (e.g., strcpy()) for assignment.

Functions and Structures

Structures can be passed to functions.
Call by Value (Default): A copy of the entire structure is placed on the stack. Changes to the copy do not affect the original. Can be inefficient for large structures.
Call by Reference: Pass the address of the structure to the function (using pointers or references). Changes affect the original structure.
Functions can also return structures.
Accessing Members with Pointers to Structures:
- (*sptr).name (parentheses are needed due to operator precedence: . has higher precedence than *).
- Arrow operator (`->`): A shorthand for accessing members via a pointer to a structure (e.g., sptr->name;).

Arrays of Structures

Declare an array of structures similar to primitive type arrays: student s[100];
Access elements using array index and dot operator: s[0].name;

Sizeof Operator

Used to determine the memory size occupied by a data type or a variable.
Can be used with structures to find their total memory footprint (e.g., sizeof(s1)). This sum includes the sizes of all data members.

Unions

Concept: Allows multiple data members to share the *same memory location*.
Purpose: To use a single memory location to store different data types interchangeably (e.g., as an int or a char).

Syntax:

union union_name{ data_type member1; data_type member2; ...};

Memory Allocation: A union is allocated memory equal to the size of its *largest* data member.
Example (intOrChar Union):
```
union intOrChar{ char c[4]; int x; }u1;
```
- If int is 4 bytes and char is 1 byte, intOrChar will occupy 4 bytes.
- Assigning a value to one member (e.g., u1.x = 'a';) will affect the bit pattern, which can be interpreted differently by other members (e.g., u1.c[0], u1.c[1], etc.).
Accessing Data Members: Use the dot operator (e.g., uval.ival = 10;, cout << uval.dval;).
Unions are rarely used but can be important for super-efficient programming.

Lecture No. 21: Bit Manipulation

Bit Manipulation

Bit: The smallest unit of memory (0 or 1). Eight bits form a byte.
Data is stored in computers in binary (0s and 1s).
Purpose: Manipulating individual bits within a byte or larger data types.
Benefits: Efficient memory usage, useful in operating systems (e.g., file attributes, bit fields).

Bit Manipulation Operators

Bitwise AND (`&`):
- Compares two bits; returns 1 if both are 1, otherwise 0.
- Truth Table:
  Bit1 Bit2 Bit1 & Bit2
  1 1 1
  1 0 0
  0 1 0
  0 0 0
- Example: 12 (1100) & 8 (1000) = 8 (1000).
- Used to check if a specific bit is set (1) or not (0).
- Hexadecimal Notation: In C, 0x or 0X prefix indicates hexadecimal (e.g., 0x8 for 8).
- Distinction from Logical AND (`&&`): Bitwise AND operates on individual bits; Logical AND operates on conditions (expressions) returning true/false.
Bitwise OR (`|`):
- Compares two bits; returns 1 if any bit is 1, otherwise 0.
- Truth Table:
  Bit1 Bit2 Bit1 | Bit2
  1 1 1
  1 0 1
  0 1 1
  0 0 0
- Used to set a specific bit to 1.
- Distinction from Logical OR (`||`): Bitwise OR operates on individual bits; Logical OR operates on conditions.
Bitwise Exclusive OR (`^`):
- Returns 1 if the two bits are different, otherwise 0.
- Truth Table:
  Bit1 Bit2 Bit1 ^ Bit2
  1 1 0
  1 0 1
  0 1 1
  0 0 0
- Property: (a ^ b) ^ b = a. Useful for encryption/decryption and swapping numbers without a temporary variable.
Bitwise NOT (`~`):
- Unary operator; inverts the bits of its operand (1 becomes 0, 0 becomes 1).
- Truth Table:
  Bit1 ~ Bit1
  1 0
  0 1
- Example: ~8 (1000) = 7 (0111) (assuming 4-bit representation).

Example (Bit Flags)

Operating systems use bit flags to represent file attributes (e.g., read-only, archive). A bit set to 1 means the attribute is active.
Example (Masking):
- Password Security: Exclusive OR (^) can encrypt passwords. c = a ^ b; then c ^ b = a;.
- Store password ^ secret_number in database. To verify, (stored_password ^ secret_number) == entered_password.
- RAID (Redundant Array of Inexpensive Devices): Uses XOR for data redundancy. If one disk fails, data can be recovered from the remaining disks using XOR.

Unsigned Integers

Bit manipulations are typically done with unsigned integers.
In signed numbers, the most significant bit indicates the sign (0 for positive, 1 for negative).
unsigned int i, j, k; declares integers that are treated as positive only, allowing all bits to represent magnitude.

Sample Program (Password Encryption/Decryption)

Problem: Encrypt a password using XOR with a number, then decrypt it.
Solution:
- Declare char password[10]; char *passptr;
- Prompt user for password.
- Encrypt: Loop through password characters, *passptr = (*passptr ^ 3);, then ++passptr;
- Decrypt: Reset passptr to start of password, loop again, *passptr = (*passptr ^ 3);, then ++passptr;
- Display encrypted and decrypted passwords.

Shift Operators

Shift binary numbers left or right.
Left Shift Operator (`<<`):
- Shifting bits left by 1 is equivalent to multiplying by 2.
- Zeros are inserted on the right side.
- Example: 2 (0010) << 1 = 4 (0100).
Right Shift Operator (`>>`):
- Shifting bits right by 1 is equivalent to dividing by 2.
- For unsigned numbers, zeros are inserted on the left. For signed numbers, behavior depends on system (sign bit might be propagated).
- Example: 12 (1100) >> 1 = 6 (0110).
Shift operators are more efficient than direct multiplication/division by powers of 2.

Lecture No. 22: Review of Previous Lectures

Bitwise Manipulation and Assignment Operator

Compound Assignment Operators for Bitwise Operations:
- &= (bitwise AND assignment): a = a & b; is equivalent to a &= b;
- |= (bitwise OR assignment): a = a | b; is equivalent to a |= b;
- ^= (bitwise Exclusive OR assignment): a = a ^ b; is equivalent to a ^= b;
The bitwise NOT operator (~) is unary and does not have a compound assignment operator.

Design Recipe

Analyze problem, express essence, provide examples.
Formulate statements/comments precisely.
Evaluate and revise activities with checks/tests.
Pay attention to detail.

Variables and Data Types

Variables are symbolic names for memory locations.
Data types (int, short, long, float, double, char) define memory size and interpretation.
unsigned qualifier for non-negative numbers.
ASCII table for character numeric values.
Arrays aggregate variables of the same data type.

Operators

Arithmetic: +, -, *, /, %. Compound operators: +=, -=, *=, /=, %=.
Logical: && (AND), || (OR), ! (NOT). Comparison operators: <, <=, ==, >, >=, !=.
Bitwise: &, |, ^, ~, <<, >>.
Important: Distinguish = (assignment) from == (equality) to avoid logical errors. An assignment statement itself has a value.

Programming Constructs

Sequential Execution: Statements execute one after another.
Decisions:
- if statement: Executes code block if condition is true.
- if-else statement: Executes one block if true, another if false.
- Nested if statements for complex conditions.
- switch statement: Multi-way decision for integer/char expressions.
Loops (Repetition Structures):
- while loop: Executes zero or more times (condition tested at beginning).
- do-while loop: Executes one or more times (body executes at least once before condition test).
- for loop: Combines initialization, condition, and increment/decrement. Executes zero or more times.
Control Statements:
- break: Exits current loop or switch block.
- continue: Skips remaining statements in current loop iteration, proceeds to next iteration.

Functions

Modularize code, promote reuse.
Function Calling:
- Call by Value (default for simple variables): Passes copies; original variables unchanged.
- Call by Reference (default for arrays, or using pointers/references for simple variables): Passes addresses; original variables can be modified.
Top-Down Methodology: Break problems into functions.

Arrays

Store multiple values of the same data type.
Zero-based indexing.
Multidimensional arrays for matrices.

Pointers

Variables storing memory addresses.
* (dereference) and & (address-of) operators.
Used for call by reference.
Array names are constant pointers.

File I/O

Used for permanent data storage.
fstream.h, ifstream, ofstream.
File opening modes (ios::in, ios::out, ios::app, etc.).
get(), put(), getline(), read(), write() for I/O.
seekg(), seekp(), tellg(), tellp() for random access.
Error checking for file operations.

Lecture No. 23: Preprocessor Directives, Macros

Preprocessor

A component of the C compiler that makes changes to the source code *before* compilation.
The compiler receives the modified source code.
Preprocessor directives start with #.

Include Directive (`#include`)

Tells the preprocessor to insert the content of a specified file into the current source code.
Syntax:
- #include <filename.h>: Searches for system header files in specific directories.
- #include "filename.h": Searches in the current working directory first, then system directories.
Header files typically contain function prototypes, constant definitions, and other directives.
Can be included anywhere logically in the code, but usually at the start.

Define Directive (`#define`)

Used to define macros.
Simple Macros (Symbolic Constants): Map a name to a value.
- Syntax: #define NAME VALUE (e.g., #define PI 3.1415926).
- Preprocessor replaces NAME with VALUE throughout the code before compilation.
- Benefits: Centralized constant definition, improved readability.
- Macros are not variables; their values cannot be changed at runtime.
Parameterized Macros: Map a name to an expression with arguments.
- Syntax: #define MACRO_NAME(arg1, arg2) (expression) (e.g., #define square(x) ((x) * (x))).
- Important: Enclose arguments and the entire expression in parentheses to prevent operator precedence issues (e.g., square(i + j) without parentheses would expand to i + j * i + j, which is incorrect).
- Macros are code substitutions, not functions; they don't perform type checking.

Other Preprocessor Directives

Conditional Compilation: Allows including or excluding parts of code based on conditions.
- #ifdef SYMBOL: If SYMBOL is defined, compile the block.
- #ifndef SYMBOL: If SYMBOL is NOT defined, compile the block.
- #if EXPRESSION: If EXPRESSION is true, compile the block.
- #else: Alternative block for #if, #ifdef, #ifndef.
- #elif: Else-if for conditional compilation.
- #endif: Ends a conditional compilation block.
- Debugging Utility: Define a DEBUG symbol (e.g., #define DEBUG). Wrap debug output statements with #ifdef DEBUG ... #endif. When DEBUG is defined, output appears; otherwise, it's ignored.
#undef SYMBOL: Undefines a previously defined macro or symbol. Necessary before redefining a symbol.
`extern "C" { ... }` with `#ifdef __cplusplus`: Used in header files to ensure C++ compilers treat certain code (e.g., C library functions) with C linkage, preventing name mangling.

Tips (Lecture 23)

All preprocessor directives start with #.
A symbol cannot be redefined without undefining it first.
Conditional compilation directives aid in debugging.
Do not declare variable names starting with an underscore (_) to avoid conflicts with library identifiers.
Always use parentheses when defining parameterized macros to prevent operator precedence issues.

Lecture No. 24: Dynamic Memory Allocation

Memory Allocation

Static Memory Allocation (Compile-time): Memory is reserved at the time of writing the program (e.g., int i; char s[20];). Size must be known in advance. Can lead to wasted memory if too much is reserved. Runs on the stack.
Dynamic Memory Allocation (Run-time): Memory is allocated during program execution based on actual requirements. Allows optimal memory utilization. Runs on the heap (or free store in C++).

Dynamic Memory Allocation Functions (C-style)

`void *calloc(size_t n, size_t el_size)`:
- Allocates memory for n elements, each of size el_size bytes.
- Initializes all allocated memory to zeros.
- Returns a void* pointer to the start of the allocated block.
- Example: (int *) calloc(1000, sizeof(int)); allocates space for 1000 integers and initializes them to 0.
`void *malloc(size_t size)`:
- Allocates a block of size bytes.
- Does not initialize the allocated memory (contains garbage values).
- Returns a void* pointer to the start of the allocated block.
- Example: (int *) malloc(numStuds * sizeof(int)); allocates space for numStuds integers.
`void *realloc(void *ptr, size_t size)`:
- Changes the size of a previously allocated memory block pointed to by ptr to size bytes.
- If contiguous space is available, it extends the existing block.
- Otherwise, it allocates a new block, copies contents from the old block, and frees the old block.
- Returns a void* pointer to the new (or resized) block.
- Danger: If a new block is allocated, other pointers still pointing to the old (now freed) block become dangling pointers.
`void free(void *ptr)`:
- Deallocates the memory block pointed to by ptr, returning it to the heap.
- Responsibility: Programmers must explicitly call free() for memory allocated with malloc(), calloc(), or realloc() to prevent memory leaks.
Error Handling: All C-style allocation functions return NULL if memory allocation fails. Always check for NULL after allocation.
`void*` Pointers and Casting: C-style allocation functions return void*. This generic pointer must be explicitly cast to the desired data type pointer before use (e.g., (int *)ptr).

Memory Leak

Occurs when dynamically allocated memory is no longer referenced by any pointer in the program but has not been deallocated.
This memory becomes unusable, leading to a gradual reduction in available heap space, potentially causing system crashes.
Common Cause: Allocating memory in a function and not freeing it before the function exits (the local pointer is destroyed, but the memory remains allocated).
Prevention: Always free allocated memory in the same function where it was allocated, or ensure it's freed at program exit points. Explicitly assign NULL to pointers after freeing memory.

Dangling Pointers

A pointer that points to a memory location that has been deallocated (freed).
Danger: Accessing or writing to a dangling pointer can lead to unpredictable behavior, data corruption, or system crashes, as the memory might now be used by another part of the program or the operating system.
Cause: Reallocating memory (realloc()) to a new location, or freeing memory pointed to by one pointer while another pointer still holds the old address.
Prevention: Update all pointers referencing a memory block if that block is reallocated or freed.

Lecture No. 25: C++ Features - Default Function Arguments, Inline Functions, Function Overloading

History of C/C++

C language (1970s, Bell Labs) was powerful but led to "spaghetti code" due to lack of structure.
Structured Programming: Introduced to break problems into smaller, manageable functions, promoting code reuse and readability.
- Principles: Divide and Conquer (short functions), Single Entry Single Exit, liberal commenting.
Limitations of Structured Programming: Data often remained external to functions, leading to complex management for complex problems.
Evolution to C++: Bjarne Stroustrup (early 1980s, Bell Labs) enhanced C to overcome these limitations, leading to "C with Classes" (later C++). This shifted focus from function-driven to data-driven programming (Object-Oriented Programming).

Default Function Arguments

Allows specifying default values for function parameters in the function prototype or definition.
If an argument is omitted during a function call, its default value is used.
Syntax: void f ( int i = 1, double x = 10.5 )
Calling: Can be called with 0, 1, or 2 arguments (e.g., f(); f(2); f(1, 2);).
Rule: Default arguments must be specified from right to left in the parameter list. Parameters without default values cannot follow parameters with default values.

Placement of Variable Declarations

C Language: Variables typically declared at the top of a function or code block.
C++ Enhancement: Variables can be declared anywhere in the function, ideally just before their first use. This improves code readability.
Scope: A variable declared inside a code block is local to that block and ceases to exist after the block ends.
Static Variables: Declared with static keyword (e.g., static int i;).
- Initialized only once during the program's lifetime.
- Retain their value between function calls.
- Exist in a dedicated "static memory area," distinct from stack (automatic) and heap (dynamic) memory.
- Useful for maintaining state within a function without using global variables.

Inline Functions

A C++ feature to optimize function calls.
Mechanism: The inline keyword (a directive to the compiler) suggests that the compiler replace the function call with the full function definition at each call site.
Benefits (similar to macros): Eliminates function call overhead (stack operations), potentially making programs faster.
Disadvantages: Can significantly increase program size if the function is large or called many times.
Compiler Discretion: The inline keyword is a *suggestion*; the compiler may ignore it for large or complex functions.
Advantages over Macros:
- Behave like regular functions: perform type checking on parameters.
- Avoid operator precedence issues that can occur with parameterized macros.

Function Overloading

Allows defining multiple functions with the same name but different parameter lists (different number or types of arguments).
Purpose: To perform similar tasks on different data types or with different inputs using a single, intuitive function name.
Example (cout operator <<): cout can print int, double, float, string because the << operator is overloaded for these types.
Example (Square Root): Instead of intsqrt(int i) and doublesqrt(double d), use overloaded functions like sqrt(int i) and sqrt(double d).
Differentiation: The compiler distinguishes overloaded functions based on the *type and number* of arguments passed during the call.
Return Type: The return type is *not* a distinguishing feature for overloading. Functions with the same name and parameter list but different return types will cause an ambiguous declaration error.
Name Mangling: Internally, the compiler generates unique names for overloaded functions (e.g., print_int, print_double) to differentiate them.

Lecture No. 26: Classes and Objects, Constructors

Classes and Objects

Classes: A user-defined data type that groups both data members (variables) and member functions (methods) that manipulate that data.
Objects: Instances of a class. When a variable of a class type is created, it is called an object.
Analogy: A class is a blueprint (e.g., for a car or a person); an object is a specific car or person created from that blueprint.
Object-Oriented Programming: Programs revolve around data and objects, where objects know how to manipulate themselves.

Definition of a Class

Syntax:
```
class class_name{ // definition of class};
```
- class is a keyword.
- Data members are typically primitive types (int, float, char) or other user-defined types.

Example (Date Class):

class Date{ int Day; int month; int year;};

Accessing Members: Use the dot operator (.) with an object (e.g., myDate.month = 3;).

Separation of Interface from Implementation (Encapsulation and Data Hiding)

Problem: In traditional programming, data is often globally visible, leading to accidental modification and logical errors.
Encapsulation: Bundling data and the methods that operate on the data within a single unit (the class).
Data Hiding: Restricting direct access to some of the object's components.
Keywords for Visibility:
- `private` (Default for classes): Data members and functions declared as private are only accessible from within the class itself. They form the implementation.
- `public`: Data members and functions declared as public are accessible from outside the class. They form the interface.
Analogy (Wristwatch): You can see the watch face (public interface) and use buttons to set time (public methods), but you cannot directly touch the internal gears (private implementation).
Benefits:
- Protects data from unintended external modification.
- Allows changing internal implementation without affecting external code that uses the interface.
- Promotes modularity and maintainability.
Good Practice: Explicitly write private: and public: keywords in class definitions.
Member Functions: Functions defined within a class. They can access both private and public data members of the class.
Scope Resolution Operator (`::`): Used to define a member function outside the class definition (e.g., Date::display()). It tells the compiler which class the function belongs to.

Constructors

Definition: A special member function that is automatically called when an object of the class is created (instantiated).
Purpose: To initialize the object's data members into a known, valid state.
Characteristics:
- Has the same name as the class.
- Has no return type (not even void).
- Can take arguments (parameterized constructor).
- If no constructor is explicitly defined, C++ provides a default constructor (which does no initialization).

Example (Date Class Constructor):

class Date{ public: Date(int day, int month, int year); // Constructor prototype private: int day, month, year;};Date::Date(int theDay, int theMonth, int theYear) // Constructor definition{ day = theDay; month = theMonth; year = theYear;}

Calling a Constructor: Implicitly called when an object is created (e.g., Date myDate(1, 1, 2003);).
Default Arguments with Constructors: Can be used to provide default values for parameters (e.g., Date::Date(int theDay, int theMonth, int theYear = 2002)).
Overloading Constructors: A class can have multiple constructors with different parameter lists (number or types of arguments), similar to function overloading.

Lecture No. 27: Classes and Objects (continued), Constructors, Destructors, Utility Functions

Classes and Objects (Continued)

The object-oriented paradigm shifts focus to data that knows how to manipulate itself.
Objects are perceived as real-world entities with attributes (data members) and actions (functions/methods).
Example: An aeroplane has attributes (height, width, seats, engines) and actions (takeoff, flying, landing).
Data Hiding: Private members are the "implementation" (hidden); public members are the "interface" (visible).
A constructor must be in the public section to be called from outside.

Constructors

Definition: Special functions called automatically when an object is instantiated.
Purpose: Initialize data members to a known, valid state. Prevents bugs from uninitialized data.
Types of Constructors:
- Compiler Generated Constructor: Provided automatically if no user-defined constructor exists. Takes no parameters and performs no initialization.
- Simple Constructor (Default Constructor): A user-defined constructor that takes no arguments (e.g., Date();). If provided, the compiler will use this instead of its own default. Good practice to provide one.
- Parameterized Constructors: Take arguments to initialize data members (e.g., Date(int, int, int);).
- Constructor Overloading: A class can have multiple constructors with the same name but different argument lists (number or types of parameters). This allows creating objects with various initialization options.
Characteristics:
- Same name as the class.
- No return type.
- No return statement in the body.
Example (Date Class with Constructors): Shows a default constructor (Date()) and a parameterized constructor (Date(int, int, int)).
Constructor Execution: Called when an object is created (e.g., Date myDate(1, 1, 2003);). It reserves memory and initializes data members.

Utility Functions

Private member functions that are used internally by other member functions of the class.
They manipulate the class's private data members but are not part of the public interface.
Purpose: To encapsulate internal logic and prevent direct external access, while still allowing other member functions to use them.
Example: A setDate() function that validates and sets day, month, year. It could be private if only other public methods (like a constructor) are meant to use it.

Destructors

Definition: A special member function that is automatically called when an object is destroyed (goes out of scope).
Purpose: To release any resources (e.g., dynamically allocated memory) acquired by the object during its lifetime. This prevents memory leaks.
Characteristics:
- Has the same name as the class, preceded by a tilde (`~`) (e.g., ~Date()).
- Cannot be overloaded (only one destructor per class).
- Takes no arguments.
- Has no return type and no return statement.
Execution:
- For objects created in a function, the destructor is called when the function exits.
- For global objects, called when the program ends.
Importance: Essential for classes that perform dynamic memory allocation in their constructors. The destructor must free this memory using delete or delete [].

Example (Date Class with Constructors and Destructors)

Demonstrates how constructors are called upon object creation and destructors upon object destruction.
Shows messages printed by constructors and destructors to illustrate their execution order.
Output: Shows default constructor calls, parameterized constructor calls, and then destructor calls in reverse order of construction.

Lecture No. 28: Memory Allocation in C++, `new`/`delete` Operators, Classes & Structures

Memory Allocation in C

Recap of C-style memory allocation: malloc(), calloc(), realloc(), free().
These functions return void* pointers, requiring explicit casting.
Memory allocated by these functions is uninitialized (except calloc()).
Programmers are responsible for determining size and freeing memory.

Memory Allocation in C++ (`new` and `delete` Operators)

C++ provides operators new and delete for dynamic memory allocation and deallocation, designed to work seamlessly with classes.
`new` Operator:
- Allocates memory for an object or array of objects from the free store (C++ equivalent of heap).
- Automatically determines the size of memory required (no need for sizeof).
- Returns a pointer of the correct data type (no explicit casting needed).
- Crucially, it calls the constructor for the object(s) being created, ensuring proper initialization.
- Syntax for single object: pointer_type = new ClassName; (e.g., Date *dptr = new Date;).
- Syntax for array of objects: pointer_type = new ClassName[size]; (e.g., Date *dptr = new Date[10];).
- Returns 0 (or throws an exception) if allocation fails. Always check for failure.
`delete` Operator:
- Deallocates memory previously allocated with new, returning it to the free store.
- Crucially, it calls the destructor for the object(s) before deallocating memory.
- Syntax for single object: delete pointer; (e.g., delete dptr;).
- Syntax for array of objects: delete [] pointer; (e.g., delete [] dptr;). The [] informs delete to deallocate an array and call destructors for all elements. Incorrect syntax (e.g., delete dptr; for an array) can lead to memory leaks for all but the first object.
C-style vs. C++-style: new/delete are preferred in C++ code as they integrate with constructors/destructors and type safety. C-style functions can still be used.

Example Program 1 (`new` and `delete` with Class Objects)

Demonstrates creating an array of MyDate objects using new MyDate[10].
Shows that the parameterless constructor is called 10 times.
Highlights the memory leak problem if delete [] dptr; is not called.

`new`, `delete` outside Constructors and Destructors

new and delete can be called anywhere, not just within constructors/destructors.
Example: Dynamically reallocating memory for a string data member within a Student object without destroying the whole object. This involves:
- delete old memory.
- Determine new size (e.g., using strlen()).
- new memory for new string.
- Assign new pointer to data member.
The destructor of an object (e.g., Student) is the appropriate place to call delete for memory allocated by new within that object's constructor.

`main()` Function and Classes

In C++, the main() function often becomes very small, primarily calling functions that interact with class objects.
Most of the program's logic resides within class definitions (member functions).

Class Abstraction

When designing a class, programmers expose only the interface (public methods) to users, hiding the implementation (private data and utility functions).
Users only need to know *what* a class does, not *how* it does it.

Messages and Methods

Calling a function on an object is often referred to as "sending a message" to the object.
Member functions are also called "methods."

Classes to Extend the Language

Classes allow users to define new data types (e.g., a Complex number class).
By overloading operators (e.g., +, *, /), these user-defined types can behave like primitive types, extending the language's capabilities.

Overloading `[]` Operator to Create Arrays

The default new operator allocates memory for arrays of objects, but the [] operator can be overloaded to customize array behavior.
Purpose: To implement array bounds checking.
Syntax: int& operator[](int index); (returns a reference to an integer).
Inside the overloaded [] operator, check if index is within valid range. If not, display an error and return a reference to a static dummy variable to prevent memory corruption.

Lecture No. 29: Friend Functions and Friend Classes

Friend Functions

Data Hiding: Classes encapsulate data (private members) and expose an interface (public members). Private data is normally inaccessible from outside the class.
Need for Friend Functions: Sometimes, an external function needs to access a class's private data members.
Definition: A friend function is a non-member function that is granted special permission by a class to access its private and protected members.
Declaration:
- Declared inside the class definition, preceded by the friend keyword (e.g., friend return_type friend_function_name(argument_list);).
- Can be placed anywhere in the class definition (public or private section), as friend status overrides access specifiers.
- Its definition is always outside the class.
Access: A friend function receives an object of the class (usually by reference or pointer) as an argument to access its private data members (e.g., a->topSecret += i;).
One-Way Friendship: Friendship is granted by the class, not taken by the function. A function cannot declare itself a friend of a class. This preserves encapsulation.
Non-Transitive: If A is a friend of B, and B is a friend of C, A is not automatically a friend of C. Friendship is a one-step relationship.
Usage: Used sparingly, as it compromises encapsulation. Often used for overloaded operators that cannot be member functions (e.g., scalar + ClassObject).

Sample Program 1 (Friend Function to Increment Private Data)

Problem: Increment a private integer data member (topSecret) of a class (myClass) using an external function.
Solution:
- Class myClass has a private int topSecret; and a public display() method.
- Declare friend void increment(myClass *a, int i); inside myClass.
- Define increment() outside the class: void increment(myClass *a, int i) { a->topSecret += i; }
- In main(), create myClass x;, call increment(&x, 10);, then x.display();.
- Output shows topSecret changed from 100 to 110.

Friend Classes

A class can declare another class as its friend class.
If OtherClass is a friend of ClassOne, all member functions of OtherClass have access to all private and protected members of ClassOne.
Declaration: friend class OtherClass; inside ClassOne.
Forward Declaration: If OtherClass is referenced before its full definition, a forward declaration (class OtherClass;) is needed.
One-Way Friendship: If ClassOne declares OtherClass as a friend, OtherClass can access ClassOne's private members. However, ClassOne cannot access OtherClass's private members unless OtherClass also declares ClassOne as a friend (two-way friendship).
Non-Transitive: Similar to friend functions, friend classes are not transitive.
Disadvantage: Breaks encapsulation. Changes in the implementation of one class (e.g., ClassOne's private data) may require recompilation of its friend class (OtherClass).
Usage: Used when two classes are tightly coupled and need to interact closely with each other's internal details (e.g., mathematical objects like StraightLine and Quadratic needing to find intersection points).

Sample Program 2 (Friend Function for Two Classes)

Problem: Add private data members (topSecret) of two separate classes (myClass1, myClass2) using an external function.
Solution:
- Forward declare class myClass2;
- In both myClass1 and myClass2, declare friend void addBoth(myClass1, myClass2);
- Define addBoth() outside classes: void addBoth(myClass1 a, myClass2 b) { cout << a.topSecret + b.topSecret; }
- In main(), create objects myClass1 a; myClass2 b;, then call addBoth(a, b);.

Tips (Lecture 29)

Separate interface and implementation.
Friendship is granted, not taken.
Friendship is one-way and non-transitive.
Use friend functions/classes sparingly to maintain encapsulation.

Lecture No. 30: Reference Data Type, Pointers vs. References, Dangling References

Reference Data Type

C++ introduces the reference data type, which creates an alias or synonym for an existing variable.
Declaration Syntax: data_type &reference_name = existing_variable; (e.g., int &j = i;).
The & operator is used here as a reference declarator, not the address-of operator.
Properties:
- A reference is *not* a new variable; it's just another name for an existing variable.
- Must be initialized immediately upon declaration to an existing variable.
- Cannot be reassigned to refer to another variable after initialization.
- Manipulating the reference (e.g., j++) directly affects the original variable (i).
Benefit: Provides an elegant way to implement call by reference in functions without using pointer syntax (*, & operators in function body).

Difference Between References and Pointers

Pointers:
- Can be declared without initialization (can be NULL).
- Can be reassigned to point to different memory locations.
- Allow pointer arithmetic (increment, decrement).
- Require dereferencing (*) to access the value they point to.
References:
- Must be initialized immediately to an existing variable.
- Cannot be reassigned after initialization.
- Do not allow arithmetic operations.
- Used like ordinary variables; no dereferencing operator needed in the function body.
Main Usage: References are primarily used in function parameters to implement call by reference, offering a cleaner interface than pointers.

References as Return Values

A function can return a reference to a variable.
Declaration Syntax: data_type &function_name(parameter_list); (e.g., int &myfunc();).
Usage: The returned reference can be used as an l-value (left-hand side of an assignment) to modify the original variable it refers to (e.g., num() = 200;).
Caution: Returning a reference to a local variable is extremely dangerous, as local variables are destroyed when the function exits. The returned reference would then become a dangling reference.
Safe Usage: Functions returning references should only return references to global or static variables, which have a longer lifetime.

Dangling Reference

A reference that refers to a memory location that no longer exists (e.g., a local variable that has gone out of scope).
Danger: Using a dangling reference leads to unpredictable behavior, memory corruption, or program crashes.
Compilers may catch some instances of this error, but not all.

Lecture No. 31: Operator Overloading (General, Minus Operator)

What is Operator Overloading and Why is it Required?

Operator Overloading: Allows the same operator symbol (e.g., +, -, *) to have multiple implementations, depending on the data types of its operands.
Purpose: To enable standard operators to work with user-defined data types (classes and objects) in an intuitive and readable way, similar to how they work with primitive data types.
Example (Complex Numbers): Without overloading, adding two Complex objects (c1, c2) would require a function like cadd(c1, c2). With overloading, c1 + c2 becomes possible, making the code more natural.
Cost: Requires writing an operator function and correctly implementing its semantics.

Where is it Relevant to Apply?

Mathematical Operations: For classes representing mathematical entities (e.g., Complex numbers, Date objects, String objects).
Example (Date Class): Overloading + to add days to a date (e.g., date1 + 5) makes sense. Subtracting two dates to find the difference also makes sense.
Example (String Class): Overloading + to concatenate strings (e.g., string1 + string2) is more readable than using strcat().
Non-Mathematical Operations: Can be applied to other contexts where the operator's meaning is clear and intuitive.
Guideline: Only overload operators when their meaning is clear and consistent with their original purpose to maintain readability and avoid confusion.

Operators to Overload

Types of Operators:
- Unary: Requires one operand (e.g., ~, !).
- Binary: Requires two operands (e.g., +, -, *, /).
Overloadable C++ Operators: Most operators can be overloaded, including arithmetic, relational, logical, bitwise, assignment, increment/decrement, stream I/O, array subscript [], function call (), and member access ->.
Non-Overloadable Operators:
- . (member access)
- .* (pointer to member)
- :: (scope resolution)
- ? : (ternary conditional)
- sizeof
Syntax of Overloaded Operator Function Prototype:return-type operator operator-symbol (parameter-list);
Example: Complex operator + (Complex & );

Restrictions on Operator Overloading

Class Members: Operators (), [], ->, and = must be declared as class members.
Arity: The number of operands an operator takes cannot be changed (e.g., a binary * cannot become unary).
New Operators: Cannot create new operator symbols (only existing C++ operators can be overloaded).
Built-in Types: Cannot overload operators for primitive (native) data types (e.g., cannot change how two ints are added). Overloading applies to user-defined types (classes).
Precedence: The precedence of an operator cannot be changed.
Associativity: The associativity (left-to-right or right-to-left) of an operator cannot be changed.

Examples of Operator Overloading (Complex Class)

Problem: Define a + operator for a Complex class (with real and imag parts).
Member Operator Function:
- The object on the left-hand side of the operator (e.g., c1 in c3 = c1 + c2;) implicitly calls the member function.
- The right-hand side operand (e.g., c2) is passed as an argument.
- Prototype: Complex Complex :: operator + (Complex c);
- Definition:
```
Complex Complex :: operator + (Complex c){ Complex temp; temp.real = real + c.real; temp.imag = imag + c.imag; return temp;}
```
- This function returns a new Complex object by value.
Assignment Operator (`=`): C++ automatically generates a default assignment operator for classes, which performs a member-wise copy. This works fine unless the class has pointer data members that manage dynamic memory (which would lead to shallow copies and potential issues). Custom assignment operators are needed in such cases.

Lecture No. 32: Operator Overloading (Minus, Date Class, Unary Operators)

Recap (Operator Overloading)

Only existing C++ operators can be overloaded; new symbols cannot be introduced.
Overloading should maintain the original meaning/behavior of the operator.
Unary and binary nature of operators cannot be changed.
Left-hand operand is the driving force for member operators.
Member operators vs. non-member (friend) operators.

Overloading Minus Operator (`-`)

Binary Minus (`-`): Subtracts two Complex numbers (real part from real part, imaginary from imaginary).
Member Operator Function:
- Prototype: Complex Complex::operator - (Complex c);
- Definition:
```
Complex Complex::operator - (Complex c){ Complex tmp; tmp.real = real - c.real; tmp.imag = imag - c.imag; return tmp;}
```
- Returns a new Complex object by value.
Compound Assignment Minus (`-=`): Modifies the calling object directly.
Member Operator Function:
- Prototype: Complex Complex::operator -= (Complex c);
- Definition:
```
Complex Complex::operator -= (Complex c){ real -= c.real; imag -= c.imag;}
```
- No temporary object needed. Can return a reference to *this.
Guideline: Avoid overloading operators (like - for String class) if their meaning is not intuitive or common sense.

Operators with Date Class

Problem: Overload + and - operators for a Date class to perform date arithmetic (e.g., date1 + 5 days, date1 - 10 days).
Complexity: Date arithmetic is complex due to varying days in months, leap years, and year changes.
Design: Encapsulate all date arithmetic logic within the Date class.
Member Operator `+` (Adding an integer to a Date):
- Prototype: Date Date::operator + (int numberOfDays);
- Logic: Iteratively call the pre-increment operator (++) for numberOfDays times.
- Returns a new Date object by value.
Pre-increment Operator `++` (for Date):
- Prototype: Date Date::operator ++ ();
- Logic: Increments the day. If it's the last day of the month, reset day to 1 and increment month. If it's December 31st, reset day/month to 1 and increment year (checking for leap year).
- Uses helper functions like daysOfMonth() and leapYear() (which can be private utility functions).
- Returns a reference to *this (the modified object).
Friend Operator `+` (Adding a Date to an integer: `int + Date`):
- Cannot be a member function because the left-hand operand is an int, not a Date object.
- Must be a friend function to access Date's private members.
- Prototype: friend Date operator + (int d, Date date_obj);
- Returns a new Date object by value.

Comparison Operators (`>`, `<`, `==`, etc.):

Can be overloaded for Date objects.
Return Type: Typically bool (true/false).
Logic: Compare years first, then months, then days.

Example (`>` operator):

bool Date::operator > (Date d){ if (year > d.year) return true; else if (year == d.year) { if (month > d.month) return true; else if (month == d.month) { if (day > d.day) return true; else return false; } else return false; } else return false;}

Lecture No. 33: Assignment Operator, `this` Pointer, Self-Assignment, Copy Constructor

Assignment Operator (`=`)

C++ provides a default assignment operator for classes, which performs a member-wise copy.
Problem with Default Assignment: If a class has pointer data members that manage dynamically allocated memory, the default assignment operator performs a shallow copy (copies only the pointer address, not the data it points to). This leads to two objects sharing the same memory, causing issues like:
- Double freeing of memory when destructors are called.
- Dangling pointers if one object is destroyed while the other still points to its memory.
Solution: For classes with dynamic memory, a user-defined assignment operator is necessary to perform a deep copy.
Deep Copy: Allocates new memory for the destination object and copies the *contents* of the source object's dynamically allocated memory into the new memory.

`this` Pointer

An implicit pointer available inside every non-static member function of a class.
Points to the current object (the object on which the member function was called).
Usage:
- To refer to the current object's members (e.g., this->member is equivalent to member).
- To return a reference to the current object (e.g., return *this;).

Self Assignment Check

Problem: In a user-defined assignment operator, if an object is assigned to itself (e.g., obj = obj;), the deep copy logic might deallocate the object's memory before copying from it, leading to data loss.
Solution: Implement a self-assignment check at the beginning of the assignment operator.
Syntax: if (&other != this) { // perform deep copy } (&other gets the address of the right-hand side object, this is the address of the left-hand side object).

Returning `this` Pointer From a Function

To support chained assignments (e.g., s3 = s2 = s1;), the assignment operator must return a reference to the calling object.
Syntax: return *this; (dereferences the this pointer to get the object itself, then returns a reference to it).
This allows the result of one assignment (e.g., s2 = s1) to be used as the right-hand side for the next assignment (s3 = (s2 = s1)).

Conversions

C and C++ perform implicit type conversions for primitive types (e.g., int to float).
User-Defined Conversions: Classes can define how to convert between user-defined types or between a user-defined type and a built-in type.
Conversion by Constructor: A constructor that takes a single argument can act as a conversion function (e.g., a Fraction constructor taking an int can convert an int to a Fraction).

Copy Constructor

Definition: A special constructor that creates a new object as a copy of an existing object of the same class.
Syntax: ClassName(const ClassName &other_object); (takes a constant reference to another object).
Purpose: To perform a deep copy when an object with dynamically allocated memory is copied.
When it's called:
1. When an object is explicitly initialized with another object (e.g., Matrix m2(m1);).
2. When an object is initialized using the assignment syntax in a declaration (e.g., Matrix m2 = m1;).
3. When an object is passed by value to a function.
4. When a function returns an object by value.
Problem with Default Copy Constructor: Performs a shallow copy, leading to the same issues as the default assignment operator for classes with dynamic memory.
Solution: A user-defined copy constructor is essential for classes that manage dynamic memory. It must allocate new memory for the new object and copy the contents from the source object.

Rules for Using Dynamic Memory Allocation (The Rule of Three/Five)

For any class that manages dynamic memory, you must explicitly define:
- A constructor (to allocate memory and initialize).
- An assignment operator (`=`) (to perform deep copy and handle self-assignment).
- A destructor (`~`) (to deallocate memory).
- A copy constructor (to perform deep copy when objects are initialized or passed by value).

Lecture No. 34: Arrays of Objects, Dynamic Arrays of Objects, Overloading `new`/`delete` for Arrays

Arrays of Objects

Classes are user-defined data types, so arrays can be created from them, just like with primitive data types.
Declaration: ClassName array_name[size]; (e.g., Date myDates[10];).
Constructor Calls: When an array of objects is declared, the default (parameterless) constructor of the class is called for each object in the array.
Initialization: Array elements can be initialized at declaration time using an initializer list, similar to primitive arrays (e.g., Date yourDate[3] = {Date(10, 24, 1980), Date(06, 14, 1985), Date(07, 09,1986)};).
If an initializer list is provided for only some elements, the parameterized constructor is called for those, and the default constructor is called for the remaining elements.

Dynamic Arrays of Objects

Allows allocating arrays of objects at runtime, when the size is not known at compile time.
Syntax: ClassName *pointer_to_array = new ClassName[size]; (e.g., String *text = new String[5];).
Constructor Calls: The default (parameterless) constructor is called for each object in the dynamically allocated array.
Limitation: Objects in a dynamically allocated array *cannot* be initialized using an initializer list with new[].
Deallocation: Use delete [] pointer_to_array; to deallocate memory for an array of objects. The [] is crucial; without it, only the destructor for the first object is called, leading to memory leaks for the rest.

Overloading `new` and `delete` Operators

Allows customizing memory management for a specific class.
Purpose: To provide custom allocation/deallocation logic (e.g., zero-filling memory, memory pooling, defragmentation).
Global Overloading: Overloading void* operator new(size_t size) and void operator delete(void* ptr) globally affects all new/delete calls in the program.
Class-Specific Overloading: Overloading new and delete as member operators (e.g., void* Name::operator new(size_t size)) affects only objects of that specific class. This is generally safer.
Sequence of Events:
- For new: Memory is allocated *first*, then the constructor is called.
- For delete: The destructor is called *first*, then memory is deallocated.
Return Values: Overloaded global new returns void*; overloaded member new returns a pointer of the class type. Both return 0 (or throw exception) on failure.

Overloading `[]` Operator to Create Arrays (Bounds Checking)

Problem: Accessing array elements out of bounds (e.g., array[100] for a size-10 array) is a common programming error not caught by the compiler.
Solution: Overload the array subscript operator [] as a member function.
Prototype: int& ClassName::operator[](int index); (returns a reference to an element).
Logic: Inside the overloaded operator, check if the index is within the valid range (0 to length-1).
- If valid, return a reference to the actual array element (e.g., return aray[index];).
- If invalid, print an error message and return a reference to a static dummy variable. This prevents memory corruption by redirecting out-of-bounds access to a safe location.

Lecture No. 35: Streams, Formatted I/O, Buffered I/O

Streams

Definition: An ordered sequence of bytes that acts as a "door" or "pipe" for communication between a program and the outside world (keyboard, screen, files, memory).
Types:
- Input Streams: Data flows into the program (e.g., cin, ifstream).
- Output Streams: Data flows out of the program (e.g., cout, ofstream).
C++ streams are objects with member functions and overloaded operators (<<, >>).
Conversion: Streams handle implicit conversions (e.g., character input from keyboard to binary integer for an int variable).
Error Handling: Streams have a "state" that can be checked for errors (e.g., bad input, end of file).

Source and Destination of Streams

Every stream has an associated source and destination.
`cin` (Input Stream):
- Source: Keyboard.
- Destination: Ordinary variables (e.g., int i, char c, float f) or user-defined objects.
`cout` (Output Stream):
- Source: Program data (variables, expressions, objects).
- Destination: Screen, files, printers.
Stream State:
- Indicates the status of the stream (e.g., good, bad input, end of file).
- Functions like cin.eof(), cin.fail(), cin.bad(), cin.good() check these states.
- cin.clear() resets the stream's state to "good."

Formatted Input and Output

Streams provide capabilities for formatting input and output.
Output Formatting: Arranging numbers, text, etc., in a specific layout (e.g., right-justified, fixed decimal places).
Example: Printing pi (3.1415926) as 3.14.

Methods of Streams (Input)

`cin.get()`: Reads a single character from the keyboard.
- c = cin.get();: Reads a character and returns it.
- cin.get(character_variable);: Reads a character into the variable.
`cin.read(buffer, buff_size)`: Reads a specified number of characters into a buffer.
`cin.getline(buffer, buff_size, delimiter)`: Reads a complete line of characters into a buffer until buff_size - 1 characters are read or the delimiter character is encountered (default delimiter is '\n'). Appends a null terminator.
`cin.unget()`: Puts the last character read back into the input stream.
`cin.peek()`: Returns the next character in the input stream without removing it.

Methods of Streams (Output)

`cout.put(character_variable)`: Outputs a single character.
`cout.write(buffer, number_of_bytes)`: Performs raw, unformatted output of a block of data.

Recap Streams

Streams are ordered sequences of bytes, connecting sources and destinations.
They perform conversions between internal binary representation and human-readable forms.
Stream objects have member functions and heavily overloaded operators.
Stream state flags (eof, fail, bad, good) can be checked.
iostream.h defines cin and cout. iomanip.h is for manipulators.
Predefined Stream Objects:
Object Meaning
cin Standard input
cout Standard output
cerr Standard error (unbuffered)
clog Standard error (buffered)
caux Auxiliary (DOS only)
cprn Printer (DOS only)
Stream Insertion Operator (`<<`): Overloaded to handle various data types and supports cascading (e.g., cout << i << d << f;). It returns a reference to the ostream object itself.
Stream Extraction Operator (`>>`): Overloaded to handle various data types and supports cascading (e.g., cin >> i >> d >> f;). It returns a reference to the istream object itself.
Whitespace as Delimiter: cin >> treats whitespace as a delimiter, reading one word at a time. This can be problematic when reading strings with spaces.

Buffered Input/Output

Problem: Electro-mechanical I/O devices (disk, keyboard, monitor) are much slower than electronic components (CPU, memory). Character-by-character I/O is inefficient.
Solution: Buffered I/O. Data is collected in a temporary memory area (buffer) and then transferred in larger chunks.
`cout` is buffered: Output is collected in a buffer before being sent to the screen/file.
`cerr` is unbuffered: Output is sent immediately to the screen, useful for displaying progress or critical errors.
`clog` is buffered: Used for logging detailed program information.
`flush` command: Forces data from the buffer to its destination immediately.
`endl` vs. ` ` (newline character): Both move the cursor to a new line. endl also flushes the output buffer, while does not necessarily.

Lecture No. 36: Stream Manipulations (continued), Format State Flags, Scientific Representation

Stream Manipulations

Used to control the formatting of input and output streams.
Require #include <iomanip.h>.
Stream State Flags: Internal flags within stream objects that indicate their state (e.g., eof(), fail(), bad(), good()).
cin.clear() resets error flags to a normal "good" state.

Manipulators

Objects inserted into a stream to change its behavior or format output.
Non-Parameterized Manipulators:
- `endl` (End Line): Inserts a newline character and flushes the output buffer.
- `flush` (Flush): Flushes the output buffer.
- `oct`, `dec`, `hex` (Base Conversion): Convert integer output to octal (base 8), decimal (base 10), or hexadecimal (base 16) representation.
- `ws` (Whitespace): Skips leading whitespace characters on an input stream.
Parameterized Manipulators: Take arguments to control formatting.
- `setw(int w)` (Set Width): Sets the field width for the *next* output item to w characters. Output is typically right-justified by default. Applies only to the immediate next output.
- `setfill(char c)` (Set Fill Character): Sets the character used to fill empty spaces when setw() is used (e.g., setfill('*') for cheque printing).
- `setprecision(int p)` (Set Precision): Sets the number of decimal places for floating-point numbers.
- `setbase(int b)` (Set Base): Sets the numeric conversion base to b (0, 8, 10, or 16). Equivalent to oct, dec, hex.
Cascading Manipulators: Can be chained with the << operator (e.g., cout << setfill('*') << setw(10) << amount;).

Format State Flags (Member Functions)

These flags are part of the ios class and can be controlled using member functions like setf() and unsetf().
`ios::adjustfield` (Justification):
- ios::left: Left-justifies output.
- ios::right: Right-justifies output.
- ios::internal: Places padding between sign/base and number.
- Can be combined (e.g., ios::left | ios::right for center output, though this is not standard C++ behavior for `adjustfield`).
`ios::basefield` (Numeric Base):
- ios::dec: Decimal (base 10).
- ios::oct: Octal (base 8).
- ios::hex: Hexadecimal (base 16).

Other Flags:

Format state flag	Description
`ios::skipws`	Skip whitespace on input.
`ios::showbase`	Output numeric base prefix (0 for octal, 0x for hex).
`ios::showpoint`	Always output decimal point for floating-point numbers.
`ios::uppercase`	Use uppercase for hex digits (A-F) and scientific 'E'.
`ios::showpos`	Output `+` or `-` sign for positive/negative numbers.
`ios::scientific`	Output floating-point in scientific notation (e.g., 1.23e+04).
`ios::fixed`	Output floating-point in fixed-point notation (e.g., 12345.67).

`setf(long flag, long field)`: Sets specific flags within a field (e.g., cout.setf(ios::left, ios::adjustfield);).
`width(int w)`: Member function alternative to setw().
`precision(int p)`: Member function alternative to setprecision().
`fill(char c)`: Member function alternative to setfill().

Lecture No. 37: Overloading Insertion and Extraction Operators

Overloading Insertion and Extraction Operators

Purpose: To allow standard stream operators (<< for insertion, >> for extraction) to work with user-defined class objects in a natural, cascading manner.
Behavior: The overloaded operators should maintain the original spirit of stream I/O.
Cascading Operations: For operators to be chained (e.g., cout << obj1 << obj2; or cin >> obj1 >> obj2;), they must return a reference to the stream object itself.
Non-Member Functions: Stream insertion (<<) and extraction (>>) operators are almost always implemented as non-member functions, typically friend functions of the class.
- This is because the left-hand operand (ostream or istream object) is not an object of the user-defined class, so it cannot be a member function.
- As friend functions, they can access the private data members of the class.

Overloading Stream Insertion Operator (`<<`)

Prototype: friend ostream& operator << (ostream &os, ClassName &obj);
- First parameter: A reference to an ostream object (e.g., cout). Must be passed by reference.
- Second parameter: A reference to the ClassName object to be output. Can be const if the object is not modified.
- Return type: A reference to an ostream object (ostream&) to enable cascading.
Definition Logic: Inside the function, use the os object to output the data members of obj (e.g., os << obj.day << "." << obj.month << "." << obj.year;). Then return os;.

Overloading Stream Extraction Operator (`>>`)

Prototype: friend istream& operator >> (istream &is, ClassName &obj);
- First parameter: A reference to an istream object (e.g., cin). Must be passed by reference.
- Second parameter: A reference to the ClassName object to be input. Must be passed by reference because the object's data members will be modified.
- Return type: A reference to an istream object (istream&) to enable cascading.
Definition Logic: Inside the function, use the is object to input data into the data members of obj (e.g., is >> obj.day; is >> obj.month; is >> obj.year;). Then return is;.

Example 1 (Date Class with Overloaded I/O Operators)

Demonstrates how to overload << and >> for a Date class.
The Date class has private day, month, year members.
The overloaded operators are declared as friends.
In main(), cin >> date1 >> date2; and cout << date1 << date2; work seamlessly.

Example 2 (Matrix Class without Overloaded I/O)

Shows a Matrix class with getMatrix() and displayMatrix() member functions for I/O.
Without overloaded stream operators, users must explicitly call these member functions (e.g., matrix.getMatrix(); matrix.displayMatrix();).
This is less convenient and readable than using >> and <<.

Example (Matrix Class with Overloaded I/O)

Demonstrates overloading << and >> for a Matrix class.
The operators are declared as friend functions.
The >> operator reads numRows and numCols first, then uses nested loops to read elements.
The << operator uses formatting (setw, setprecision) and graphic characters to display the matrix.

Tips (Lecture 37)

Stream insertion (<<) and extraction (>>) operators are almost always implemented as non-member (friend) functions.
operator << returns ostream&; operator >> returns istream& to support cascading.
The first parameter to operator << is an ostream& object (e.g., cout).
The first parameter to operator >> is an istream& object (e.g., cin).
These first parameters are always passed by reference.
For operator >>, the second parameter (the class object) must also be passed by reference because it is modified.
For operator <<, the second parameter (the class object) is typically passed by const reference if it's not modified.

Lecture No. 38: User Defined Manipulators, Static Keyword, Static Objects, Static Data Members

User Defined Manipulators

Programmers can create their own manipulators to customize stream behavior.
Parameterless Manipulators:
- Syntax: ostream& manipulator_name (ostream& os) { // actions; return os; }
- Takes a reference to an ostream object as an argument and returns a reference to the same ostream object.
- Example:
  - ostream& bell (ostream& output) { return output << '\a'; } (makes a system beep).
  - ostream& tab (ostream& output) { return output << '\t'; } (inserts a tab).
  - ostream& endLine (ostream& output) { return output << '\n' << flush; } (inserts newline and flushes).
- These are non-member functions, not friends, as they operate on the stream object itself.
Parameterized Manipulators: More complex, typically involve creating a class or function object.
Behavior: Inline manipulators (like setw) apply only to the *next* piece of data in the stream.

Static Keyword

Static Variables (within functions):
- Declared with static keyword (e.g., static int i = 0;).
- Initialized only once during the program's lifetime, at the first entry into the function.
- Retain their value between function calls.
- Exist in a dedicated static memory area, distinct from stack (automatic) and heap (dynamic) memory.
- Destroyed when the program terminates.
- Useful for maintaining state within a function without using global variables.
Global Variables: Declared outside any function. Exist for the entire program lifetime, accessible everywhere. Can lead to unintended side effects.

Static Objects

Objects declared with the static keyword.
Initialization: A static object's constructor is called only once, at the start of the program (or first time its scope is entered). If it has default arguments, they are used.
Lifetime: Persists for the entire duration of the program.
Destruction: Its destructor is called when the program terminates, but *after* local objects are destroyed.
Example: A global truck A('A'); object's constructor is called first. A local static truck D('D'); object's constructor is called when its function is first entered, and its destructor is called at program end.

Static Data Members of a Class

Definition: Data members declared with the static keyword inside a class.
Properties:
- Belong to the class itself, not to individual objects.
- There is only one copy of a static data member for the entire class, regardless of how many objects are created.
- Initialization: Must be initialized *outside* the class definition, typically at file scope (e.g., int ClassName::static_member = value;).
- Access: Can be accessed using the class name and scope resolution operator (e.g., savingsAccount::profit_rate) or through an object (e.g., account1.profit_rate).
- Modification: If a static data member is modified through any object or directly via the class name, the change is reflected for all objects of that class.
Use Case: For data that is common to all objects of a class (e.g., a bank's profit_rate, or a count of how_many students in a class).

Lecture No. 39: Review of Pointers, References, Dynamic Memory Allocation, Copy Constructor

Pointers

Variables that store memory addresses.
Can be typed (e.g., int*) or void (void*).
& operator gets the address of a variable.
* operator dereferences a pointer to access the value at its address.
Can point to arrays or objects.

References

Aliases or synonyms for existing variables.
Declared using & (e.g., int &j = i;).
Must be initialized immediately and cannot be reassigned.
No pointer arithmetic allowed.
Used for call by reference, providing a cleaner syntax than pointers.

Call by Value

Default mechanism for passing simple variables to functions.
A copy of the argument's value is passed; original variable remains unchanged.
Inefficient for large data structures.

Call by Reference

Allows a function to modify the original variable.
Achieved by passing the memory address (using pointers or references).
More efficient for large data structures as it avoids copying.
Using const with a reference parameter (const Type &param) allows call by reference for efficiency without allowing modification.

Dynamic Memory Allocation

Allocates memory at runtime from the heap (C) or free store (C++).
C-style: malloc(), calloc(), realloc(), free(). Return void*, require casting.
C++-style: new and delete operators. Automatically determine size, return typed pointers, and call constructors/destructors.
`new` for arrays: new Type[size].
`delete` for arrays: delete [] pointer;.
Memory Leak: Unreferenced allocated memory not freed.
Dangling Pointer: Pointer to deallocated memory.

Assignment and Initialization

Initialization: Setting a variable's value at the time of declaration (e.g., int i = 0;).
Assignment: Changing a variable's value after declaration (e.g., i = 10;).
For objects with dynamic memory, a user-defined assignment operator is needed to perform a deep copy and handle self-assignment.

Copy Constructor

Creates a new object as a deep copy of an existing object.
Called during initialization (ClassName obj2 = obj1; or ClassName obj2(obj1);) and when passing/returning objects by value.
Essential for classes with dynamic memory to prevent shallow copies and related issues.

Rules for Using Dynamic Memory Allocation (Rule of Three/Five)

If a class manages dynamic memory, it must explicitly define:
- Constructor(s)
- Destructor
- Assignment operator (`=`)
- Copy constructor

Lecture No. 40: Objects as Class Members, Nested Classes

Objects as Class Members (Composition)

A class can contain objects of other classes as its data members. This is known as composition or "has-a" relationship.
Construction Order: Contained objects (member objects) are constructed *before* the containing object.
Destruction Order: Contained objects are destroyed *after* the containing object (reverse order of construction).
Initializer List: Member objects can be initialized efficiently using an initializer list in the constructor of the containing class (e.g., PersonInfo::PersonInfo(...) : birthday(month, day, year) { ... }). This calls the parameterized constructor of the member object.
Access: Public data members of a contained object can be accessed from outside the containing class using the dot operator (e.g., matrix.row.size).
Advantages: Code reuse (using tested classes as building blocks), improved clarity and management of source code.

Structures as Class Members

Similar to objects of classes, structures can also be data members of a class.
The same principles of construction/destruction order and access apply.

Classes inside Classes (Nested Classes)

C++ allows defining a class within another class. These are called nested classes.
Visibility:
- If nested in the public section of the outer class, the nested class is visible outside the outer class (global scope).
- If nested in the private section, it's only visible to members of the outer class.
Access: The outer class has no special privileges to access the private members of the inner class, and vice versa, unless explicitly declared as friend.
Purpose: To logically group related classes together for easier manipulation and organization.

Lecture No. 41: Template Functions

Template Functions

A mechanism for code reuse that allows writing generic functions that can operate on different data types without rewriting the code for each type.
Analogy: A stencil or "cut-out" that defines a shape, which can then be used to create actual objects of various materials.
Syntax: template <class T> (or template <typename T>) precedes the function definition. T is a placeholder for a generic data type.
Example (Generic Swap Function):
```
template<class T>void swap(T &x, T &y){ T tmp; tmp = x; x = y; y = tmp;}
```
- T is used for the data type of variables and parameters.
- The arguments x and y are passed by reference (T &) to allow modification.
Compiler Behavior: At compile time, when a template function is called with specific data types (e.g., swap(int_var, int_var2)), the compiler automatically generates a specialized version of the function for those types (e.g., an int version of swap).
Benefits:
- Write code once, use for multiple data types.
- Promotes code reuse and reduces redundancy.
- Compiler performs type checking.
Limitations:
- Declaration and definition of a template function must typically be in the same file (often a header file) because the compiler needs the full definition to generate specialized versions.
- At least one argument in the function must be of a generic type.

Overloading Template Functions

Template functions can be overloaded, similar to regular functions.
Multiple template functions can have the same name as long as their parameter lists (number or types of arguments) are different.
The compiler uses the parameter list to determine which overloaded template function to use.
Example: A template inverse(T x) that returns -x and another template inverse(T &x, T &y) that swaps values.

Explicitly Specifying the Type in a Template Function

Sometimes, the compiler might not be able to deduce the types correctly, or you might want to force a specific type instantiation.
Syntax: Specify the type in angle brackets after the function name during the call (e.g., reverse<int>(amount)).
Example: If T reverse(U x) is defined, and you call reverse<double, int>(amount), it forces the return type to double and the argument type to int.

Template Functions and Objects

Template functions can work with user-defined class objects as generic types.
Requirement: Any operations performed within the template function must be supported by the class object (e.g., if a template reverse(T x) uses -x, the class T must have an overloaded unary minus operator).

Lecture No. 42: Class Templates, Nontype Parameters, Static Members, Friend Functions, Standard Template Library (STL)

Class Templates

Allows defining generic classes that can work with any data type.
Purpose: To create a blueprint for a class where the data type of its members or operations can vary (e.g., a Stack that can hold ints, floats, or doubles).
Syntax: template <class T> class ClassName { ... }; (T is a placeholder for the generic type).
Instantiation: When an object of a template class is declared with a specific data type (e.g., Number<int> x;), the compiler generates a specialized version of the class for that type.
Benefits: Promotes code reuse, type safety (compiler performs type checking at compile time), and compiler optimizations.

Class Templates and Nontype Parameters

In addition to type parameters (like T), class templates can also have nontype parameters.
Syntax: template <class T, int element> class ClassName { ... }; (element is a constant integer).
Purpose: To pass constant values (e.g., array sizes) to the template class definition.
The nontype parameter behaves like a constant within the class definition.

Templates and Static Members

When a template class has a static data member, each instantiation of the template with a different type gets its own separate copy of that static member.
Example: Number<int> x; and Number<double> y; will each have their own distinct static members. The static member is specific to the instantiated type, not class-wide across all types.

Templates and Friend Functions

Friend Function in Template Class:
- friend f();: If declared without a generic type, f() becomes a friend to *all* instantiations of the template class.
- friend f<T>();: If declared with a generic type, f() becomes a friend only to the specific instantiation of the template class (e.g., f<int>() is friend only to ClassName<int>).
Friend Class in Template Class:
- friend class Y;: If declared without a generic type, Y becomes a friend to *all* instantiations of the template class.
- friend class Y<T>;: If declared with a generic type, Y<T> becomes a friend only to the specific instantiation of the template class.
Member Function of Another Class as Friend: friend A::f(); grants friendship to a specific member function of class A.

Standard Template Library (STL)

A major code reuse feature in C++.
A library of common-use functions and data structures (e.g., containers, algorithms, iterators) that are implemented as templates.
Benefits: Provides tested, efficient, and error-free code for common programming tasks, reducing development time and bugs.
Example: Instead of manually implementing array manipulations, STL provides generic algorithms.

Lecture No. 43: Programming Exercise - Matrices (Problem Analysis, Design Recipe)

Programming Exercise - Matrices

Matrices are a good domain for developing classes and programs, allowing manipulation and operations.

Design Recipe

Problem Analysis:
- Understand the problem domain (matrices).
- Identify operations: addition (matrix+matrix, scalar+matrix), subtraction (matrix-matrix, scalar-matrix), multiplication (matrix*matrix, scalar*matrix), division (matrix/scalar), transpose.
- Note restrictions: Matrix addition/subtraction require same order. Matrix multiplication requires inner dimensions to match.
Design Issues and Class Interface:
- Matrix Class: User-defined data type.
- Size Specification: Specify rows and columns at creation time.
- Memory Allocation: Dynamically allocate memory for matrix elements.
- Constructor: Matrix(int rows, int cols) for initialization and memory allocation.
- Display Function: void display(Matrix &); to show elements.
- Operator Overloading: Overload arithmetic, assignment, stream I/O, and transpose operators for intuitive use.
- Return Types: Operators modifying the calling object (e.g., +=) return a reference to *this. Operators returning a new object (e.g., +) return by value.
- Friend Functions: For operations where the left-hand operand is not a Matrix object (e.g., scalar + Matrix).
- Error Checking: Implement checks for conformability (dimensions) and division by zero.
- Data Hiding: Private data members (numRows, numCols, elements).

Lecture No. 44: Matrix Class (Constructors, Destructors, Utility Functions, Transpose, Code Review)

Matrix Class

Review of the Matrix class implementation, focusing on constructors, destructors, and utility functions.
Templatization: The current Matrix class is implemented for double elements. It can be templatized to handle other data types (e.g., int).
Data Structure (Private Members):
- int numRows, numCols; (store dimensions).
- double **elements; (a pointer to a pointer to double, used for dynamic 2D array allocation).
Dynamic Memory Allocation: Essential for variable-sized matrices.
Need for Deep Copy: When a class uses dynamic memory, it requires a custom copy constructor and assignment operator to perform deep copies, preventing shallow copy issues (memory leaks, dangling pointers).

Definition of Matrix Constructor

Default Constructor: Matrix(int=0, int=0); (with default arguments for rows and columns).
Parameterized Constructor: Matrix::Matrix(int row, int col)
- Assigns row and col to numRows and numCols.
- Dynamically allocates memory for the 2D array:elements = new (double *) [numRows];for (int i = 0; i < numRows; i++){ elements[i] = new double [ numCols];}
- Initializes all elements to 0.0.
- Error Handling: Check for non-negative numRows and numCols.
Copy Constructor: Matrix::Matrix(const Matrix &m)
- Takes a constant reference to another Matrix object m.
- Performs a deep copy: Allocates new memory for elements and copies the contents from m.elements.

Destructor of Matrix Class

Purpose: To deallocate dynamically allocated memory.
Definition: Matrix::~Matrix(void) { delete [] elements; }
The delete [] syntax is crucial for arrays to ensure all allocated memory is freed.

Utility Functions of Matrix

`int getRows() const;` and `int getCols() const;`: Return the number of rows and columns. Declared const as they don't modify the object.
`void Matrix::output(ostream &os) const;`: Displays the matrix to an output stream (e.g., screen).
- Uses formatting flags (ios::showpoint, ios::fixed) and manipulators (setw, setprecision) for a structured display.
- Uses ASCII graphic symbols (e.g., (char)218 for corners, (char)179 for vertical bars) to draw matrix brackets.
`void Matrix::output(ofstream &os) const;`: Writes the matrix to a file. Similar to screen output but without graphic symbols. Outputs numRows and numCols first.

Input Function

`const Matrix & Matrix::input(istream &is = cin);`: Reads matrix data from an input stream (keyboard by default).
- Prompts the user for matrix size and elements.
- Uses nested loops to read values.
- Returns a reference to *this (the modified matrix).
`const Matrix & Matrix::input(ifstream &is);`: Reads matrix data from a file.
- Reads numRows and numCols from the file first.
- Dynamically creates a temporary matrix, populates it, then assigns it to *this.
- Returns a reference to *this.

Transpose Function

`const Matrix & Matrix::transpose();`: Transposes the matrix (interchanges rows and columns).
Logic:
- Square Matrix (numRows == numCols): Swaps elements elements[i][j] with elements[j][i] using a temporary variable. The inner loop starts from j = i+1 to avoid redundant swaps and swapping diagonal elements.
- Non-Square Matrix: Creates a new temporary Matrix with dimensions numCols x numRows. Copies elements[i][j] to temp.elements[j][i]. Assigns temp to *this.
Returns a reference to *this.

Lecture No. 45: Matrix Class (Assignment Operator, Addition, Plus-Equal, Multiplication, Insertion/Extraction, Review)

Assignment Operator Function (`=`)

Prototype: const Matrix & Matrix::operator = (const Matrix &m);
Return Type: Returns a const Matrix& to allow chained assignments (e.g., m3 = m2 = m1;) and prevent modification of the returned reference.
Logic:
1. Self-Assignment Check: if (&m != this). If true, do nothing and return *this.
2. Dimension Check: If numRows or numCols differ from m.numRows/m.numCols:
  - Deallocate existing memory: delete [] elements;
  - Allocate new memory with correct dimensions: elements = new (double *) [m.numRows]; (and inner arrays).
3. Update numRows and numCols.
4. Deep Copy: Copy elements from m.elements to elements using nested loops.

Addition Operator Function (`+`)

Matrix + Matrix: Matrix Matrix::operator + (Matrix &m) const;
- Checks for conformability (same dimensions).
- Creates a temporary Matrix object (using copy constructor Matrix temp(*this);).
- Adds corresponding elements of m to temp.
- Returns temp by value (a new object).
Matrix + Scalar: Matrix Matrix::operator + (double d) const;
- Creates a temporary Matrix object (Matrix temp(*this);).
- Adds d to each element of temp.
- Returns temp by value.
Scalar + Matrix (Friend Function): friend Matrix operator + (double d, Matrix &m);
- Cannot be a member function.
- Creates a temporary Matrix object (Matrix temp(m);).
- Adds d to each element of temp.
- Returns temp by value.

Plus-equal (`+=`) Operator Function

Matrix += Matrix: const Matrix & Matrix::operator += (Matrix &m);
- Checks for conformability.
- Performs *this = *this + m; (reusing the + operator).
- Returns a const Matrix& (reference to the modified calling object).

Minus Operator (`-`) Function

Similar to addition, with member and friend versions for Matrix - Matrix, Matrix - Scalar, and Scalar - Matrix.

Multiplication Operator (`*`) Function

Matrix * Matrix: Matrix Matrix::operator * (const Matrix& m);
- Checks for conformability (numCols == m.numRows).
- Creates a temporary Matrix.
- Uses triple nested loops for matrix multiplication (temp.elements[i][j] += elements[i][k] * m.elements[k][j];).
- Returns temp by value.
Matrix * Scalar: Matrix Matrix::operator * (double d) const;
- Creates a temporary Matrix.
- Multiplies each element by d.
- Returns temp by value.
Scalar * Matrix (Friend Function): friend Matrix operator * (const double d, const Matrix& m);
- Creates a temporary Matrix.
- Multiplies each element by d.
- Returns temp by value.

Division Operator (`/`) Function

Matrix / Scalar: Matrix Matrix::operator / (const double d);
- Creates a temporary Matrix.
- Divides each element by d.
- Includes a check for division by zero (returns original matrix or throws exception).
- Returns temp by value.

Insertion (`<<`) and Extraction (`>>`) Operator Function

Overloaded as friend functions for Matrix class.
`istream & operator >> (istream &is, Matrix &m)`: Reuses the m.input(is) member function. Returns is.
`ostream & operator << (ostream &os, Matrix &m)`: Reuses the m.output(os) member function. Returns os.
Similar versions for ifstream and ofstream.

Review (Lecture 45)

Rules for Programming:
- Three constructs: sequences, decisions, loops.
- Code should be short, concise, self-contained, understandable.
- Liberal, logical comments.
- Proper indentation for readability.
Variables and Pointers: Variables are labels for values; pointers store addresses.
Arrays: Data structures for multiple values of same type.
Loops and Decisions: Fundamental programming constructs (if, if-else, switch, while, do-while, for).
Classes and Objects: User-defined data types combining data and code (encapsulation, data hiding).
Garbage Collection: Java automatically frees unreferenced memory. In C/C++, programmers must manually deallocate memory (using destructors for dynamic memory) to prevent memory leaks and dangling pointers.
Truth Table: A tool for analyzing complex logical expressions.
Structured Query Language (SQL): A database-oriented language where users specify *what* to do, and optimizers determine *how* to do it efficiently. Contrasts with 3rd/4th generation languages where programmers specify *how*.
Fundamentals: Strong fundamental knowledge is crucial for adapting to new languages and tools. Practice and experimentation are key.

Introduction to Programming CS201: Comprehensive Study Material

Introduction to Programming CS201: Comprehensive Study Material