C++ Programming
Complete Course

// My First C++ Program
#include <iostream>     // Preprocessor directive (include header file)
using namespace std;     // Use standard namespace

int main() {                  // Main function - program entry point
    cout << "Hello, World!"; // Output to console
    return 0;                  // Return 0 indicates successful execution
}

Compilation Process Flow

Source Code (.cpp)
        ↓
Preprocessing (#include, #define expanded)
        ↓
Compilation (converts to assembly code)
        ↓
Assembly (converts to machine code .obj/.o)
        ↓
Linking (links with libraries, creates .exe)
        ↓
Executable File (.exe on Windows, no extension on Linux)

// Compile with g++
g++ program.cpp -o program.exe

// Run the program
./program.exe     (Windows)
./program         (Linux/Mac)

#include <iostream>
using namespace std;

int main() {
    cout << "Hello World";          // Print text
    cout << "Welcome to C++";      // On same line
    cout << endl;                      // New line
    
    // Multiple outputs
    cout << "Name: " << "Ali" << endl;
    cout << "Age: " << 20 << endl;
    
    // Using \n for new line
    cout << "Line 1\n";
    cout << "Line 2\n";
    
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int age;
    string name;
    
    cout << "Enter your name: ";
    cin >> name;                      // Input operator
    
    cout << "Enter your age: ";
    cin >> age;
    
    cout << "Name: " << name << endl;
    cout << "Age: " << age << endl;
    
    return 0;
}

// Single-line comment (use // for one line)

/*
   Multi-line comment
   Use /* ... */ for multiple lines
   Everything between /* and */ is ignored by compiler
*/

int x = 10;  // You can add comments after code too

// Comments are important for:
// 1. Code documentation
// 2. Explaining complex logic
// 3. Temporarily disabling code during testing

#include <iostream>
using namespace std;

int main() {
    int num1, num2, sum;
    
    cout << "Enter first number: ";
    cin >> num1;
    
    cout << "Enter second number: ";
    cin >> num2;
    
    sum = num1 + num2;
    
    cout << "Sum = " << sum << endl;
    
    return 0;
}

Enter first number: 15
Enter second number: 25
Sum = 40

int age = 25;        // Variable 'age' stores integer 25
string name = "Ali"; // Variable 'name' stores string "Ali"

unsigned int rollNo = 12345;      // Only positive, 0 to 4,294,967,295
signed int temperature = -10;     // Can be negative
long long bigNumber = 9876543210; // Very large number
unsigned char letter = 255;       // 0 to 255 range

#include <iostream>
using namespace std;

int main() {
    int age = 20;
    short marks = 95;
    long population = 220000000;
    unsigned int rollNo = 12345;
    
    cout << "Age: " << age << endl;
    cout << "Marks: " << marks << endl;
    cout << "Population: " << population << endl;
    cout << "Roll No: " << rollNo << endl;
    
    return 0;
}

float pi = 3.14159f;            // Note the 'f' suffix for float
double price = 1599.99;         // More precise
long double precise = 3.141592653589793238;

cout << "Pi (float): " << pi << endl;           // 3.14159
cout << "Price (double): " << price << endl;   // 1599.99

char grade = 'A';
char symbol = '$';
char digit = '5';        // Character '5', not integer 5

cout << grade << endl;   // Output: A

// Characters are stored as ASCII values (integers)
cout << (int)grade << endl;  // Output: 65 (ASCII of 'A')

bool isStudent = true;
bool hasPassed = false;
bool isAdult = (age >= 18);  // Result of comparison

cout << isStudent << endl;      // Output: 1 (true = 1, false = 0)
cout << hasPassed << endl;      // Output: 0

// Use boolalpha to print true/false instead of 1/0
cout << boolalpha << isStudent << endl;  // Output: true

#include <iostream>
#include <string>      // Must include string header
using namespace std;

int main() {
    string name = "Ali Ahmed";
    string city = "Lahore";
    
    cout << "Name: " << name << endl;
    cout << "City: " << city << endl;
    
    // String concatenation
    string fullInfo = name + " from " + city;
    cout << fullInfo << endl;  // Ali Ahmed from Lahore
    
    return 0;
}

int x = 10;
double y = x;      // int automatically converted to double (10.0)

float a = 3.14f;
int b = a;         // float to int (data loss: b = 3)

// C-style cast
double pi = 3.14159;
int intPi = (int)pi;           // intPi = 3

// C++ style cast (preferred)
int intPi2 = static_cast<int>(pi);  // More readable, safer

// Character to integer
char ch = 'A';
int ascii = (int)ch;            // ascii = 65

// Using const keyword
const int MAX_AGE = 100;
const double PI = 3.14159;

// Using #define (preprocessor directive - old style)
#define MAX_SIZE 1000
#define TAX_RATE 0.16

// Trying to change const gives error
// MAX_AGE = 50;  // ERROR: Cannot modify const

#include <iostream>
using namespace std;

int main() {
    cout << "Size of int: " << sizeof(int) << " bytes" << endl;
    cout << "Size of double: " << sizeof(double) << " bytes" << endl;
    cout << "Size of char: " << sizeof(char) << " bytes" << endl;
    cout << "Size of bool: " << sizeof(bool) << " bytes" << endl;
    
    int arr[10];
    cout << "Size of array: " << sizeof(arr) << " bytes" << endl; // 40 bytes (10×4)
    
    return 0;
}

int age = 20;

if (age >= 18) {
    cout << "You are an adult" << endl;
}
// If condition false, this block is skipped

int marks = 55;

if (marks >= 50) {
    cout << "Pass" << endl;
} else {
    cout << "Fail" << endl;
}

int marks = 75;

if (marks >= 80) {
    cout << "Grade: A" << endl;
} else if (marks >= 70) {
    cout << "Grade: B" << endl;
} else if (marks >= 60) {
    cout << "Grade: C" << endl;
} else if (marks >= 50) {
    cout << "Grade: D" << endl;
} else {
    cout << "Grade: F (Fail)" << endl;
}

int age = 25;
bool hasLicense = true;

if (age >= 18) {
    if (hasLicense) {
        cout << "You can drive" << endl;
    } else {
        cout << "Get a license first" << endl;
    }
} else {
    cout << "You are too young to drive" << endl;
}

int age = 25;
bool isStudent = true;

// AND: Both conditions must be true
if (age >= 18 && isStudent) {
    cout << "Adult student discount available" << endl;
}

// OR: At least one condition must be true
if (age < 18 || age > 60) {
    cout << "Special discount" << endl;
}

// NOT: Inverts the condition
if (!isStudent) {
    cout << "Regular price" << endl;
}

int day = 3;

switch (day) {
    case 1:
        cout << "Monday" << endl;
        break;
    case 2:
        cout << "Tuesday" << endl;
        break;
    case 3:
        cout << "Wednesday" << endl;
        break;
    case 4:
        cout << "Thursday" << endl;
        break;
    case 5:
        cout << "Friday" << endl;
        break;
    case 6:
        cout << "Saturday" << endl;
        break;
    case 7:
        cout << "Sunday" << endl;
        break;
    default:
        cout << "Invalid day" << endl;
}

// Print numbers 1 to 10
for (int i = 1; i <= 10; i++) {
    cout << i << " ";
}
cout << endl;
// Output: 1 2 3 4 5 6 7 8 9 10

// Syntax: for (initialization; condition; increment/decrement)

// Print even numbers from 2 to 20
for (int i = 2; i <= 20; i += 2) {
    cout << i << " ";
}

// Print numbers in reverse
for (int i = 10; i >= 1; i--) {
    cout << i << " ";
}

int i = 1;

while (i <= 5) {
    cout << i << " ";
    i++;
}
// Output: 1 2 3 4 5

int i = 1;

do {
    cout << i << " ";
    i++;
} while (i <= 5);
// Output: 1 2 3 4 5

// Executes at least once even if condition false
int x = 10;
do {
    cout << "This prints once" << endl;
} while (x < 5);  // Condition false, but body executed once

// Print multiplication table (1 to 5)
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 10; j++) {
        cout << i << " x " << j << " = " << (i*j) << endl;
    }
    cout << endl;
}

// Print pattern
/*
*
**
***
****
*****
*/
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        cout << "*";
    }
    cout << endl;
}

// Find first number divisible by 7 and 3
for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0 && i % 3 == 0) {
        cout << "Found: " << i << endl;
        break;  // Exit loop
    }
}
// Output: Found: 21

// Print odd numbers from 1 to 10
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // Skip even numbers
    }
    cout << i << " ";
}
// Output: 1 3 5 7 9

// Function Definition
returnType functionName(parameters) {
    // Function body (code to execute)
    return value;  // Optional (not needed for void)
}

// Example:
int add(int a, int b) {
    int sum = a + b;
    return sum;
}

void greet() {
    cout << "Hello, World!" << endl;
}

int main() {
    greet();  // Function call
    return 0;
}

int getRandomNumber() {
    return 42;
}

int main() {
    int num = getRandomNumber();
    cout << "Number: " << num << endl;
    return 0;
}

void printSum(int a, int b) {
    cout << "Sum: " << (a + b) << endl;
}

int main() {
    printSum(5, 10);  // Output: Sum: 15
    return 0;
}

int multiply(int a, int b) {
    return a * b;
}

int main() {
    int result = multiply(4, 5);
    cout << "Result: " << result << endl;  // Output: 20
    return 0;
}

#include <iostream>
using namespace std;

// Function Declaration (Prototype) - placed before main
int add(int, int);  // Parameter names optional in declaration

int main() {
    int result = add(5, 3);
    cout << "Sum: " << result << endl;
    return 0;
}

// Function Definition - can be placed after main
int add(int a, int b) {
    return a + b;
}

void increment(int x) {
    x = x + 1;
    cout << "Inside function: " << x << endl;  // 11
}

int main() {
    int num = 10;
    increment(num);
    cout << "Outside function: " << num << endl;  // Still 10 (unchanged)
    return 0;
}

void increment(int &x) {  // & means reference
    x = x + 1;
    cout << "Inside function: " << x << endl;  // 11
}

int main() {
    int num = 10;
    increment(num);
    cout << "Outside function: " << num << endl;  // 11 (changed!)
    return 0;
}

void increment(int *x) {  // * means pointer
    *x = *x + 1;
    cout << "Inside function: " << *x << endl;  // 11
}

int main() {
    int num = 10;
    increment(&num);  // Pass address
    cout << "Outside function: " << num << endl;  // 11 (changed!)
    return 0;
}

int power(int base, int exp = 2) {  // exp defaults to 2
    int result = 1;
    for(int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

int main() {
    cout << power(5) << endl;      // 25 (5^2, uses default)
    cout << power(5, 3) << endl;   // 125 (5^3, overrides default)
    return 0;
}

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

int add(int a, int b, int c) {
    return a + b + c;
}

int main() {
    cout << add(5, 3) << endl;           // Calls first (int version): 8
    cout << add(5.5, 3.2) << endl;       // Calls second (double version): 8.7
    cout << add(1, 2, 3) << endl;        // Calls third (3 params): 6
    return 0;
}

inline int square(int x) {
    return x * x;
}

int main() {
    cout << square(5) << endl;  // Compiler replaces with: cout << 5 * 5;
    return 0;
}

// Factorial using recursion
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;  // Base case
    }
    return n * factorial(n - 1);  // Recursive call
}

int main() {
    cout << factorial(5) << endl;  // 120 (5! = 5×4×3×2×1)
    return 0;
}

int fibonacci(int n) {
    if (n == 0) return 0;     // Base case 1
    if (n == 1) return 1;     // Base case 2
    return fibonacci(n-1) + fibonacci(n-2);  // Recursive
}

int main() {
    for(int i = 0; i < 10; i++) {
        cout << fibonacci(i) << " ";
    }
    // Output: 0 1 1 2 3 5 8 13 21 34
    return 0;
}

// Class Definition
class Car {
    public:          // Access specifier
        // Data members (attributes/properties)
        string brand;
        string model;
        int year;
        
        // Member functions (methods/behaviors)
        void displayInfo() {
            cout << "Brand: " << brand << endl;
            cout << "Model: " << model << endl;
            cout << "Year: " << year << endl;
        }
};

int main() {
    // Creating objects (instances of class)
    Car car1;  // Object 1
    Car car2;  // Object 2
    
    // Accessing members using dot operator
    car1.brand = "Toyota";
    car1.model = "Corolla";
    car1.year = 2023;
    
    car2.brand = "Honda";
    car2.model = "Civic";
    car2.year = 2022;
    
    car1.displayInfo();
    car2.displayInfo();
    
    return 0;
}

class Student {
    private:     // Accessible only within class
        int rollNo;
        string name;
    
    public:      // Accessible from anywhere
        // Setter methods (to set private data)
        void setData(int r, string n) {
            rollNo = r;
            name = n;
        }
        
        // Getter methods (to get private data)
        void displayData() {
            cout << "Roll No: " << rollNo << endl;
            cout << "Name: " << name << endl;
        }
};

int main() {
    Student s1;
    // s1.rollNo = 101;  // ERROR: rollNo is private
    
    s1.setData(101, "Ali");  // Use public method to set private data
    s1.displayData();
    
    return 0;
}

class BankAccount {
    private:
        double balance;  // Hidden from outside
    
    public:
        // Constructor
        BankAccount(double initialBalance) {
            balance = initialBalance;
        }
        
        // Controlled access through methods
        void deposit(double amount) {
            if(amount > 0) {
                balance += amount;
                cout << "Deposited: " << amount << endl;
            }
        }
        
        void withdraw(double amount) {
            if(amount > 0 && amount <= balance) {
                balance -= amount;
                cout << "Withdrawn: " << amount << endl;
            } else {
                cout << "Insufficient balance!" << endl;
            }
        }
        
        void checkBalance() {
            cout << "Balance: " << balance << endl;
        }
};

int main() {
    BankAccount acc(1000);  // Initial balance 1000
    acc.deposit(500);
    acc.withdraw(200);
    acc.checkBalance();  // 1300
    
    // Can't directly access balance: acc.balance = 0; (ERROR)
    return 0;
}

class Box {
    public:
        int length;
        
        // Default Constructor
        Box() {
            length = 0;
            cout << "Default Constructor called" << endl;
        }
};

int main() {
    Box b1;  // Constructor called automatically
    cout << "Length: " << b1.length << endl;  // 0
    return 0;
}

class Rectangle {
    private:
        int length, width;
    
    public:
        // Parameterized Constructor
        Rectangle(int l, int w) {
            length = l;
            width = w;
        }
        
        int area() {
            return length * width;
        }
};

int main() {
    Rectangle r1(10, 5);  // Pass values to constructor
    cout << "Area: " << r1.area() << endl;  // 50
    return 0;
}

class Point {
    public:
        int x, y;
        
        // Parameterized Constructor
        Point(int a, int b) {
            x = a;
            y = b;
        }
        
        // Copy Constructor
        Point(const Point &p) {
            x = p.x;
            y = p.y;
            cout << "Copy Constructor called" << endl;
        }
};

int main() {
    Point p1(10, 20);
    Point p2 = p1;  // Copy constructor called
    
    cout << "p2: (" << p2.x << ", " << p2.y << ")" << endl;  // (10, 20)
    return 0;
}

class Demo {
    public:
        // Constructor
        Demo() {
            cout << "Constructor called" << endl;
        }
        
        // Destructor (~ before class name)
        ~Demo() {
            cout << "Destructor called" << endl;
        }
};

int main() {
    Demo d1;  // Constructor called
    cout << "Inside main" << endl;
    return 0;  // Destructor called when d1 goes out of scope
}
/* Output:
Constructor called
Inside main
Destructor called
*/

// Base Class (Parent)
class Animal {
    public:
        void eat() { cout << "Eating..." << endl; }
};

// Derived Class (Child) - inherits from Animal
class Dog : public Animal {
    public:
        void bark() { cout << "Barking..." << endl; }
};

int main() {
    Dog d;
    d.eat();   // Inherited from Animal
    d.bark();  // Own method
}

// Virtual Function Example
class Shape {
    public:
        virtual void draw() {  // Virtual function
            cout << "Drawing Shape" << endl;
        }
};

class Circle : public Shape {
    public:
        void draw() override {  // Override
            cout << "Drawing Circle" << endl;
        }
};

int main() {
    Shape* s = new Circle();  // Base pointer, derived object
    s->draw();  // Calls Circle's draw (Runtime polymorphism)
    delete s;
}

int x = 10;
int* ptr = &x;  // Pointer stores address of x
cout << *ptr << endl;  // Dereferencing: prints value (10)

// Dynamic Memory
int* p = new int(25);  // Allocate memory on heap
cout << *p << endl;  // 25
delete p;  // Free memory

int arr[5] = {10, 20, 30, 40, 50};
for(int i=0; i<5; i++) cout << arr[i] << " ";

// 2D Array
int matrix[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};

string s = "Hello";
cout << s.length() << endl;  // 5
s += " World";  // Concatenation
cout << s.substr(0, 5) << endl;  // "Hello"

#include <fstream>

// Writing to file
ofstream outfile("data.txt");
outfile << "Hello File!" << endl;
outfile.close();

// Reading from file
ifstream infile("data.txt");
string line;
while(getline(infile, line)) {
    cout << line << endl;
}
infile.close();

try {
    int x = 10, y = 0;
    if(y == 0) throw "Division by zero!";
    cout << x/y;
}
catch(const char* msg) {
    cout << "Error: " << msg << endl;
}

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    cout << add(5, 3) << endl;        // int version
    cout << add(5.5, 3.2) << endl;    // double version
}

template <typename T>
class Pair {
    T first, second;
public:
    Pair(T a, T b) : first(a), second(b) {}
    T getMax() { return (first > second) ? first : second; }
};

#include <vector>
#include <map>

// Vector (Dynamic Array)
vector<int> v = {10, 20, 30};
v.push_back(40);  // Add element

// Map (Key-Value pairs)
map<string, int> ages;
ages["Ali"] = 20;
ages["Sara"] = 22;

#include <stack>
stack<int> s;
s.push(10);
s.push(20);
cout << s.top() << endl;  // 20
s.pop();

// Modern C++ Examples
auto x = 10;  // auto deduces type as int

vector<int> v = {1, 2, 3, 4, 5};
for(auto num : v) {  // Range-based for
    cout << num << " ";
}

// Lambda function
auto add = [](int a, int b) { return a + b; };
cout << add(5, 3) << endl;  // 8