Скачиваний:
34
Добавлен:
10.09.2019
Размер:
9.49 Кб
Скачать
#include <iostream>
#include <cmath>
#include <stdexcept>

using std::cin;
using std::cout;
using std::endl;

template <class T>
class Complex {
 public:
    T re, im;

    // Конструктор
    explicit Complex(T re = 0, T im = 0) : re(re), im(im) {}

    // --------------------------------------
    // Комплексные числа

    // Оператор смены знака комплексного числа
    Complex operator-() const {
        return Complex(-re, -im);
    }

    // Оператор сложения комплексных чисел
    Complex operator+(const Complex &arg) const {
        return Complex(re + arg.re, im + arg.im);
    }

    // Оператор сложения комплексных чисел и присваивания
    Complex &operator+=(const Complex &arg) {
        re = re + arg.re;
        im = im + arg.im;
        return *this;
    }

    // Оператор вычитания комплексных чисел
    Complex operator-(const Complex &arg) const {
        return Complex(re - arg.re, im - arg.im);
    }

    // Оператор вычитания комплексных чисел и присваивания
    Complex &operator-=(const Complex &arg) {
        re = re - arg.re;
        im = im - arg.im;
        return *this;
    }

    // Оператор умножения комплексных чисел
    Complex operator*(const Complex &arg) const {
        return Complex(re * arg.re - im * arg.im, re * arg.im + im * arg.re);
    }

    // Оператор умножения комплексных чисел и присваивания
    Complex &operator*=(const Complex &arg) {
        T copy_re = re;
        re = re * arg.re - im * arg.im;
        im = copy_re * arg.im + im * arg.re;
        return *this;
    }

    // Оператор деления комплексных чисел
    Complex operator/(const Complex &arg) const {
        return Complex(( re * arg.re - im * arg.im ) / ( arg.re * arg.re + arg.im * arg.im ),
                       ( im * arg.re - re * arg.im ) / ( arg.re * arg.re + arg.im * arg.im ));
    }

    // Оператор деления комплексных чисел и присваивания
    Complex &operator/=(const Complex &arg) {
        T copy_re = re;
        re = ( re * arg.re - im * arg.im ) / ( arg.re * arg.re + arg.im * arg.im );
        im = ( im * arg.re - copy_re * arg.im ) / ( arg.re * arg.re + arg.im * arg.im );
        return *this;
    }

    // Оператор == сравнения комплексных чисел
    bool operator==(const Complex &arg) const {
        return re == arg.re && im == arg.im;
    }

    // Оператор != сравнения комплексных чисел
    bool operator!=(const Complex &arg) const {
        return !( operator==(arg) );
    }

    // --------------------------------------
    // Комплексные и вещественные числа

    // Оператор сложения комплексного и вещественного чисел
    Complex operator+(const T &d) const {
        return Complex(re + d, im);
    }

    // Оператор сложения вещественного и комплексного  чисел
    friend Complex operator+(const T &d, const Complex &comp) {
        return Complex(d + comp.re, comp.im);
    }

    // Оператор сложения комплексного и вещественного чисел и присваивания
    Complex &operator+=(const T &d) {
        re = re + d;
        return *this;
    }

    // Оператор вычитания комплексного и вещественного чисел
    Complex operator-(const T &d) const {
        return Complex(re - d, im);
    }

    // Оператор вычитания вещественного и комплексного чисел
    friend Complex operator-(const T &d, const Complex &comp) {
        return Complex(d - comp.re, -comp.im);
    }

    // Оператор вычитания комплексного и вещественного чисел и присваивания
    Complex &operator-=(const T &d) {
        re = re - d;
        return *this;
    }

    // Оператор умножения комплексного и вещественного чисел
    Complex operator*(const T &d) const {
        return Complex(re * d, im * d);
    }

    // Оператор умножения вещественного и комплексного чисел
    friend Complex operator*(const T &d, const Complex &comp) {
        return Complex(d * comp.re, d * comp.im);
    }

    // Оператор умножения комплексного и вещественного чисел и присваивания
    Complex &operator*=(const T &d) {
        re = re * d;
        im = im * d;
        return *this;
    }

    // Оператор деления комплексного и вещественного чисел
    Complex operator/(const T &d) const {
        return Complex(re / d, im / d);
    }

    // Оператор деления вещественного и комплексного чисел
    friend Complex operator/(const T &d, const Complex &comp) {
        return Complex(( comp.re * d ) / ( comp.re * comp.re + comp.im * comp.im ),
                       ( -comp.im * d ) / ( comp.re * comp.re + comp.im * comp.im ));
    }

    // Оператор деления комплексного и вещественного чисел и присваивания
    Complex &operator/=(const T &d) {
        re = re / d;
        im = im / d;
        return *this;
    }

    // Оператор == сравнения комплексного и вещественного чисел
    bool operator==(const T &d) const {
        return re == d && im == 0;
    }

    // Оператор != сравнения комплексного и вещественного чисел
    bool operator!=(const T &d) const {
        return !( operator==(d) );
    }

    // Оператор приведения к типу bool
    explicit operator bool() {
        return re != 0 || im != 0;
    }

    // Модуль комплексного числа
    T module() const {
        return sqrt(re * re + im * im);
    }

    // ---------------------
    // Дружественные функции и операторы

    // Дружественный оператор для вывода комплексных чисел в выходной поток os (cout, ...)
    friend std::ostream &operator<<(std::ostream &os, const Complex &arg) {
        return os << '(' << arg.re << ( arg.im >= 0 ? " + " : " - " ) << std::abs(arg.im) << "i)";
    }
};

int main() {
    Complex<double> compA(rand() % 10, rand() % 10); // Вызов конструктора
    Complex<double> compB(rand() % 10, rand() % 10); // Вызов конструктора
    cout << "Complex A: " << compA << endl;
    cout << "-Complex A: " << -compA << endl;
    cout << "module(Complex A): " << compA.module() << endl;
    cout << "Complex B: " << compB << endl;
    cout << "-Complex B: " << -compB << endl;
    cout << "module(Complex B): " << compB.module() << endl;
    Complex<double> compA_add_B(compA); // Вызов конструктора копирования
    compA_add_B += compB;
    Complex<double> compA_sub_B(compA); // Вызов конструктора копирования
    compA_sub_B -= compB;
    Complex<double> compA_mul_B(compA); // Вызов конструктора копирования
    compA_mul_B *= compB;
    Complex<double> compA_div_B(compA); // Вызов конструктора копирования
    compA_div_B /= compB;
    cout << "Complex A + Complex B: " << compA + compB << " (" << compA_add_B << ")\n";
    cout << "Complex A - Complex B: " << compA - compB << " (" << compA_sub_B << ")\n";
    cout << "Complex A * Complex B: " << compA * compB << " (" << compA_mul_B << ")\n";
    cout << "Complex A / Complex B: " << compA / compB << " (" << compA_div_B << ")\n";
    Complex<double> compC = compA; // Вызов оператора копирования
    cout << "Complex C: " << compC << endl;
    cout << "Complex A == Complex C: " << ( compA == compC ) << endl;
    cout << "Complex B != Complex C: " << ( compB != compC ) << endl << endl;
    cout << "Complex A + 55: " << compA + 55 << " (= 55 + Complex A = " << 55 + compA << ")\n";
    cout << "Complex A - 55: " << compA - 55 << " (= -(55 - Complex A) = " << -( 55 - compA ) << ")\n";
    cout << "Complex A * 2: " << compA * 2 << " (= 2 * Complex A = " << 2 * compA << ")\n";
    cout << "Complex A / 2: " << compA / 2 << endl;
    cout << "2 / ComplexA: " << 2 / compA << endl;
    cout << "Complex " << Complex<double>(128, 0) << " == " << 128 << " ? " << ( Complex<double>(128, 0) == 128 )
         << endl;
    cout << "Complex " << Complex<double>(128, 0) << " != " << 127 << " ? " << ( Complex<double>(128, 0) != 127 )
         << endl;
    cout << "Bool (1 + 0i): " << bool(Complex<double>(1, 0)) << endl;
    cout << "Bool (0 + 0i): " << bool(Complex<double>(0, 0)) << endl;
}
Соседние файлы в папке Решения лабораторных работ (местами есть ошибки)