Practice Questions — Abstract Classes, Pure Virtual Functions, and Interfaces

class Animal {
public:
    virtual void sound() = 0;
    virtual ~Animal() {}
};

int main() {
    Animal a;
    return 0;
}

#include <iostream>
using namespace std;
class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() {}
};
class Square : public Shape {
    double side;
public:
    Square(double s) : side(s) {}
    double area() const override { return side * side; }
};
int main() {
    Shape* s = new Square(5);
    cout << s->area() << endl;
    delete s;
    return 0;
}

class Printable {
public:
    virtual void print() const = 0;
    virtual ~Printable() {}
};
class Report : public Printable {
    // print() not implemented
};
int main() {
    Report r;
    return 0;
}

#include <iostream>
using namespace std;
class Vehicle {
public:
    virtual void start() = 0;
    void honk() { cout << "Beep!" << endl; }
    virtual ~Vehicle() {}
};
class Car : public Vehicle {
public:
    void start() override { cout << "Car started" << endl; }
};
int main() {
    Car c;
    c.start();
    c.honk();
    return 0;
}

#include <iostream>
using namespace std;
class IGreeter {
public:
    virtual void greet(const string& name) const = 0;
    virtual ~IGreeter() {}
};
class FormalGreeter : public IGreeter {
public:
    void greet(const string& name) const override {
        cout << "Good morning, " << name << endl;
    }
};
class CasualGreeter : public IGreeter {
public:
    void greet(const string& name) const override {
        cout << "Hey, " << name << "!" << endl;
    }
};
int main() {
    IGreeter* g1 = new FormalGreeter();
    IGreeter* g2 = new CasualGreeter();
    g1->greet("Arjun");
    g2->greet("Kavya");
    delete g1; delete g2;
    return 0;
}

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show() = 0;
    virtual ~Base() {}
};
void Base::show() {
    cout << "Base default" << endl;
}
class Derived : public Base {
public:
    void show() override {
        Base::show();
        cout << "Derived extra" << endl;
    }
};
int main() {
    Derived d;
    d.show();
    return 0;
}

#include <iostream>
using namespace std;
class AbstractBase {
public:
    virtual ~AbstractBase() = 0;
    void work() { cout << "Working" << endl; }
};
AbstractBase::~AbstractBase() { cout << "~AbstractBase" << endl; }

class Concrete : public AbstractBase {
public:
    ~Concrete() override { cout << "~Concrete" << endl; }
};
int main() {
    AbstractBase* p = new Concrete();
    p->work();
    delete p;
    return 0;
}

#include <iostream>
using namespace std;
class IPrint {
public:
    virtual void print() const = 0;
    virtual ~IPrint() {}
};
class ISave {
public:
    virtual void save() const = 0;
    virtual ~ISave() {}
};
class Doc : public IPrint, public ISave {
    string content;
public:
    Doc(string c) : content(c) {}
    void print() const override { cout << "Print: " << content << endl; }
    void save() const override { cout << "Save: " << content << endl; }
};
int main() {
    Doc d("Hello World");
    IPrint* p = &d;
    ISave* s = &d;
    p->print();
    s->save();
    return 0;
}

#include <iostream>
using namespace std;
class Animal {
public:
    virtual void sound() const = 0;
    virtual void move() const = 0;
    virtual ~Animal() {}
};
class Pet : public Animal {
public:
    void move() const override { cout << "Walks at home" << endl; }
};
class Dog : public Pet {
public:
    void sound() const override { cout << "Bark" << endl; }
};
int main() {
    Dog d;
    d.sound();
    d.move();
    return 0;
}

#include <iostream>
using namespace std;
class A {
public:
    virtual void f() = 0;
    virtual ~A() {}
};
void A::f() { cout << "A::f" << endl; }

class B : public A {
public:
    void f() override { cout << "B::f" << endl; }
};
class C : public A {
public:
    void f() override {
        A::f();
        cout << "C::f" << endl;
    }
};
int main() {
    A* arr[] = { new B(), new C() };
    for (int i = 0; i < 2; i++) {
        arr[i]->f();
        cout << "---" << endl;
        delete arr[i];
    }
    return 0;
}

#include <iostream>
using namespace std;
class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() {}
};
class Circle : public Shape {
    double r;
public:
    Circle(double r) : r(r) {}
    double area() const override { return 3.14 * r * r; }
};
void printArea(Shape s) {
    cout << s.area() << endl;
}
int main() {
    Circle c(5);
    printArea(c);
    return 0;
}

#include <iostream>
using namespace std;
class IEngine {
public:
    virtual void start() = 0;
    virtual ~IEngine() {}
};
class IElectric {
public:
    virtual int battery() const = 0;
    virtual ~IElectric() {}
};
class HybridCar : public IEngine, public IElectric {
public:
    void start() override { cout << "Hybrid started" << endl; }
    int battery() const override { return 85; }
};
int main() {
    HybridCar h;
    IEngine* e = &h;
    IElectric* el = &h;
    e->start();
    cout << "Battery: " << el->battery() << "%" << endl;
    return 0;
}

#include <iostream>
using namespace std;
class Base {
public:
    virtual void f() { cout << "Base::f" << endl; }
    virtual void g() = 0;
    virtual ~Base() {}
};
class Mid : public Base {
public:
    void g() override { cout << "Mid::g" << endl; }
};
class Leaf : public Mid {
public:
    void f() override { cout << "Leaf::f" << endl; }
};
int main() {
    Base* b = new Leaf();
    b->f();
    b->g();
    delete b;
    return 0;
}

#include <iostream>
using namespace std;
class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() { cout << "~Shape" << endl; }
};
class Circle : public Shape {
public:
    void draw() const override { cout << "Circle" << endl; }
    ~Circle() { cout << "~Circle" << endl; }
};
class ColoredCircle : public Circle {
    string color;
public:
    ColoredCircle(string c) : color(c) {}
    void draw() const override { cout << color << " Circle" << endl; }
    ~ColoredCircle() { cout << "~ColoredCircle" << endl; }
};
int main() {
    Shape* s = new ColoredCircle("Red");
    s->draw();
    delete s;
    return 0;
}

#include <iostream>
using namespace std;
class Calculator {
public:
    virtual int compute(int a, int b) const = 0;
    virtual ~Calculator() {}
};
class Adder : public Calculator {
public:
    int compute(int a, int b) const override { return a + b; }
};
class Multiplier : public Calculator {
public:
    int compute(int a, int b) const override { return a * b; }
};
int main() {
    Calculator* c1 = new Adder();
    Calculator* c2 = new Multiplier();
    cout << c1->compute(3, 4) << endl;
    cout << c2->compute(3, 4) << endl;
    delete c1; delete c2;
    return 0;
}

#include <iostream>
using namespace std;
class A {
public:
    virtual void f() = 0;
    void g() { cout << "A::g calls f: "; f(); }
    virtual ~A() {}
};
class B : public A {
public:
    void f() override { cout << "B::f" << endl; }
};
int main() {
    B b;
    b.g();
    return 0;
}

#include <iostream>
using namespace std;
class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() {}
    bool isLargerThan(const Shape& other) const {
        return area() > other.area();
    }
};
class Circle : public Shape {
    double r;
public:
    Circle(double r) : r(r) {}
    double area() const override { return 3.14 * r * r; }
};
class Square : public Shape {
    double s;
public:
    Square(double s) : s(s) {}
    double area() const override { return s * s; }
};
int main() {
    Circle c(5);
    Square sq(8);
    cout << c.isLargerThan(sq) << endl;
    cout << sq.isLargerThan(c) << endl;
    return 0;
}

#include <iostream>
using namespace std;
class ILog {
public:
    virtual void log(const string& msg) const = 0;
    virtual ~ILog() {}
};
class INotify {
public:
    virtual void notify(const string& msg) const = 0;
    virtual ~INotify() {}
};
class Service : public ILog, public INotify {
public:
    void log(const string& msg) const override {
        cout << "[LOG] " << msg << endl;
    }
    void notify(const string& msg) const override {
        cout << "[NOTIFY] " << msg << endl;
    }
};
void doLog(const ILog& logger) { logger.log("System started"); }
void doNotify(const INotify& notifier) { notifier.notify("Alert!"); }
int main() {
    Service s;
    doLog(s);
    doNotify(s);
    return 0;
}

#include <iostream>
using namespace std;
class Base {
public:
    virtual void action() = 0;
    virtual ~Base() = 0;
};
Base::~Base() { cout << "~Base" << endl; }
void Base::action() { cout << "Base::action" << endl; }

class Mid : public Base {
public:
    void action() override {
        Base::action();
        cout << "Mid::action" << endl;
    }
    ~Mid() override { cout << "~Mid" << endl; }
};
class Leaf : public Mid {
public:
    void action() override {
        Mid::action();
        cout << "Leaf::action" << endl;
    }
    ~Leaf() override { cout << "~Leaf" << endl; }
};
int main() {
    Base* p = new Leaf();
    p->action();
    delete p;
    return 0;
}

#include <iostream>
using namespace std;
class IComparable {
public:
    virtual bool lessThan(const IComparable& other) const = 0;
    virtual ~IComparable() {}
};
class Score : public IComparable {
    int val;
public:
    Score(int v) : val(v) {}
    bool lessThan(const IComparable& other) const override {
        const Score& s = dynamic_cast<const Score&>(other);
        return val < s.val;
    }
};
int main() {
    Score a(85), b(92);
    cout << a.lessThan(b) << endl;
    cout << b.lessThan(a) << endl;
    return 0;
}

class A { public: virtual void f() = 0; virtual ~A(){} };
void A::f() { cout << "A"; }
class B : public A { public: void f() override { A::f(); cout << "B"; } };
int main() { B b; b.f(); }