Чистые виртуальные функции

Часть раздела Объектно-ориентированное программирование путешествия по C++ на Coddy. Урок 59 из 104.

Чистая виртуальная функция — это виртуальная функция, у которой нет реализации в базовом классе. Она объявляется присваиванием = 0 объявлению функции. Это сообщает компилятору, что производные классы обязаны предоставить собственную реализацию.

class Shape {
public:
    virtual double area() = 0;  // Чисто виртуальная функция
    virtual ~Shape() = default;
};

В отличие от обычных виртуальных функций, которые задают поведение по умолчанию, чистые виртуальные функции определяют контракт: любой конкретный производный class должен реализовать эту function, чтобы его можно было создать. Базовый class просто объявляет что должно быть сделано, а не как.

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    
    double area() override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double area() override {
        return width * height;
    }
};

И Circle, и Rectangle должны реализовать area(), поскольку в Shape это чистая виртуальная функция. Если производному классу не удаётся реализовать все чистые виртуальные функции, он также становится абстрактным и не может быть создан.

Чистые виртуальные function необходимы, когда базовый class не может предоставить осмысленную реализацию по умолчанию. У каждой фигуры есть area, но невозможно разумно calculate «area generic shape», не зная конкретного типа фигуры.

Задание

Легко

Давайте создадим систему обработки платежей, которая демонстрирует, как чистые виртуальные функции обеспечивают соблюдение контракта для различных способов оплаты. Вы создадите абстрактный базовый класс, определяющий, что должен делать каждый обработчик платежей, а затем реализуете конкретные типы платежей, выполняющие этот контракт.

Вы организуете код в трёх файлах:

PaymentProcessor.h: определите абстрактный класс PaymentProcessor, который служит основой для всех способов оплаты. Этот класс должен содержать:
- защищённый член std::string accountId
- конструктор, инициализирующий идентификатор аккаунта
- чистый виртуальный метод processPayment(double amount): каждый тип платежа должен реализовать его по-своему
- чистый виртуальный метод getProcessorName(), возвращающий std::string
- виртуальный деструктор
PaymentMethods.h: реализуйте два конкретных обработчика платежей, наследующих PaymentProcessor:
CreditCardProcessor:
- закрытый член double feePercentage (ставка комиссии за транзакцию)
- конструктор, принимающий идентификатор аккаунта и процент комиссии
- реализуйте processPayment(), чтобы вычислить комиссию (amount * feePercentage / 100), а затем вывести:
  Credit Card [<accountId>]: Charged $<amount> (Fee: $<fee>)
- реализуйте getProcessorName(), возвращающий "CreditCard"
BankTransferProcessor:
- закрытый член std::string bankName
- конструктор, принимающий идентификатор аккаунта и название банка
- реализуйте processPayment(), чтобы вывести:
  Bank Transfer [<accountId>] via <bankName>: Transferred $<amount>
- реализуйте getProcessorName(), возвращающий "BankTransfer"
main.cpp: считайте четыре входных значения (каждое в отдельной строке):
1. идентификатор аккаунта кредитной карты
2. процент комиссии кредитной карты (double)
3. идентификатор банковского аккаунта
4. название банка
Создайте оба обработчика платежей и сохраните их в массиве указателей PaymentProcessor*. Выполните платёж на сумму 100.0 через каждый обработчик, отображая имя обработчика перед каждой транзакцией:
```
Processing with <processorName>:
<processPayment output>
```
Выведите пустую строку между обработчиками. После завершения освободите память, выделенную динамически.

Например, для входных данных CC-4521, 2.5, BA-7890 и National Bank:

Processing with CreditCard:
Credit Card [CC-4521]: Charged $100 (Fee: $2.5)

Processing with BankTransfer:
Bank Transfer [BA-7890] via National Bank: Transferred $100

Поскольку PaymentProcessor содержит чистые виртуальные функции, нельзя создать его экземпляр напрямую: можно создавать только конкретные реализации, выполняющие контракт. Это гарантирует, что каждый способ оплаты предоставляет собственную логику обработки.

Попробуйте сами

#include <iostream>
#include <string>
#include "PaymentMethods.h"

using namespace std;

int main() {
    // Прочитать входные данные
    string ccAccountId;
    double feePercentage;
    string bankAccountId;
    string bankName;
    
    getline(cin, ccAccountId);
    cin >> feePercentage;
    cin.ignore();
    getline(cin, bankAccountId);
    getline(cin, bankName);
    
    // TODO: Создать массив указателей PaymentProcessor* с 2 элементами
    
    // TODO: Создать объекты CreditCardProcessor и BankTransferProcessor
    // и сохранить их в массиве
    
    // TODO: Пройти по массиву и для каждого процессора:
    // 1. Print "Processing with <processorName>:"
    // 2. Вызвать processPayment с суммой 100.0
    // 3. Вывести пустую строку между процессорами (не после последнего)
    
    // TODO: Очистить динамически выделенные объекты
    
    return 0;
}