Q1. Single Inheritance: STUDENT → RESULT

#include <iostream.h>
#include <conio.h>

class STUDENT {
protected:
    int rollno;
    char name[30];
public:
    void input_data() {
        cout << "\nEnter Roll No: ";
        cin >> rollno;
        cout << "Enter Name: ";
        cin >> name;
    }
};

class RESULT : public STUDENT {
private:
    int OOP_marks;
    int PYTHON_marks;
    int WD_marks;
public:
    void input_marks() {
        cout << "Enter OOP Marks: ";
        cin >> OOP_marks;
        cout << "Enter PYTHON Marks: ";
        cin >> PYTHON_marks;
        cout << "Enter WD Marks: ";
        cin >> WD_marks;
    }

    void display_result() {
        cout << "\nRoll No: " << rollno;
        cout << "\nName   : " << name;
        cout << "\nOOP    : " << OOP_marks;
        cout << "\nPYTHON : " << PYTHON_marks;
        cout << "\nWD     : " << WD_marks;
        cout << "\nTotal  : " << (OOP_marks + PYTHON_marks + WD_marks);
        cout << "\n---------------------------\n";
    }
};

void main() {
    clrscr();
    RESULT students[3];
    for(int i = 0; i < 3; i++) {
        cout << "\nEnter details for Student " << i+1 << ":\n";
        students[i].input_data();
        students[i].input_marks();
    }

    cout << "\n======= Student Results =======";
    for(int i = 0; i < 3; i++) {
        students[i].display_result();
    }
    getch();
}


Q2. Multiple Inheritance: CALC1 + CALC2 → MYCALC

#include <iostream.h>
#include <conio.h>

class CALC1 {
public:
    void addition(int a, int b) {
        cout << "\nAddition: " << (a + b);
    }
};

class CALC2 {
public:
    void subtraction(int a, int b) {
        cout << "\nSubtraction: " << (a - b);
    }
};

class MYCALC : public CALC1, public CALC2 {
public:
    void multiplication(int a, int b) {
        cout << "\nMultiplication: " << (a * b);
    }
};

void main() {
    clrscr();
    int x, y;
    cout << "Enter two numbers: ";
    cin >> x >> y;

    MYCALC obj;
    obj.addition(x, y);
    obj.subtraction(x, y);
    obj.multiplication(x, y);
    getch();
}


Q3. Hierarchical Inheritance: Area → Circle, Rectangle

#include <iostream.h>
#include <conio.h>

class Area {
protected:
    float tot_area;
public:
    void disp_area() {
        cout << "Total Area: " << tot_area << "\n";
    }
};

class Circle : public Area {
public:
    void findAreaFor(int r) {
        tot_area = 3.14 * r * r;
        cout << "\nCircle Area:\n";
        disp_area();
    }
};

class Rectangle : public Area {
public:
    void findAreaFor(int l, int d) {
        tot_area = l * d;
        cout << "\nRectangle Area:\n";
        disp_area();
    }
};

void main() {
    clrscr();
    Circle c;
    Rectangle r;
    int radius, length, breadth;
    cout << "Enter radius of circle: ";
    cin >> radius;
    c.findAreaFor(radius);

    cout << "\nEnter length and breadth of rectangle: ";
    cin >> length >> breadth;
    r.findAreaFor(length, breadth);
    getch();
}


Q4. Multilevel Inheritance

#include <iostream.h>
#include <conio.h>

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

class B : public A {
public:
    void showB() {
        cout << "\nClass B";
    }
};

class C : public B {
public:
    void showC() {
        cout << "\nClass C";
    }
};

void main() {
    clrscr();
    C obj;
    obj.showA();
    obj.showB();
    obj.showC();
    getch();
}





// Q-5: Override data member
#include<iostream.h>
#include<conio.h>
class Father {
protected:
    char first_name[20];
    char surname[20];
public:
    void getFatherName() {
        cout << "Enter Father's First Name: ";
        cin >> first_name;
        cout << "Enter Surname: ";
        cin >> surname;
    }
};

class Son : public Father {
private:
    char first_name[20];
public:
    void getFirstName() {
        cout << "Enter Son's First Name: ";
        cin >> first_name;
    }
    void displayFullName() {
        cout << "Full Name of Son: " << first_name << " " << surname << "\n";
    }
};

void main() {
    clrscr();
    Son s;
    s.getFatherName();
    s.getFirstName();
    s.displayFullName();
    getch();
}


// Q-6: Function overriding problem
#include<iostream.h>
#include<conio.h>
class Base {
public:
    void show() {
        cout << "Base class show()\n";
    }
};

class Derived : public Base {
public:
    void show() {
        cout << "Derived class show()\n";
    }
};

void main() {
    clrscr();
    Derived d;
    d.show(); // calls Derived's show()
    d.Base::show(); // still accessible with scope resolution
    getch();
}


// Q-7: Compile time solution using scope resolution
#include<iostream.h>
#include<conio.h>
class Base {
public:
    void display() {
        cout << "Base display()\n";
    }
};

class Derived : public Base {
public:
    void display() {
        cout << "Derived display()\n";
    }
    void showBoth() {
        display();       // Derived's display
        Base::display(); // Base's display using scope resolution
    }
};

void main() {
    clrscr();
    Derived d;
    d.showBoth();
    getch();
}


// Q-8: Run time solution using virtual function
#include<iostream.h>
#include<conio.h>
class Base {
public:
    virtual void display() {
        cout << "Base class display()\n";
    }
};

class Derived : public Base {
public:
    void display() {
        cout << "Derived class display()\n";
    }
};

void main() {
    clrscr();
    Base *ptr;
    Derived d;
    ptr = &d;
    ptr->display(); // runtime polymorphism: calls Derived's display()
    getch();
}


// Q-9: Diamond problem and solution
#include<iostream.h>
#include<conio.h>
class A {
public:
    void display() {
        cout << "Class A\n";
    }
};

class B : virtual public A {
};

class C : virtual public A {
};

class D : public B, public C {
};

void main() {
    clrscr();
    D obj;
    obj.display(); // No ambiguity due to virtual base class
    getch();
}


// Q-10: Calling sequence of default constructors
#include<iostream.h>
#include<conio.h>
class A {
public:
    A() {
        cout << "Constructor A\n";
    }
};

class B : public A {
public:
    B() {
        cout << "Constructor B\n";
    }
};

class C : public B {
public:
    C() {
        cout << "Constructor C\n";
    }
};

void main() {
    clrscr();
    C obj; // Calls A -> B -> C
    getch();
}


// Q-11: Calling parent class parameterized constructor
#include<iostream.h>
#include<conio.h>
class Parent {
public:
    Parent(int x) {
        cout << "Parent Constructor: " << x << "\n";
    }
};

class Child : public Parent {
public:
    Child(int x) : Parent(x) {
        cout << "Child Constructor\n";
    }
};

void main() {
    clrscr();
    Child c(100);
    getch();
}


// Q-12: Constructor calling sequence (non-virtual & virtual base)
#include<iostream.h>
#include<conio.h>
class A {
public:
    A() { cout << "A Constructor\n"; }
};

class B : virtual public A {
public:
    B() { cout << "B Constructor\n"; }
};

class C : public A {
public:
    C() { cout << "C Constructor\n"; }
};

class D : public B, public C {
public:
    D() { cout << "D Constructor\n"; }
};

void main() {
    clrscr();
    D d;
    getch();
}


// Q-13: Two parent class parameterized constructor call
#include<iostream.h>
#include<conio.h>
class A {
public:
    A(int x) { cout << "A: " << x << "\n"; }
};

class B {
public:
    B(int y) { cout << "B: " << y << "\n"; }
};

class C : public A, public B {
public:
    C(int x, int y) : A(x), B(y) {
        cout << "C Constructor\n";
    }
};

void main() {
    clrscr();
    C obj(5, 10);
    getch();
}


// Q-14: Initialization list in constructor
#include<iostream.h>
#include<conio.h>
class Sample {
    int a;
    int b;
public:
    Sample(int x, int y) : b(y), a(x) {
        cout << "a = " << a << "\n";
        cout << "b = " << b << "\n";
    }
};

void main() {
    clrscr();
    Sample s(2, 4);
    getch();
}