OOP C++ Practical Programs

student.cpp C++

1 Student Class

Demonstrates basic class creation with private data members and public member functions in C++.

#include <iostream>
using namespace std;

class Student {
    int roll;
    string name;
    float marks;

public:
    void input() {
        cout << "Enter Roll No, Name and Marks: ";
        cin >> roll >> name >> marks;
    }

    void display() {
        cout << "\nStudent Details:\n";
        cout << "Roll No: " << roll  << endl;
        cout << "Name:    " << name  << endl;
        cout << "Marks:   " << marks << endl;
    }
};

int main() {
    Student s;
    s.input();
    s.display();
    return 0;
}

Explanation

class Student — A user-defined data type that bundles data (roll, name, marks) and functions together.
Private members — roll, name, marks are private by default; they cannot be accessed directly from outside the class.
public: section — Functions input() and display() are accessible outside the class.
input() — Reads values from the user using cin and stores them in the object's data members.
display() — Prints all stored student information to the console.
Student s; — Creates an object s of type Student; member functions are called using the dot operator.

Output Roll No: 1 | Name: Rahul | Marks: 89.5

constructors.cpp C++

2 Constructors

Shows both a Default Constructor and a Parameterized Constructor inside a single class.

#include <iostream>
using namespace std;

class Box {
    int length;

public:
    Box() { length = 0; }          // Default Constructor
    Box(int l) { length = l; }     // Parameterized Constructor

    void show() {
        cout << "Length: " << length << endl;
    }
};

int main() {
    Box b1;       // calls Default Constructor  -> length = 0
    Box b2(10);   // calls Parameterized Constructor -> length = 10
    b1.show();
    b2.show();
    return 0;
}

Explanation

Constructor — A special function with the same name as the class; called automatically when an object is created.
Default Constructor Box() — Takes no arguments; sets length = 0. Called when you write Box b1;
Parameterized Constructor Box(int l) — Accepts a value and assigns it to length. Called as Box b2(10);
Constructor Overloading — Both constructors coexist; the compiler picks the right one based on the arguments provided.
No return type — Constructors never have a return type, not even void.

Output Length: 0 | Length: 10

friend_function.cpp C++

3 Friend Function

A non-member function that is granted access to private and protected members of a class.

#include <iostream>
using namespace std;

class Test {
    int x;   // private member

public:
    Test(int a) { x = a; }

    friend void show(Test t);   // grant access to show()
};

// show() is NOT a member, but can access private 'x'
void show(Test t) {
    cout << "Value of x: " << t.x << endl;
}

int main() {
    Test t1(5);
    show(t1);   // calling the friend function
    return 0;
}

Explanation

friend keyword — Declared inside the class to allow an external function to access private/protected data.
show(Test t) — Defined outside the class, so it is an ordinary global function, not a member.
Access to private — Without friend, t.x inside show() would cause a compile error.
Friendship is not mutual — show() can access Test's members, but not vice versa.
Use case — Useful when two independent classes or a global function needs to work with each other's private data.

Output Value of x: 5

object_argument.cpp C++

4 Passing Object as Argument

An object of a class is passed as a parameter to a member function of the same class.

#include <iostream>
using namespace std;

class Distance {
    int meter;

public:
    Distance(int m) { meter = m; }

    void add(Distance d) {
        cout << "Total Distance: " << meter + d.meter
             << " meters" << endl;
    }
};

int main() {
    Distance d1(5), d2(6);
    d1.add(d2);   // d2 is passed as an argument to d1's method
    return 0;
}

Explanation

Object as argument — Just like primitive types, objects can be passed to functions by value or by reference.
d1.add(d2) — Inside add(), meter refers to d1.meter (the calling object), and d.meter refers to d2.meter (the argument).
Pass by value — A copy of d2 is made; changes inside add() do not affect the original d2.
Same class access — A member function can access private members of any object of the same class, not only the calling object.

Output Total Distance: 11 meters

function_overloading.cpp C++

5 Function Overloading

Multiple functions share the same name but differ in the number or type of parameters — compile-time polymorphism.

#include <iostream>
using namespace std;

class Area {
public:
    // One argument -> area of a square
    void calc(int s) {
        cout << "Area of Square: " << s * s << endl;
    }

    // Two arguments -> area of a rectangle
    void calc(int l, int b) {
        cout << "Area of Rectangle: " << l * b << endl;
    }
};

int main() {
    Area a;
    a.calc(4);      // calls calc(int s)
    a.calc(3, 5);   // calls calc(int l, int b)
    return 0;
}

Explanation

Function Overloading — Defining two or more functions with the same name but different parameter lists.
Compile-time polymorphism — The compiler decides which version to call at compile time based on the arguments.
calc(4) — Single argument → square area: 4 × 4 = 16.
calc(3, 5) — Two arguments → rectangle area: 3 × 5 = 15.
Return type alone is NOT sufficient to distinguish overloaded functions; parameters must differ.

Output Area of Square: 16 | Area of Rectangle: 15

operator_overload.cpp C++

6 Binary Operator + Overloading

Redefines the + operator to add two Complex number objects.

#include <iostream>
using namespace std;

class Complex {
    int real, imag;

public:
    Complex(int r, int i) {
        real = r;
        imag = i;
    }

    // Overload the + operator
    Complex operator+(Complex c) {
        return Complex(real + c.real, imag + c.imag);
    }

    void display() {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(1, 2), c2(3, 4);
    Complex c3 = c1 + c2;   // invokes operator+()
    c3.display();
    return 0;
}

Explanation

Operator Overloading — Giving custom meaning to an operator for user-defined types.
operator+() — A member function named operator+; called when c1 + c2 is written.
Return type Complex — The operator returns a new Complex object holding the summed values.
c1 + c2 internally becomes c1.operator+(c2); real = 1+3 = 4, imag = 2+4 = 6.
Does not modify originals — c1 and c2 remain unchanged; the result is stored in c3.

Output 4 + 6i

unary_operator.cpp C++

7 Unary Operator Overloading

Overloads the unary - operator to negate a Number object's value.

#include <iostream>
using namespace std;

class Number {
    int n;

public:
    Number(int x) { n = x; }

    // Overload unary minus operator
    void operator-() {
        n = -n;
    }

    void show() {
        cout << "Value: " << n << endl;
    }
};

int main() {
    Number obj(5);
    -obj;        // invokes operator-()  ->  n becomes -5
    obj.show();
    return 0;
}

Explanation

Unary operator — Operates on a single operand (e.g., -, ++, !).
operator-() — Takes no arguments; the calling object itself is the operand.
-obj — Internally calls obj.operator-(), which flips the sign of n.
In-place modification — The value of n changes from 5 to −5 inside the same object.
Difference from binary — Binary operator+ takes one parameter (the right operand); unary takes none.

Output Value: -5

virtual_function.cpp C++

8 Virtual Function

Enables runtime polymorphism — the correct overridden function is called through a base-class pointer.

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base Class" << endl;
    }
};

class Derived : public Base {
public:
    void show() {          // overrides Base::show()
        cout << "Derived Class" << endl;
    }
};

int main() {
    Base* b;        // pointer to Base
    Derived d;
    b = &d;         // base pointer points to Derived object

    b->show();      // calls Derived::show()  (runtime polymorphism)
    return 0;
}

Explanation

virtual keyword — Tells the compiler to use the vtable (virtual dispatch table) for this function.
Runtime polymorphism — The function to call is decided at runtime based on the actual object type, not the pointer type.
Without virtual — b->show() would call Base::show() regardless of what b points to.
With virtual — Since b actually points to a Derived object, Derived::show() is called.
Base pointer rule — A base-class pointer can hold the address of a derived-class object; this is the foundation of polymorphism.

Output Derived Class

abstract_class.cpp C++

9 Pure Virtual Function & Abstract Class

Declares an interface using = 0; forces derived classes to provide their own implementation.

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void area() = 0;   // Pure Virtual Function
};

class Circle : public Shape {
public:
    void area() {              // must provide implementation
        cout << "Area of Circle = 3.14 * r * r" << endl;
    }
};

int main() {
    // Shape s;   // ERROR: cannot instantiate abstract class
    Circle c;
    c.area();
    return 0;
}

Explanation

Pure Virtual Function — Declared as virtual void area() = 0;; has no body in the base class.
Abstract Class — Any class that has at least one pure virtual function becomes abstract and cannot be instantiated directly.
Interface contract — Every derived class must override all pure virtual functions, or it too becomes abstract.
Circle : Shape — Circle provides area(), so it is a concrete class and can be instantiated.
Polymorphism via abstract class — A Shape* pointer can point to any shape, enabling generic programming.

Output Area of Circle = 3.14 * r * r

single_inheritance.cpp C++

10 Single Inheritance

A derived class inherits properties and behaviours from one base class — the simplest form of inheritance.

#include <iostream>
using namespace std;

class Person {
public:
    string name;
};

class Student : public Person {   // Student inherits Person
public:
    void get() {
        cout << "Enter Name: ";
        cin >> name;              // 'name' inherited from Person
    }

    void show() {
        cout << "Name: " << name << endl;
    }
};

int main() {
    Student s;
    s.get();
    s.show();
    return 0;
}

Explanation

Single Inheritance — One derived class inherits from exactly one base class (Student ← Person).
public inheritance — Public members of Person remain public in Student.
Inherited members — name is defined in Person, but Student can use it directly.
Code reuse — No need to re-declare name in Student; inheritance provides it automatically.
IS-A relationship — A Student IS-A Person; this real-world relationship maps naturally to inheritance.

Output Enter Name: Priyanshu → Name: Priyanshu

multilevel_inheritance.cpp C++

11 Multilevel Inheritance

A chain of classes where B inherits A, and C inherits B — forming a grandparent → parent → child hierarchy.

#include <iostream>
using namespace std;

class A {
public:
    void showA() { cout << "Class A\n"; }
};

class B : public A {          // B inherits A
public:
    void showB() { cout << "Class B\n"; }
};

class C : public B {          // C inherits B (and thus A)
public:
    void showC() { cout << "Class C\n"; }
};

int main() {
    C obj;
    obj.showA();   // inherited from A (via B)
    obj.showB();   // inherited from B
    obj.showC();   // own method
    return 0;
}

Explanation

Multilevel Inheritance — Three or more classes in a linear chain; each derived class is also a base for the next.
C inherits B inherits A — Object obj of type C can access members of A, B, and C all at once.
Transitive inheritance — C does not inherit A directly, but still gets A's members through B.
Method Resolution — The compiler walks up the chain (C → B → A) to find the called method.
Advantage — Promotes code reuse in a hierarchical, layered design.

Output Class A | Class B | Class C

exception_handling.cpp C++

12 Exception Handling

Uses try, throw, and catch to gracefully handle a divide-by-zero error.

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 0;

    try {
        if (b == 0)
            throw b;         // throw an int exception

        cout << a / b;       // this line is skipped
    }
    catch (int) {
        cout << "Error: Division by zero!" << endl;
    }

    return 0;
}

Explanation

try block — Wraps code that might cause an error; execution jumps to catch if an exception is thrown.
throw b — Throws an exception of type int; the value b is passed to the handler.
catch (int) — Catches any int-type exception; multiple catch blocks can handle different types.
Normal flow — If b != 0, throw is never reached and division happens normally.
Purpose — Prevents program crashes by handling runtime errors in a controlled manner.

Output Error: Division by zero!

function_template.cpp C++

13 Function Template

A generic function that works with any data type — write once, use with int, float, string, etc.

#include <iostream>
using namespace std;

template <class T>
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << "Maximum (int):   " << maximum(5, 9)       << endl;
    cout << "Maximum (float): " << maximum(3.7f, 2.1f) << endl;
    return 0;
}

Explanation

template <class T> — Declares a generic type placeholder T; the compiler substitutes the real type when the function is called.
maximum(5, 9) — Compiler generates an int version automatically: int maximum(int, int).
maximum(3.7f, 2.1f) — Compiler generates a float version automatically.
Code reuse — Without templates, you'd need a separate maximum for each data type.
Generic Programming — Templates are the foundation of STL containers like vector<T>.

Output Maximum (int): 9 | Maximum (float): 3.7

class_template.cpp C++

14 Class Template

A generic class whose data type is determined at instantiation time using template <class T>.

#include <iostream>
using namespace std;

template <class T>
class Test {
    T x;

public:
    Test(T a) { x = a; }

    void show() {
        cout << "Value: " << x << endl;
    }
};

int main() {
    Test<int>    t1(10);
    Test<float>  t2(3.14f);
    Test<string> t3("Hello");

    t1.show();
    t2.show();
    t3.show();
    return 0;
}

Explanation

Class Template — A blueprint for a class where the data type T is a parameter.
Test<int> t1(10) — The compiler generates an int-specialised version of Test.
Test<float> t2(3.14f) — A separate float version is generated automatically.
Type safety — Each instantiation is strictly typed; no runtime type confusion.
STL example — vector<int>, stack<string> are all class templates from the Standard Library.

Output Value: 10 | Value: 3.14 | Value: Hello

file_handling.cpp C++

15 File Handling

Writes data to a file using ofstream and reads it back using ifstream — persistent storage in C++.

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    // --- WRITE to file ---
    ofstream fout("data.txt");
    fout << "Hello, File Handling!";
    fout.close();

    // --- READ from file ---
    ifstream fin("data.txt");
    string line;

    cout << "Reading from file:\n";
    while (getline(fin, line)) {
        cout << line << endl;
    }
    fin.close();

    return 0;
}

Explanation

#include <fstream> — Provides ofstream (output file stream) and ifstream (input file stream).
ofstream fout("data.txt") — Opens (or creates) data.txt for writing; overwrites existing content.
fout << "Hello, File Handling!" — Writes the string into the file using the stream insertion operator.
fout.close() — Flushes and closes the file; always close after writing to avoid data loss.
ifstream fin("data.txt") — Opens the file for reading.
getline(fin, line) — Reads one line at a time into line; the loop continues until EOF.

Output Reading from file: Hello, File Handling!