Advanced OOP in C++: Operator Overloading, Virtual Inheritance, Abstract Classes & Design Patterns

#include <iostream>
#include <set>
#include <queue>
using namespace std;

struct Node {
    int id, cost;
    bool operator<(const Node& o) const { return cost < o.cost; }
    bool operator==(const Node& o) const { return id == o.id && cost == o.cost; }
    friend ostream& operator<<(ostream& os, const Node& n) {
        return os << "Node(" << n.id << ", cost=" << n.cost << ")";
    }
};

int main() {
    set<Node> nodes = {{1,10},{2,5},{3,15}};
    for (const auto& n : nodes) cout << n << " ";
    cout << endl;
    priority_queue<Node, vector<Node>, greater<Node>> pq;
    pq.push({1,10}); pq.push({2,3}); pq.push({3,7});
    while (!pq.empty()) { cout << pq.top() << " "; pq.pop(); }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;

class Graph {
public:
    int numVertices;
    Graph(int v) : numVertices(v) {}
    virtual void display() { cout << "Graph with " << numVertices << " vertices\n"; }
};
class DirectedGraph : virtual public Graph {
public: DirectedGraph(int v) : Graph(v) {}
};
class WeightedGraph : virtual public Graph {
public: WeightedGraph(int v) : Graph(v) {}
};
class DirectedWeightedGraph : public DirectedGraph, public WeightedGraph {
public:
    DirectedWeightedGraph(int v) : Graph(v), DirectedGraph(v), WeightedGraph(v) {}
};

int main() {
    DirectedWeightedGraph g(10);
    g.display();
    cout << "Vertices: " << g.numVertices << endl;
    return 0;
}

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

class GraphTraversal {
public:
    virtual void traverse(int start) = 0;
    virtual string name() const = 0;
    virtual ~GraphTraversal() {}
};

class BFS : public GraphTraversal {
public:
    void traverse(int start) override { cout << "BFS from vertex " << start << endl; }
    string name() const override { return "Breadth-First Search"; }
};

class DFS : public GraphTraversal {
public:
    void traverse(int start) override { cout << "DFS from vertex " << start << endl; }
    string name() const override { return "Depth-First Search"; }
};

int main() {
    vector<GraphTraversal*> algos = {new BFS(), new DFS()};
    for (auto* algo : algos) {
        cout << algo->name() << ": ";
        algo->traverse(0);
        delete algo;
    }
    return 0;
}

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

class AdjacencyList {
private:
    int vertices;
    vector<vector<int>> adj;
public:
    AdjacencyList(int v) : vertices(v), adj(v) {}
    void addEdge(int u, int v) { adj[u].push_back(v); adj[v].push_back(u); }
    friend ostream& operator<<(ostream& os, const AdjacencyList& g) {
        for (int i = 0; i < g.vertices; i++) {
            os << i << ": ";
            for (int v : g.adj[i]) os << v << " ";
            os << "\n";
        }
        return os;
    }
};

int main() {
    AdjacencyList g(4);
    g.addEdge(0,1); g.addEdge(0,2); g.addEdge(1,3);
    cout << g;
    return 0;
}

#include <iostream>
#include <vector>
#include <typeinfo>
using namespace std;

class ASTNode {
public:
    virtual ~ASTNode() {}
    virtual string type() const = 0;
};
class NumberNode : public ASTNode {
public:
    int value;
    NumberNode(int v) : value(v) {}
    string type() const override { return "Number"; }
};
class OperatorNode : public ASTNode {
public:
    char op;
    OperatorNode(char o) : op(o) {}
    string type() const override { return "Operator"; }
};

int main() {
    vector<ASTNode*> nodes = {
        new NumberNode(42), new OperatorNode('+'), new NumberNode(7)
    };
    for (auto* node : nodes) {
        cout << "Type: " << node->type() << " | ";
        if (auto* num = dynamic_cast<NumberNode*>(node))
            cout << "Value = " << num->value;
        else if (auto* op = dynamic_cast<OperatorNode*>(node))
            cout << "Op = " << op->op;
        cout << endl;
        delete node;
    }
    return 0;
}

#include <iostream>
using namespace std;
class GraphConfig {
private:
    int maxVertices;
    GraphConfig() : maxVertices(1000) {}
public:
    static GraphConfig& getInstance() {
        static GraphConfig instance;
        return instance;
    }
    GraphConfig(const GraphConfig&) = delete;
    GraphConfig& operator=(const GraphConfig&) = delete;
    int getMax() const { return maxVertices; }
    void setMax(int m) { maxVertices = m; }
};
int main() {
    GraphConfig& cfg1 = GraphConfig::getInstance();
    cfg1.setMax(500);
    GraphConfig& cfg2 = GraphConfig::getInstance();
    cout << "Max: " << cfg2.getMax() << endl;
    cout << "Same? " << (&cfg1 == &cfg2 ? "yes" : "no") << endl;
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;
class IGraph {
public:
    virtual void addEdge(int u, int v) = 0;
    virtual string typeName() const = 0;
    virtual ~IGraph() = default;
};
class DirectedGraph : public IGraph {
public:
    void addEdge(int u, int v) override { cout << "Directed: " << u << " → " << v << endl; }
    string typeName() const override { return "Directed"; }
};
class UndirectedGraph : public IGraph {
public:
    void addEdge(int u, int v) override { cout << "Undirected: " << u << " — " << v << endl; }
    string typeName() const override { return "Undirected"; }
};
unique_ptr<IGraph> createGraph(const string& type) {
    if (type == "directed")   return make_unique<DirectedGraph>();
    if (type == "undirected") return make_unique<UndirectedGraph>();
    return nullptr;
}
int main() {
    auto g1 = createGraph("directed");
    auto g2 = createGraph("undirected");
    g1->addEdge(0, 1); g2->addEdge(2, 3);
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class SortStrategy {
public:
    virtual void sort(vector<int>& data) = 0;
    virtual string name() const = 0;
    virtual ~SortStrategy() = default;
};
class STLSort : public SortStrategy {
public:
    void sort(vector<int>& data) override { std::sort(data.begin(), data.end()); }
    string name() const override { return "std::sort (introsort)"; }
};
class BubbleSort : public SortStrategy {
public:
    void sort(vector<int>& data) override {
        int n = data.size();
        for (int i = 0; i < n-1; i++)
            for (int j = 0; j < n-i-1; j++)
                if (data[j] > data[j+1]) swap(data[j], data[j+1]);
    }
    string name() const override { return "Bubble Sort O(n²)"; }
};
class Sorter {
    SortStrategy* strategy;
public:
    Sorter(SortStrategy* s) : strategy(s) {}
    void setStrategy(SortStrategy* s) { strategy = s; }
    void sort(vector<int>& data) { cout << "Using: " << strategy->name() << endl; strategy->sort(data); }
};
int main() {
    vector<int> data = {5,2,8,1,9};
    STLSort stl; BubbleSort bubble;
    Sorter sorter(&stl);
    sorter.sort(data);
    for (int x : data) cout << x << " "; cout << endl;
    data = {5,2,8,1,9};
    sorter.setStrategy(&bubble);
    sorter.sort(data);
    for (int x : data) cout << x << " "; cout << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <stdexcept>
using namespace std;
class IPriorityQueue {
public:
    virtual void push(int v) = 0;
    virtual int pop() = 0;
    virtual bool isEmpty() const = 0;
    virtual ~IPriorityQueue() = default;
};
class MaxHeap : public IPriorityQueue {
    vector<int> h;
    void siftUp(int i) { while(i>0&&h[(i-1)/2]<h[i]){swap(h[i],h[(i-1)/2]);i=(i-1)/2;} }
    void siftDown(int i){int n=h.size(),mx=i;if(2*i+1<n&&h[2*i+1]>h[mx])mx=2*i+1;if(2*i+2<n&&h[2*i+2]>h[mx])mx=2*i+2;if(mx!=i){swap(h[i],h[mx]);siftDown(mx);}}
public:
    void push(int v) override { h.push_back(v); siftUp(h.size()-1); }
    int pop() override { if(h.empty())throw runtime_error("empty"); int r=h[0];h[0]=h.back();h.pop_back();if(!h.empty())siftDown(0);return r; }
    bool isEmpty() const override { return h.empty(); }
    MaxHeap operator+(const MaxHeap& o) const {
        MaxHeap result; result.h=h;
        result.h.insert(result.h.end(),o.h.begin(),o.h.end());
        for(int i=result.h.size()/2-1;i>=0;--i) result.siftDown(i);
        return result;
    }
};
int main() {
    MaxHeap pq1, pq2;
    pq1.push(5); pq1.push(3); pq2.push(7); pq2.push(1);
    MaxHeap merged = pq1 + pq2;
    while(!merged.isEmpty()) cout << merged.pop() << " ";
    cout << endl;
    return 0;
}