Работа с массивом программ комплексных чисел

Question

Я пытаюсь создать программу, которая работает с массивами комплексных чисел, в моей программе есть два класса: класс, представляющий комплексные числа, и класс, представляющий массив.

Вот код, который я создал до сих пор:

Complex.h

#pragma once
#include <functional>

class Complex
{
    friend class Array;
    double re, im;
    friend std::ostream& operator<<(std::ostream&, const Array&);
    friend std::istream& operator>>(std::istream&, Array&);

public:
    double getRe() const;
    double getIm() const;
    void setRe(double);
    void setIm(double);
    Complex operator[](int);
    Complex operator=(const Complex&);
    Complex operator+(const Complex&);
    Complex operator-(const Complex&);

private:
    Complex apply(const Complex&, const std::function <double(double, double)> &);
};

Array.h

#pragma once
#include "Complex.h" 
#include <functional>

class Array
{
    Complex *arr;
    int n;
    friend std::ostream& operator<<(std::ostream&, const Array&);
    friend std::istream& operator>>(std::istream&, Array&);

public:
    Array();
    Array(int);
    Array(const Array&);
    Array(Array&&);
    ~Array();
    Array& operator=(const Array&);
    Array& operator=(Array &&);
    Array operator+(const Array&);
//  Array operator-(const Array&);

private:
    Array& copy(Array&);
    Array& move(Array&);
    Array compute(const Array &,const std::function<Complex(Complex, Complex)> &f);

};

Complex.cpp

#include <iostream>
#include "Complex.h"

double Complex::getRe() const
{
    return re;
}

double Complex::getIm() const
{
    return im;
}

void Complex::setRe(double re)
{
    this->re = re;
}

void Complex::setIm(double im)
{
    this->im = im;

}
Complex Complex::operator[](int i)
{   
    Complex temp;
    temp.re = re;
    temp.im = im;

    return temp;
}

Complex Complex::operator=(const Complex &c)
{
    re = c.re;
    im = c.im;
    return *this;
}

Complex Complex::operator+(const Complex &c)
{
    *this = apply(c, [](double x, double y) { return x + y; });
    return *this;
}

Complex Complex::operator-(const Complex &c)
{
    *this = apply(c, [](double x, double y) { return x - y; });
    return *this;
}



Complex Complex::apply(const Complex &c, const std::function<double(double, double)> &f)
{
    re = re + c.re;
    im = im + c.im;

    return *this;
}

Array.cpp

Array::Array(int n)
{
    this->n = n;
    arr = new Complex[n];
}

Array::Array(const Array &a)
{
    this->n = a.n;
    arr = new Complex[n];
    arr = a.arr;
}

Array::Array(Array &&a)
{
    this->n = a.n;
    arr = a.arr;
    a.arr = nullptr;
}

Array& Array::operator=(const Array &a)
{
    this->n = a.n;
    arr = new Complex[n];
    arr = a.arr;
    return *this;
}

Array& Array::operator=(Array &&a)
{
    this->n = n;
    this->arr = a.arr;
    a.arr = nullptr;  
    return *this;
}

std::ostream& operator<<(std::ostream& out, const Array &a)
{
    for (int i = 0; i < a.n; i++)
        out << a.arr[i].re << " +i" << a.arr[i].im;
    return out;
}

std::istream& operator>>(std::istream& in, Array &a)
{
    for (int i = 0; i < a.n; i++)
        in >> a.arr[i].re >> a.arr[i].im;   
    return in;
}

Array Array::operator+(const Array &a)            
{
    return compute(a, [](Complex x, Complex y) { return x + y; });

}
/*
Array Array::operator-(const Array &a)         
{
    return compute(a, [](Complex x, Complex y) { return x - y; });    
}
*/
Array Array::compute(const Array &a,const std::function<Complex(Complex , Complex)> &f)
{ 
    for (int i = 0; i < n; i++)
       arr[i] = f(arr[i], a.arr[i]);



    return *this;

}

Array::~Array()
{

    delete[] arr;
    n = 0;
}

Source.cpp

#include <iostream>
#include "Array.h"
#include "Complex.h"


int main()
{

    Array a(2);       
    std::cin >> a;
    Array b;         
    b = a;          
    Array c(2);      
    c = a + b;
    std::cout << c;

    getchar();
    getchar();
}

Итак, это то, что у меня есть на данный момент, я должен добавить, что раньше это работало очень хорошо, когда в моем классе Complex у меня были только сеттеры,getters, эти поля и Array класс как друг, что означает, что я делал индексирование "вручную" и выполнял операции + и - без перегрузки соответствующих операторов в Complex классе.

ОднакоУ меня была идея, что было бы лучше (и больше в духе упа) перегружать операторы, которые мне нужны для класса Complex, так как код был бы более читабельным.

Однако, хотя я получаюрезультат мне нужен, каждый раз после выполнения прогиram, когда я нажимаю ввод, появляется ошибка с деструктором, я пробовал отладку, и мне кажется, что проблема возникает, когда объект Array b «разрушен», но я не мог понять, что на самом деле происходит (и действительно ли b вызываетпроблема в первую очередь).

ПРИМЕЧАНИЕ: я нашел здесь несколько вопросов, связанных со сложными массивами, но ни один из них не решил мою проблему.

Любая помощь приветствуется!