inheritance 10

#include <iostream>
#include <cmath>
#include <stdexcept>

// Класс массива
class Array {
private:
    double* data;
    size_t size;
public:
    // Конструктор с заданным размером
    Array(size_t size) : size(size), data(new double[size]) {}

    // Конструктор копирования
    Array(const Array& other) : size(other.size), data(new double[other.size]) {
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    // Деструктор
    ~Array() {
        delete[] data;
    }

    // Оператор присваивания
    Array& operator=(const Array& other) {
        if (this == &other) return *this;
        delete[] data;
        size = other.size;
        data = new double[size];
        for (size_t i = 0; i < size; i++) {
            data[i] = other.data[i];
        }
        return *this;
    }

    // Оператор доступа (чтение)
    double operator[](size_t index) const {
        return data[index];
    }

    // Оператор доступа (запись)
    double& operator[](size_t index) {
        return data[index];
    }

    // Возвращает размер массива
    size_t Size() const { return size; }


};

// Базовый класс для всех операций
class Operator {
public:
    virtual Array Process(const Array& input) const = 0; // Чисто виртуальный метод
    virtual ~Operator() {}
};

// Класс AddConstant: добавляет константу к каждому элементу массива
class AddConstant : public Operator {
private:
    double value;

public:
    AddConstant(double value) : value(value) {}

    Array Process(const Array& input) const override {
        Array result(input.Size());
        for (size_t i = 0; i < input.Size(); ++i) {
            result[i] = input[i] + value;
        }
        return result;
    }
};

// Класс Clip: ограничивает значения массива минимальным и максимальным значением
class Clip : public Operator {
private:
    double minValue;
    double maxValue;

public:
    Clip(double minValue, double maxValue) : minValue(minValue), maxValue(maxValue) {}

    Array Process(const Array& input) const override {
        Array result(input.Size());
        for (size_t i = 0; i < input.Size(); ++i) {
            if (input[i] < minValue) {
                result[i] = minValue;
            } else if (input[i] > maxValue) {
                result[i] = maxValue;
            } else {
                result[i] = input[i];
            }
        }
        return result;
    }
};

// Класс Log: вычисляет натуральный логарифм для каждого элемента массива
class Log : public Operator {
public:
    Array Process(const Array& input) const override {
        Array result(input.Size());
        for (size_t i = 0; i < input.Size(); ++i) {
            if (input[i] <= 0) {
                throw std::invalid_argument("Error: Logarifm not defined for non positive values");
            }
            result[i] = std::log(input[i]);
        }
        return result;
    }
};

// Класс Pipeline: объединяет цепочку операторов
class Pipeline : public Operator {
private:
    Operator** ops; // Двойной указатель для полиморфных операторов
    size_t count;   // Количество операторов

public:
    Pipeline() : ops(nullptr), count(0) {}

    // Добавление оператора в цепочку
    void AddOperator(Operator* op) {
        Operator** newOps = new Operator*[count + 1];
        for (size_t i = 0; i < count; ++i) {
            newOps[i] = ops[i];
        }
        newOps[count] = op;
        delete[] ops;
        ops = newOps;
        count++;
    }

    // Применение всех операторов по цепочке
    Array Process(const Array& input) const override {
        Array result = input;
        for (size_t i = 0; i < count; ++i) {
            result = ops[i]->Process(result);
        }
        return result;
    }

    // Деструктор
    ~Pipeline() {
        delete[] ops;
    }
};

// Главная функция для демонстрации работы
int main() {
    try {
        // Создаём массив данных
        Array data(5);
        data[0] = 1.0;
        data[1] = 2.0;
        data[2] = 3.0;
        data[3] = 12;
        data[4] = -7.0; // Пример неположительного числа

        // Создаём операторы
        AddConstant addOp(5.0);
        Clip clipOp(0.0, 10.0);
        Log logOp;

        // Создаём pipeline и добавляем операторы
        Pipeline pipeline;
        pipeline.AddOperator(&addOp);
        pipeline.AddOperator(&clipOp);
        pipeline.AddOperator(&logOp);

        // Применяем pipeline к данным
        Array result = pipeline.Process(data);

        // Выводим результат
        for (size_t i = 0; i < result.Size(); ++i) {
            std::cout << result[i] << " ";
        }
        std::cout << std::endl;
    } catch (const std::exception& ex) {
        std::cerr << "Exception: " << ex.what() << std::endl;
    }

    return 0;
}