#include <iostream>
#include <fstream>
#include <cmath>

//допустимі межі змінних для перевірки
#define qA 1e-9
#define qB 2e-9
#define eA 12e-11
#define eB 15e-11
#define rA 1e-4
#define rB 3e-4

#define EPS 1e-18

//помилка при діленні на нуль
#define DIV_ERROR       "Cannot be divided by zero!"

//помилка відриття файла
#define OPEN_ERROR      "The file cannot be opened!"

//помилки при некоректних параметрах
#define E_ERROR     "Param e is invalid!"
#define R_ERROR     "Param q is invalid!"
#define Q_ERROR     "Param r is invalid!"

//вхідний та вихідний файли
#define INPUT_FILE  "input.txt"
#define OUTPUT_FILE "output.txt"

using namespace std;

//абстрактний клас об’єкт_обчислення
class calcObject {
    protected:
        //обчислюваний параметр
        float calcParam;

    public:
        //віртуальна функція введення даних із файлу
        virtual void read(ifstream& ifs) = 0;

        //віртуальна фукнція розрахунок обчислюваного параметру
        virtual float getResult() = 0;

        //віртуальна фукнція виведення в файл результату та вхідних даних
        virtual void write(ofstream& ofs) = 0;

        //віртуальна функція виведення результату та вхідних даних у консоль
        virtual void print() = 0;
};

//клас заряд похідний від абстрактного класу
class Charge : public calcObject {
    private:
        //заряди
        float q1, q2;

        //епсілон
        float e;

        //відстань між зарядами
        float r;

        //функція для перевірки параметрів
        void check() {
            if (e < eA || eB < e) {
                cout << E_ERROR << endl;
                exit(1);
            }

            if (r < rA || rB < r) {
                cout << R_ERROR << endl;
                exit(1);
            }

            if (q1 < qA || qB < q1 || q2 < qA || qB < q2) {
                cout << Q_ERROR << endl;
                exit(1);
            }
        }

    public:
        //констуктор за замовчуванням
        Charge() {
            q1 = q2 = e = r = calcParam = 0;
        }

        //констуктор з ініціалізацією списком
        Charge(float _e, float _q1, float _q2, float _r) : e(_e), q1(_q1), q2(_q2), r(_r) {
            check();
        }

        //конструктор копіювання
        Charge(const Charge &x) {
            q1 = x.q1;
            q2 = x.q2;
            e = x.e;
            r = x.r;
        }

        //перевантажена функція читання даних із файлу
        void read(ifstream& ifs) {
            ifs >> q1 >> q2 >> e >> r;
            check();
        }

        //перевантажена функція обчислення
        float getResult() {
            if (fabs(e * pow(r, 2)) < EPS) {
                cout << DIV_ERROR << endl;
                exit(1);
            }

            calcParam = (q1 * q2) / (e * pow(r, 2));

            return calcParam;
        }

        //перевантажена функція друкування даних у файл
        void write(ofstream& ofs) {
            ofs << "Params:" << endl;
            ofs << "q1 = " << q1 << endl;
            ofs << "q2 = " << q2 << endl;
            ofs << "e = " << e << endl;
            ofs << "r = " << r << endl;
            ofs << "Result:" << endl;
            ofs << "F = " << getResult() << endl;
            ofs << endl;
        }

        //функція для друкування параметрів і результату у консоль
        void print() {
            cout << "Params:" << endl;
            cout << "q1 = " << q1 << endl;
            cout << "q2 = " << q2 << endl;
            cout << "e = " << e << endl;
            cout << "r = " << r << endl;
            cout << "Result:" << endl;
            cout << "F = " << getResult() << endl;
            cout << endl;
        }

        //оператор ==
        bool operator == (Charge &x) {
            return getResult() == x.getResult();
        }

        //оператор !=
        bool operator != (Charge &x) {
            return getResult() != x.getResult();
        }

        //оператор <
        bool operator < (Charge &x) {
            return getResult() < x.getResult();
        }

        //оператор <=
        bool operator <= (Charge &x) {
            return getResult() <= x.getResult();
        }

        //оператор >
        bool operator > (Charge &x) {
            return getResult() > x.getResult();
        }

        //оператор >=
        bool operator >= (Charge &x) {
            return getResult() >= x.getResult();
        }
};

int main() {
    Charge a(13e-11, 1.1e-9, 2e-9, 2e-4);
    cout << "Constructor with list-initialization:" << endl;
    a.print();

    Charge b = a;
    cout << "Copy constructor:" << endl;
    b.print();

    cout << "Operator == : ";
    cout << boolalpha;
    cout << (a == b) << endl;
    cout << endl;

    cout << "Operator != : ";
    cout << boolalpha;
    cout << (a != b) << endl;
    cout << endl;

    cout << "Operator < : ";
    cout << boolalpha;
    cout << (a < b) << endl;
    cout << endl;

    cout << "Operator <= : ";
    cout << boolalpha;
    cout << (a <= b) << endl;
    cout << endl;

    cout << "Operator > : ";
    cout << boolalpha;
    cout << (a > b) << endl;
    cout << endl;

    cout << "Operator >= : ";
    cout << boolalpha;
    cout << (a >= b) << endl;
    cout << endl;

    ofstream ofs(OUTPUT_FILE);
    ifstream ifs(INPUT_FILE);

    if (ifs.is_open() == false) {
        cout << OPEN_ERROR << endl;
        exit(1);
    }

    Charge x;
    cout << "Reading from file ..." << endl;
    x.read(ifs);
    cout << endl;

    cout << "Info:" << endl;
    x.print();

    cout << "Calculating ..." << endl;
    x.getResult();
    cout << endl;

    cout << "Writing to file ..." << endl;
    x.write(ofs);

    return 0;
}