examples

/**
 * Abstract Classes - Examples
 * Compile: g++ -std=c++17 -Wall examples.cpp -o examples
 */

#include <iostream>
#include <string>
#include <vector>
#include <memory>
using namespace std;

// ============================================================
// SECTION 1: BASIC ABSTRACT CLASS
// ============================================================

class Shape {
public:
    virtual double area() const = 0;
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override { return 3.14159 * radius * radius; }
    void draw() const override { cout << "  Circle(r=" << radius << ")" << endl; }
};

class Rectangle : public Shape {
    double w, h;
public:
    Rectangle(double w, double h) : w(w), h(h) {}
    double area() const override { return w * h; }
    void draw() const override { cout << "  Rectangle(" << w << "x" << h << ")" << endl; }
};

void demoBasic() {
    cout << "--- Basic Abstract Class ---\n" << endl;
    
    vector<unique_ptr<Shape>> shapes;
    shapes.push_back(make_unique<Circle>(5));
    shapes.push_back(make_unique<Rectangle>(4, 3));
    
    for (const auto& s : shapes) {
        s->draw();
        cout << "    Area: " << s->area() << endl;
    }
}

// ============================================================
// SECTION 2: INTERFACE PATTERN
// ============================================================

class ISerializable {
public:
    virtual string serialize() const = 0;
    virtual void deserialize(const string& data) = 0;
    virtual ~ISerializable() = default;
};

class IPrintable {
public:
    virtual void print() const = 0;
    virtual ~IPrintable() = default;
};

class Document : public ISerializable, public IPrintable {
    string title, content;
public:
    Document(const string& t, const string& c) : title(t), content(c) {}
    
    string serialize() const override {
        return title + "|" + content;
    }
    
    void deserialize(const string& data) override {
        size_t pos = data.find('|');
        title = data.substr(0, pos);
        content = data.substr(pos + 1);
    }
    
    void print() const override {
        cout << "  " << title << ": " << content << endl;
    }
};

void demoInterface() {
    cout << "\n--- Interface Pattern ---\n" << endl;
    
    Document doc("Report", "Q4 Results");
    doc.print();
    cout << "  Serialized: " << doc.serialize() << endl;
}

// ============================================================
// SECTION 3: PARTIAL IMPLEMENTATION
// ============================================================

class Logger {
public:
    virtual void log(const string& msg) = 0;
    
    void info(const string& msg) { log("[INFO] " + msg); }
    void warn(const string& msg) { log("[WARN] " + msg); }
    void error(const string& msg) { log("[ERROR] " + msg); }
    
    virtual ~Logger() = default;
};

class ConsoleLogger : public Logger {
public:
    void log(const string& msg) override {
        cout << "  " << msg << endl;
    }
};

void demoPartial() {
    cout << "\n--- Partial Implementation ---\n" << endl;
    
    ConsoleLogger logger;
    logger.info("Application started");
    logger.warn("Low memory");
    logger.error("Connection failed");
}

// ============================================================
// SECTION 4: PURE VIRTUAL WITH BODY
// ============================================================

class Validator {
public:
    virtual bool validate(const string& data) = 0;
    virtual ~Validator() = default;
};

bool Validator::validate(const string& data) {
    return !data.empty();  // Default: just check non-empty
}

class EmailValidator : public Validator {
public:
    bool validate(const string& data) override {
        if (!Validator::validate(data)) return false;
        return data.find('@') != string::npos;
    }
};

void demoPureWithBody() {
    cout << "\n--- Pure Virtual with Body ---\n" << endl;
    
    EmailValidator ev;
    cout << "  'test@email.com' valid: " << (ev.validate("test@email.com") ? "yes" : "no") << endl;
    cout << "  'invalid' valid: " << (ev.validate("invalid") ? "yes" : "no") << endl;
    cout << "  '' valid: " << (ev.validate("") ? "yes" : "no") << endl;
}

// ============================================================
// SECTION 5: ABSTRACT FACTORY PATTERN
// ============================================================

class Button {
public:
    virtual void render() const = 0;
    virtual ~Button() = default;
};

class WindowsButton : public Button {
public:
    void render() const override { cout << "  [Windows Button]" << endl; }
};

class MacButton : public Button {
public:
    void render() const override { cout << "  [Mac Button]" << endl; }
};

class GUIFactory {
public:
    virtual unique_ptr<Button> createButton() = 0;
    virtual ~GUIFactory() = default;
};

class WindowsFactory : public GUIFactory {
public:
    unique_ptr<Button> createButton() override {
        return make_unique<WindowsButton>();
    }
};

class MacFactory : public GUIFactory {
public:
    unique_ptr<Button> createButton() override {
        return make_unique<MacButton>();
    }
};

void demoAbstractFactory() {
    cout << "\n--- Abstract Factory ---\n" << endl;
    
    unique_ptr<GUIFactory> factory = make_unique<WindowsFactory>();
    auto btn = factory->createButton();
    btn->render();
    
    factory = make_unique<MacFactory>();
    btn = factory->createButton();
    btn->render();
}

// ============================================================
// MAIN
// ============================================================

int main() {
    cout << "╔══════════════════════════════════════╗" << endl;
    cout << "║     ABSTRACT CLASSES - EXAMPLES      ║" << endl;
    cout << "╚══════════════════════════════════════╝" << endl;
    
    demoBasic();
    demoInterface();
    demoPartial();
    demoPureWithBody();
    demoAbstractFactory();
    
    cout << "\n=== Complete ===" << endl;
    return 0;
}