Lecture 1: Introduction to IT and Computers
- Explains what “information technology” is and how it combines computer technology with communication technology.
- Shows common real-world uses of computers (e.g., education, health, banking, government).
- Introduces how computers are classified (single vs multi-user; microcomputers, mainframes, etc.) and outlines course expectations.
|
Download PDF |
Lecture 2: Number Systems and Bases
- Introduces number systems and the idea of a “base/radix” (how many symbols a system uses).
- Covers the main systems used in computing: decimal, binary, octal, and hexadecimal.
- Explains why binary matters for computers and why we need to understand base conversions.
|
Download PDF |
Lecture 3: Conversions, Digit Positions, and Data Units
- Practices converting numbers from decimal to binary/octal/hex (and working with remainders).
- Explains digit positions (least significant digit vs most significant digit) and how place value works.
- Defines bits, bytes, and words, and connects them to storage sizes (KB, MB, GB, TB).
|
Download PDF |
Lecture 4: Binary Arithmetic and an Intro to Negative Numbers
- Teaches binary addition rules (including carrying) with worked examples.
- Teaches binary multiplication using the same “shift and add” idea as decimal multiplication.
- Introduces the problem of representing negative numbers in binary and why special methods are needed.
|
Download PDF |
Lecture 5: One’s Complement vs Two’s Complement (Negative Numbers Done Properly)
- Explains one’s complement (flip bits) and two’s complement (flip bits + add one) for negative numbers.
- Shows how addition works with these systems, including what to do with carries.
- Summarizes why you can’t guess a number’s meaning without knowing the representation method.
|
Download PDF |
Lecture 6: Getting Started with C++ (Languages, Tools, and First Program)
- Compares machine language, assembly, and high-level languages, and gives brief history of C and C++.
- Explains the basic C++ workflow (edit → preprocess → compile → link → load → execute).
- Walks through a simple C++ program using main, #include, comments, and output with cout.
|
Download PDF |
Lecture 7: Variables, Data Types, Constants, and User Input
- Defines variables as named storage in memory, and shows how to declare and assign them.
- Introduces common data types (int, float, double, char, bool) and what they store.
- Teaches reading input with cin, and explains why double is often safer than float for calculations.
|
Download PDF |
Lecture 8: C++ Operators (Doing Work with Values)
- Covers arithmetic operators like + - * / % and the increment/decrement operators ++ and --.
- Covers assignment operators like =, +=, -=, *=, /=, and %= for updating variables.
- Covers comparison and logical operators to build true/false conditions in programs.
|
Download PDF |
Lecture 9: Decision Making in C++ (if/else and switch)
- Introduces comparison conditions (e.g., <, <=, ==, !=) used to make decisions.
- Explains if, else if, and else for running different code based on a condition.
- Introduces switch for choosing between many options (with case, break, and default).
|
Download PDF |
Lecture 10: Loops in C++ (while and do-while)
- Explains why loops matter: they repeat code and reduce manual work and mistakes.
- Teaches the while loop (check condition first, then run repeatedly while true).
- Teaches the do-while loop (run once first, then repeat only if the condition stays true).
|
Download PDF |
Lecture 11: C++ Practice: Decisions, Loops, and Simple Input
- Uses if/else to solve common problems like finding the maximum of 2 or 3 numbers and checking even vs odd.
- Repeats the even/odd check using a switch statement to show an alternative decision method.
- Practices while loops and basic input parsing (like reading 1/2), plus simple ASCII/character tasks (alphabet check, next letter).
|
Download PDF |
Lecture 12: For Loops and Nested Loops
- Explains the for loop structure (initialization, condition, update all in one line).
- Shows how to print sequences (0–10, even numbers, odd numbers) using for loops.
- Introduces nested loops and uses them to print patterns (like squares of * and number patterns).
|
Download PDF |
Lecture 13: One-Dimensional Arrays
- Defines an array as a group of same-type values under one name (like int a[10]).
- Explains indexing (starts at 0) and how arrays sit in continuous memory, with examples using loops to access values.
- Highlights key warnings: you can’t assign arrays directly (a=b is illegal) and C++ does no bounds checking (going past the end can break things).
|
Download PDF |
Lecture 14: Strings as Character Arrays
- Explains that a C++ “string” here means a char array ending with '\0' (null terminator).
- Shows different ways to initialize and edit strings, and why missing '\0' causes messy output.
- Covers reading strings (why cin stops at spaces) and introduces common string functions like copy, join, length, and compare.
|
Download PDF |
Lecture 15: 2D Arrays and Functions Basics
- Introduces two-dimensional arrays as rows and columns (like a table), including how to declare and fill them using nested loops.
- Explains what functions are (a reusable block of code) and how to declare, define, and call them.
- Gives reasons to use functions: split big problems into smaller parts, easier testing/debugging, and cleaner code.
|
Download PDF |
Lecture 16: Scope and Function Overloading
- Defines scope: where a variable/name can be used (local inside a block vs global for the whole program).
- Explains name precedence: a local variable with the same name as a global one “wins” inside its block.
- Introduces function overloading: same function name, but different parameters (number and/or types).
|
Download PDF |
Lecture 17: Memory Addresses, References, and Pointers
- Explains that every variable lives at a memory address, which you can view using &.
- Introduces references (an alias to an existing variable) and the main rules (set once, can’t be null).
- Introduces pointers (store addresses), how to read/change values using * (dereference), and the idea of pass-by-value vs pass-by-reference.
|
Download PDF |
Lecture 18: Arrays with Pointers, Sorting, Type Conversion, and Dynamic Memory
- Shows how to pass arrays into functions, and connects arrays with pointer-style access (like A[i] vs *(A+i)).
- Introduces sorting, especially bubble sort, and why sorting makes tasks like searching easier.
- Covers type casting (implicit vs explicit) and dynamic memory (new/delete vs malloc/free), including an example idea for allocating a 2D array.
|
Download PDF |
