c++中文件顺序存储以及complex复数类加减乘除符号的重载，在这里输入输出符号用的友元函数

c++中文件顺序存储以及complex复数类±*/= != ,<< >>符号的重载，在这里输入输出符号用的友元函数

complex复数类相±*/并使用重载

第一次写博客，一枚在校大学生，物联网工程专业。
整个代码是我们c++的实验报告，写完收获很大，想把自己的错误，以及走过的歪路分享给大家，写的不好的地方还望大家海涵。
整体思想：
1.为了防止存储数据类型的不同，我使用了template
2.complex复数类的±*/=！= ==，并使用array类进行验证。
3.最后验证完将几个数据还有一个float类顺序存储到文件中。

上代码

下面展示一些 内联代码片。

//main函数
#include <iostream>
#include "complex.h"
#include <array>
#include <fstream>//顺序文件存储，打开文件用的
#include <cstdlib>
using namespace std;

int main()
{
    Complex<float>s1;
    Complex<float>s2;//float类型为了去调试template<typename T>
    Complex<double>arr1[1]={Complex<double>(0.0,0.0)};//数组初始化
    Complex<double>arr2[1]={Complex<double>(0.0,0.0)};//数组初始化
    Complex<double>arr3[1]={Complex<double>(0.0,0.0)};//数组初始化
    arr1[1].setReal(1.1);
    arr1[1].setImag(2.2);
    arr2[1].setReal(3.3);
    arr2[1].setImag(4.4);//直接将数据存入arr里
    cout << "       实验9"<<endl;
   
    float r1,i1,r2,i2;//定义float
    cout<<"array类已定义"<<endl;
    cout<<"输出array类+-*/的结果"<<endl;
    //对array类进行+-*/= ！=  ==进行预算
    arr3[1]=arr1[1]+arr2[1];
    cout<<"add="<<arr3[1]<<endl;
    arr3[1]=arr1[1]-arr2[1];
    cout<<"subtract="<<arr3[1]<<endl;
    arr3[1]=arr1[1]*arr2[1];
    cout<<"muitiply="<<arr3[1]<<endl;
    arr3[1]=arr1[1]/arr2[1];
    cout<<"divide="<<arr3[1]<<endl;
    arr3[1]=arr1[1];
    cout<<"arr3=arr1,arr3="<<arr3[1]<<endl;
  
    if(arr1==arr2)
    {
        cout<<"arr1==arr2"<<endl;
    }
    else
    {
        cout<<"arr1!=arr2"<<endl;
    }
    cout<<"arr1="<<arr1[1]<<endl;
    cout<<"arr2="<<arr2[1]<<endl;
    cout<<"arr3="<<arr3[1]<<endl;输出三组arr的数据
    ofstream outClientFile("clients.txt",ios::out);打开文件clients，如果没有就自动建立了一个，就算里边有内容也没有关系，下边存储的时候会自动覆盖。
    if(!outClientFile)
    {
        cerr<<"File could not be opened!"<<endl;
        exit(1);
    }//判断文件是否成功打开
    outClientFile<<arr1[1]<<endl;
    outClientFile<<arr2[1]<<endl;
    outClientFile<<arr3[1]<<endl;//将三个arr存入文件中
    cout<<"请输入两组复数(complex<float>):"<<endl;//下边是用复数float进行一个输入，用下重载的>>.
    cin>>r1>>i1;
    cin>>r2>>i2;
    //将实部虚部输入
    s1.setReal(r1);
    s1.setImag(i1);
    s2.setReal(r2);
    s2.setImag(i2);
    cout<<"将五个对象的内容存储于一个顺序文件中"<<endl;
    cout<<"3个array类，2个complex类"<<endl;
    //将float类的复数存入文件
    outClientFile<<s1<<endl;
    outClientFile<<s2<<endl;
    return 0;
}

// complex.h
#ifndef COMPLEX_H_INCLUDED
#define COMPLEX_H_INCLUDED
#include <iostream>

using namespace std;
template<typename T>//这个可以让你使用任意类的输入，不管是int，还是double
class Complex
{
    friend ostream& operator<<(ostream &output ,Complex<T> &t)
    {
        output << t.real <<" + " << t.imag <<"i";
         return output;
    }
    friend istream& operator>>(istream &input ,Complex<T> &c)
    {
        input >>c.real;
        input >>c.imag;
        return input;
    }//对输入输出进行重载，并使用友元函数
public:
    Complex(T=0.0,T=0.0);//初始化
    ~Complex();//析构函数
    void setReal(T);
    T getReal();
    void setImag(T);
    T getImag();//建立复数的实部虚部，对数据进行封装
    
    Complex operator+(Complex<T> );
    Complex operator-(Complex<T> );
    Complex operator*(Complex<T> );
    Complex operator/(Complex<T> );
    Complex operator=(Complex<T> );
    bool operator==(Complex<T> &);
    bool operator!=(Complex<T> &);
    //上边是对符号的重载
private:
    T real;
    T imag;

};
template class Complex<double>;//你的main函数里用什么类型需要提前在这里声明
template class Complex<float>;

#endif  //COMPLEX_H_INCLUDED

下面展示一些 内联代码片。

// complex.cpp
#include<iostream>
#include"complex.h"//声明我要用complex里声明的函数

using namespace std;
template<typename T>//每个函数使用前都要声明，它可以使用任何类型的数据int，double，都可以
Complex<T>::Complex(T r,T i)
{
    real=r;
    imag=i;
}//初始化
template<typename T>
Complex<T>::~Complex()
{

}//析构函数
template<typename T>
void Complex<T>::setReal(T r)
{
    real=r;
}//set实部
template<typename T>
T Complex<T>::getReal()
{
    return real;
}//get实部
template<typename T>
void Complex<T>::setImag(T i)
{
    imag=i;
}//set虚部
template<typename T>
T Complex<T>::getImag()
{
    return imag;
}get虚部
template<typename T>
Complex<T> Complex<T>::operator+(Complex<T> m)
{
    Complex temp;
    temp.real=this->real+m.real;
    temp.imag=this->imag+m.imag;
    return temp;

}//+号重载
template<typename T>
Complex<T> Complex<T>::operator-(Complex<T> m)
{
    Complex temp;
    temp.real=real-m.real;
    temp.imag=imag-m.imag;
    return temp;

}//-号重载
template<typename T>
Complex<T> Complex<T>::operator*(Complex<T> m)
{
    Complex temp;
    temp.real=real*m.real-imag*m.imag;
    temp.imag=imag*m.real+real*m.imag;
    return temp;

}//*号重载
template<typename T>
Complex<T> Complex<T>::operator/(Complex<T> m)
{
    Complex temp;
    temp.real=(real*m.real+imag*m.imag)/(m.real*m.real+m.imag*m.imag);
    temp.imag=(imag*m.real-real*m.imag)/(m.real*m.real+m.imag*m.imag);
    return temp;

}//除号重载
template<typename T>
Complex<T> Complex<T>::operator=(Complex<T> c1)
{
    real=c1.real;
    imag=c1.imag;
    return *this;//这块一定要注意，因为我前边会用到等号，但用意并不是使用重载的等号，所有这里return *this，这样会不妨碍后边使用等号的重载
}//等号重载
template<typename T>
bool Complex<T>::operator==(Complex<T> &c2)
{
    Complex temp;
    if(temp.real==c2.real&&temp.imag==c2.imag)
        return 1;
    else
        return 0;
}//==的重载
template<typename T>
bool Complex<T>::operator!=(Complex<T> &c3)
{
    Complex temp;
    if(temp.real!=c3.real)
        return 1;
    else
        return 0;
}//！=的重载

整体思路与解释，我已经写在了代码的后边，第一次写博客，小白一只，有写的不好的地方望大佬们海涵。