Абстрактні класи та чисті віртуальні функції

#include <iostream>

class Shape
{
public:
    virtual double getArea() const
    {
        // ❓ Яку площу повертати для "абстрактної фігури"?
        return 0.0;  // Заглушка, яка не має сенсу
    }
    
    virtual ~Shape() = default;
};

class Circle : public Shape
{
private:
    double radius;

public:
    Circle(double r) : radius(r) {}
    
    double getArea() const override
    {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape
{
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double getArea() const override
    {
        return width * height;
    }
};

class Shape
{
public:
    // Чиста віртуальна функція: оголошення без реалізації
    virtual double getArea() const = 0;
    virtual void draw() const = 0;
    
    virtual ~Shape() = default;
};

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

int main()
{
    // ❌ Помилка компіляції: не можна створювати об'єкти абстрактного класу
    Shape shape;  
    
    // ❌ Помилка: не можна створювати через new
    Shape* ptr = new Shape();
    
    return 0;
}

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

class Circle : public Shape
{
private:
    double radius;

public:
    Circle(double r) : radius(r) {}
    
    // ✅ Перевизначили getArea()
    double getArea() const override
    {
        return 3.14159 * radius * radius;
    }
    
    // ❌ Забули перевизначити draw()
    // Circle залишається абстрактним!
};

int main()
{
    // ❌ Помилка: Circle все ще абстрактний клас
    Circle c(5.0);
    
    return 0;
}

class Circle : public Shape
{
private:
    double radius;

public:
    Circle(double r) : radius(r) {}
    
    double getArea() const override
    {
        return 3.14159 * radius * radius;
    }
    
    void draw() const override
    {
        std::cout << "Малюю коло радіусом " << radius << "\n";
    }
};

int main()
{
    // ✅ Тепер можна створювати об'єкти Circle
    Circle c(5.0);
    std::cout << "Площа кола: " << c.getArea() << "\n";
    c.draw();
    
    return 0;
}

#include <iostream>
#include <string>

// Абстрактний клас: визначає контракт для всіх платіжних систем
class PaymentProcessor
{
public:
    virtual ~PaymentProcessor() = default;
    
    // Чисті віртуальні функції: обов'язковий контракт
    virtual bool authorize(double amount) = 0;
    virtual bool charge(double amount, const std::string& description) = 0;
    virtual void refund(double amount) = 0;
    
    // Невіртуальний метод: спільна логіка для всіх процесорів
    void logTransaction(const std::string& message) const
    {
        std::cout << "[LOG] " << message << "\n";
    }
};

// Конкретна реалізація: PayPal
class PayPalProcessor : public PaymentProcessor
{
private:
    std::string email;

public:
    PayPalProcessor(std::string userEmail) : email(userEmail) {}
    
    bool authorize(double amount) override
    {
        logTransaction("PayPal: перевірка ліміту для " + email);
        return amount <= 10000.0;  // Ліміт $10,000
    }
    
    bool charge(double amount, const std::string& description) override
    {
        logTransaction("PayPal: списано $" + std::to_string(amount) + " - " + description);
        return true;
    }
    
    void refund(double amount) override
    {
        logTransaction("PayPal: повернуто $" + std::to_string(amount));
    }
};

// Конкретна реалізація: кредитна картка
class CreditCardProcessor : public PaymentProcessor
{
private:
    std::string cardNumber;

public:
    CreditCardProcessor(std::string card) : cardNumber(card) {}
    
    bool authorize(double amount) override
    {
        logTransaction("Картка " + cardNumber + ": перевірка через банк");
        return amount <= 50000.0;  // Ліміт $50,000
    }
    
    bool charge(double amount, const std::string& description) override
    {
        logTransaction("Картка: списано $" + std::to_string(amount));
        return true;
    }
    
    void refund(double amount) override
    {
        logTransaction("Картка: повернуто $" + std::to_string(amount));
    }
};

// Функція обробки платежу: працює з будь-яким процесором
void processPayment(PaymentProcessor& processor, double amount, const std::string& description)
{
    if (processor.authorize(amount)) {
        if (processor.charge(amount, description)) {
            std::cout << "✅ Платіж успішний\n\n";
        }
    } else {
        std::cout << "❌ Платіж відхилено: недостатній ліміт\n\n";
    }
}

int main()
{
    PayPalProcessor paypal("user@example.com");
    CreditCardProcessor card("**** 1234");
    
    processPayment(paypal, 500.0, "Підписка Premium");
    processPayment(card, 1500.0, "Покупка обладнання");
    
    return 0;
}

#include <iostream>
#include <string>

class Document
{
protected:
    std::string title;
    std::string author;

public:
    Document(std::string t, std::string a) : title(t), author(a) {}
    
    virtual ~Document() = default;
    
    // Невіртуальний метод: спільна логіка
    void printMetadata() const
    {
        std::cout << "Назва: " << title << "\n";
        std::cout << "Автор: " << author << "\n";
    }
    
    // Віртуальний метод з реалізацією за замовчуванням
    virtual std::string getType() const
    {
        return "Загальний документ";
    }
    
    // Чиста віртуальна функція: кожен тип документа має свій спосіб відображення
    virtual void render() const = 0;
};

class PDFDocument : public Document
{
public:
    PDFDocument(std::string t, std::string a) : Document(t, a) {}
    
    std::string getType() const override
    {
        return "PDF документ";
    }
    
    void render() const override
    {
        std::cout << "Рендеринг PDF: відкриття Adobe Reader...\n";
    }
};

class MarkdownDocument : public Document
{
public:
    MarkdownDocument(std::string t, std::string a) : Document(t, a) {}
    
    std::string getType() const override
    {
        return "Markdown документ";
    }
    
    void render() const override
    {
        std::cout << "Рендеринг Markdown: перетворення на HTML...\n";
    }
};

int main()
{
    PDFDocument pdf("Звіт_2024", "Іван Петренко");
    MarkdownDocument md("README", "Марія Коваль");
    
    Document* docs[] = { &pdf, &md };
    
    for (Document* doc : docs) {
        doc->printMetadata();
        std::cout << "Тип: " << doc->getType() << "\n";
        doc->render();
        std::cout << "\n";
    }
    
    return 0;
}

class ILogger
{
public:
    virtual ~ILogger() = default;
    
    // Всі методи — чисті віртуальні функції
    virtual void log(const std::string& message) = 0;
    virtual void logError(const std::string& error) = 0;
    virtual void logWarning(const std::string& warning) = 0;
};

#include <iostream>
#include <fstream>
#include <string>

// Інтерфейс: контракт для всіх логерів
class ILogger
{
public:
    virtual ~ILogger() = default;
    
    virtual void log(const std::string& message) = 0;
    virtual void logError(const std::string& error) = 0;
    virtual void logWarning(const std::string& warning) = 0;
};

// Конкретна реалізація: логування в консоль
class ConsoleLogger : public ILogger
{
public:
    void log(const std::string& message) override
    {
        std::cout << "[INFO] " << message << "\n";
    }
    
    void logError(const std::string& error) override
    {
        std::cout << "[ERROR] " << error << "\n";
    }
    
    void logWarning(const std::string& warning) override
    {
        std::cout << "[WARNING] " << warning << "\n";
    }
};

// Конкретна реалізація: логування у файл
class FileLogger : public ILogger
{
private:
    std::ofstream file;

public:
    FileLogger(const std::string& filename)
    {
        file.open(filename, std::ios::app);
    }
    
    ~FileLogger()
    {
        if (file.is_open()) {
            file.close();
        }
    }
    
    void log(const std::string& message) override
    {
        if (file.is_open()) {
            file << "[INFO] " << message << "\n";
        }
    }
    
    void logError(const std::string& error) override
    {
        if (file.is_open()) {
            file << "[ERROR] " << error << "\n";
        }
    }
    
    void logWarning(const std::string& warning) override
    {
        if (file.is_open()) {
            file << "[WARNING] " << warning << "\n";
        }
    }
};

// Функція, що використовує логер: залежить від абстракції, а не реалізації
void processData(ILogger& logger, int value)
{
    logger.log("Початок обробки даних");
    
    if (value < 0) {
        logger.logError("Від'ємне значення: " + std::to_string(value));
        return;
    }
    
    if (value > 100) {
        logger.logWarning("Велике значення: " + std::to_string(value));
    }
    
    logger.log("Обробка завершена: результат = " + std::to_string(value * 2));
}

int main()
{
    ConsoleLogger console;
    FileLogger fileLog("app.log");
    
    std::cout << "=== Логування в консоль ===\n";
    processData(console, 50);
    processData(console, -10);
    processData(console, 150);
    
    std::cout << "\n=== Логування у файл (перевірте app.log) ===\n";
    processData(fileLog, 75);
    
    return 0;
}

#include <iostream>
#include <string>

// Інтерфейс: сериалізація у рядок
class ISerializable
{
public:
    virtual ~ISerializable() = default;
    virtual std::string serialize() const = 0;
};

// Інтерфейс: порівняння об'єктів
class IComparable
{
public:
    virtual ~IComparable() = default;
    virtual int compareTo(const IComparable& other) const = 0;
};

// Конкретний клас, що реалізує обидва інтерфейси
class Product : public ISerializable, public IComparable
{
private:
    std::string name;
    double price;

public:
    Product(std::string n, double p) : name(n), price(p) {}
    
    // Реалізація ISerializable
    std::string serialize() const override
    {
        return "Product{name=\"" + name + "\", price=" + std::to_string(price) + "}";
    }
    
    // Реалізація IComparable
    int compareTo(const IComparable& other) const override
    {
        const Product& otherProduct = dynamic_cast<const Product&>(other);
        if (price < otherProduct.price) return -1;
        if (price > otherProduct.price) return 1;
        return 0;
    }
    
    double getPrice() const { return price; }
};

int main()
{
    Product laptop("Asus ZenBook", 35000.0);
    Product phone("iPhone 15", 45000.0);
    
    // Використання через інтерфейс ISerializable
    ISerializable* s = &laptop;
    std::cout << "Сериалізація: " << s->serialize() << "\n\n";
    
    // Використання через інтерфейс IComparable
    IComparable* c1 = &laptop;
    IComparable* c2 = &phone;
    
    int result = c1->compareTo(*c2);
    if (result < 0) {
        std::cout << "Laptop дешевший за Phone\n";
    } else if (result > 0) {
        std::cout << "Laptop дорожчий за Phone\n";
    } else {
        std::cout << "Однакова ціна\n";
    }
    
    return 0;
}

#include <iostream>
#include <fstream>

// Низькорівнева деталь: конкретний спосіб логування
class FileLogger
{
private:
    std::ofstream file;

public:
    FileLogger() { file.open("app.log", std::ios::app); }
    ~FileLogger() { if (file.is_open()) file.close(); }
    
    void log(const std::string& message)
    {
        if (file.is_open()) {
            file << "[LOG] " << message << "\n";
        }
    }
};

// Високорівнева бізнес-логіка: сервіс обробки замовлень
class OrderService
{
private:
    FileLogger logger;  // ❌ Жорстка залежність від конкретної реалізації

public:
    void processOrder(int orderId)
    {
        logger.log("Обробка замовлення " + std::to_string(orderId));
        // ... бізнес-логіка ...
        logger.log("Замовлення " + std::to_string(orderId) + " завершено");
    }
};

int main()
{
    OrderService service;
    service.processOrder(12345);
    
    return 0;
}

#include <iostream>
#include <fstream>

// Абстракція (інтерфейс)
class ILogger
{
public:
    virtual ~ILogger() = default;
    virtual void log(const std::string& message) = 0;
};

// Конкретна реалізація #1: файл
class FileLogger : public ILogger
{
private:
    std::ofstream file;

public:
    FileLogger() { file.open("app.log", std::ios::app); }
    ~FileLogger() { if (file.is_open()) file.close(); }
    
    void log(const std::string& message) override
    {
        if (file.is_open()) {
            file << "[FILE] " << message << "\n";
        }
    }
};

// Конкретна реалізація #2: консоль
class ConsoleLogger : public ILogger
{
public:
    void log(const std::string& message) override
    {
        std::cout << "[CONSOLE] " << message << "\n";
    }
};

// Високорівнева бізнес-логіка залежить від абстракції
class OrderService
{
private:
    ILogger& logger;  // ✅ Залежність від інтерфейсу, а не реалізації

public:
    OrderService(ILogger& log) : logger(log) {}
    
    void processOrder(int orderId)
    {
        logger.log("Обробка замовлення " + std::to_string(orderId));
        // ... бізнес-логіка ...
        logger.log("Замовлення " + std::to_string(orderId) + " завершено");
    }
};

int main()
{
    FileLogger fileLog;
    ConsoleLogger consoleLog;
    
    // Можемо легко змінювати реалізацію логування
    OrderService service1(fileLog);
    service1.processOrder(12345);
    
    std::cout << "\n--- Змінюємо логер ---\n\n";
    
    OrderService service2(consoleLog);
    service2.processOrder(67890);
    
    return 0;
}

class IBase
{
public:
    virtual ~IBase() = default;  // ❌ Клас НЕ абстрактний!
};

int main()
{
    // ✅ Компілюється — IBase не є абстрактним класом
    IBase base;  
    
    return 0;
}

class IBase
{
public:
    virtual ~IBase() = 0;  // Чистий віртуальний деструктор
};

int main()
{
    // ❌ Помилка компіляції: IBase є абстрактним класом
    IBase base;
    
    return 0;
}

#include <iostream>

class IBase
{
public:
    virtual ~IBase() = 0;  // Оголошення: чистий віртуальний
};

// Визначення: обов'язкове тіло реалізації поза класом
IBase::~IBase()
{
    std::cout << "Деструктор IBase викликано\n";
}

class Derived : public IBase
{
public:
    ~Derived()
    {
        std::cout << "Деструктор Derived викликано\n";
    }
};

int main()
{
    // ❌ Не можемо створювати IBase напряму — абстрактний клас
    // IBase base;
    
    // ✅ Створюємо Derived, знищуємо через IBase*
    IBase* ptr = new Derived();
    delete ptr;
    
    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>

// Інтерфейс: можливість малювання
class IDrawable
{
public:
    virtual ~IDrawable() = default;
    virtual void draw() const = 0;
};

// Інтерфейс: можливість обертання
class IRotatable
{
public:
    virtual ~IRotatable() = default;
    virtual void rotate(double angle) = 0;
};

// Абстрактний базовий клас: геометрична фігура
class Shape : public IDrawable
{
protected:
    double posX, posY;
    std::string color;

public:
    Shape(double x, double y, std::string c) 
        : posX(x), posY(y), color(c) {}
    
    virtual ~Shape() = default;
    
    // Чиста віртуальна функція: площа (кожна фігура обчислює по-своєму)
    virtual double getArea() const = 0;
    
    // Спільна невіртуальна логіка
    void printInfo() const
    {
        std::cout << "  Позиція: (" << posX << ", " << posY << ")\n";
        std::cout << "  Колір: " << color << "\n";
        std::cout << "  Площа: " << getArea() << "\n";
    }
};

// Конкретна фігура: коло
class Circle : public Shape, public IRotatable
{
private:
    double radius;

public:
    Circle(double x, double y, std::string c, double r)
        : Shape(x, y, c), radius(r) {}
    
    double getArea() const override
    {
        return 3.14159 * radius * radius;
    }
    
    void draw() const override
    {
        std::cout << "Малюю коло:\n";
        printInfo();
    }
    
    void rotate(double angle) override
    {
        std::cout << "  Обертаю коло на " << angle << " градусів (без візуального ефекту)\n";
    }
};

// Конкретна фігура: прямокутник
class Rectangle : public Shape, public IRotatable
{
private:
    double width, height;
    double rotationAngle = 0.0;

public:
    Rectangle(double x, double y, std::string c, double w, double h)
        : Shape(x, y, c), width(w), height(h) {}
    
    double getArea() const override
    {
        return width * height;
    }
    
    void draw() const override
    {
        std::cout << "Малюю прямокутник:\n";
        printInfo();
        std::cout << "  Кут обертання: " << rotationAngle << " градусів\n";
    }
    
    void rotate(double angle) override
    {
        rotationAngle += angle;
        std::cout << "  Обертаю прямокутник на " << angle << " градусів (новий кут: " << rotationAngle << ")\n";
    }
};

// Функція: малювання всіх об'єктів через інтерфейс
void renderScene(const std::vector<IDrawable*>& objects)
{
    std::cout << "=== Рендеринг сцени ===\n\n";
    for (const IDrawable* obj : objects) {
        obj->draw();
        std::cout << "\n";
    }
}

int main()
{
    Circle circle(100, 100, "червоний", 50);
    Rectangle rect(200, 150, "синій", 80, 40);
    
    // Обертаємо фігури
    IRotatable* rotatable1 = &circle;
    IRotatable* rotatable2 = &rect;
    
    rotatable1->rotate(45);
    rotatable2->rotate(90);
    std::cout << "\n";
    
    // Малюємо всі фігури через єдиний інтерфейс
    std::vector<IDrawable*> scene = { &circle, &rect };
    renderScene(scene);
    
    return 0;
}