2024/4/26 C++day4

1在Complex类的基础上，完成^，>>，<<,~运算符的重载

#include <iostream>
using namespace std;
class Complex
{
    int rel;    //实部
    int vir;    //虚部
public:
    Complex(){}
    Complex(int rel,int vir):rel(rel),vir(vir){}
    void show()
    {
        cout << this->rel << "+" << this->vir << "i" << endl;
    }
    friend Complex operator-(const Complex c1,const Complex c2);
    friend Complex operator/(const Complex c1,const Complex c2);
    friend bool operator==(const Complex c1,const Complex c2);
    friend Complex operator++(Complex &c1,int);
    friend ostream &operator<<(ostream &out,Complex c1);
    friend istream &operator>>(istream &in,Complex &c1);
    Complex operator~() const {  
       
          return Complex(-rel, -vir);  
      } 
    Complex operator^(const Complex& other) const {  
           // 实部相减，虚部相加  
           return Complex(rel - other.rel, vir + other.vir);  
       }  
    //成员函数版实现+运算符重载
    Complex operator+(const Complex c1);
    //成员函数版实现*运算符重载
    Complex operator*(const Complex c1);
    //成员函数版%运算符重载
    Complex operator%(const Complex c1);
    //         <<
    friend ostream &operator<<(ostream &out,Complex c1);
    //         >>
    friend istream &operator>>(istream &in,Complex c2);
    //成员函数版>运算符重载
    bool operator>(const Complex c1);
    bool operator!();
    //成员函数版的前自增运算重载,单目运算符，成员函数版运算符重载无需传参
    Complex operator++()
    {
        ++this->rel;
        ++this->vir;
        return *this;
    }
    //成员函数版()运算符的重载
    operator int()
    {
        return this->rel;
    }
//    operator double()
//    {
//        return 0.9;
//    }
//    operator char()
//    {
//        return 'a';
//    }
    
    //使用operator()实现仿函数的功能
    int operator()(int a,int b)
    {
        return  a>b?a:b;
    }
    void operator()()
    {
        cout << "这是一个仿函数" << endl;
    }
};
//成员函数版的！运算符重载
bool Complex::operator!()
{
    return !(this->rel||this->vir);
}
bool Complex::operator>(const Complex c1)
{
    return this->rel>c1.rel;
}
ostream &operator<<(ostream &out,Complex c1){
    out<<c1.rel<<"+"<<c1.vir<<"i"<<endl;
    return out;
}
istream &operator>>(istream &in,Complex c2){
    in>>c2.rel>>c2.vir;
    return in;
}
Complex Complex::operator%(const Complex c1)
{
    Complex temp;
    temp.rel = this->rel%c1.rel;
    temp.vir = this->vir%c1.vir;
    return temp;
}
Complex Complex::operator*(const Complex c1)
{
    Complex temp;
    temp.rel = this->rel*c1.rel;
    temp.vir = this->vir*c1.vir;
    return temp;
}
Complex Complex::operator+(const Complex c1)
{
    //实例化了一个temp类对象，并调用了有参构造
    //Complex temp(this->rel+c1.rel,this->vir+c1.vir);
    Complex temp;
    temp.rel = this->rel+c1.rel;
    temp.vir = this->vir+c1.vir;
    return temp;
}
//全局函数版本的-运算符重载
Complex operator-(const Complex c1,const Complex c2)
{
    //实例化一个类对象，用于返回运算后的结果
    Complex temp;
    temp.rel = c1.rel-c2.rel;
    temp.vir = c1.vir-c2.vir;
    return temp;
}
//全局函数版/运算符重载
Complex operator/(const Complex c1,const Complex c2)
{
    Complex temp;
    temp.rel = c1.rel/c2.rel;
    temp.vir = c1.vir/c2.vir;
    return temp;
}
//全局函数版本==运算符重载
bool operator==(const Complex c1,const Complex c2)
{
    return c1.rel==c2.rel&&c1.vir==c2.vir;
}
//全局函数版后自增运算符重载
Complex operator++(Complex &c1,int)
{
    Complex temp(c1.rel++,c1.vir++);
    return temp;
}
//全局函数版<<运算符重载,
//参数是ostream类对象的引用，返回值也是ostream类对象的引用
ostream &operator<<(ostream &out,Complex c1)
{
    out << c1.rel << "+" << c1.vir << "i" << endl;
    return out;
}
//全局函数版>>运算符重载,传类对象的引用，因为需要把输入保存在类对象中
istream &operator>>(istream &in,Complex &c1)
{
    in >> c1.rel >>c1.vir;
    return in;
}

1. 在昨天作业myString类的基础上，完成+、关系运算符、逻辑运算符、输入输出运算符的重载

#include <iostream>
#include <cstring>
using namespace std;
class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //运算符重载
        friend myString operator+(const myString s1,const myString s2);//+
        friend ostream &operator<<(ostream &out,myString s1);//左移
        friend istream &operator>>(istream &in,myString &s1);//右移
        //>、<、==、!=关系运算符重载
        friend bool operator>(const myString s1,const myString s2);
        friend bool operator<(const myString s1,const myString s2);
        friend bool operator==(const myString s1,const myString s2);
        friend bool operator!=(const myString s1,const myString s2);
        
        //无参构造
        myString() : str(new char[1]), size(0)
        {
            str[0] = '\0';
            //cout<<"无参构造"<<endl;
        }
        //有参构造
        myString(const char* s)
        {
            size = strlen(s);
            str = new char[size + 1];
            strcpy(str, s);
            //cout<<"有参构造"<<endl;
        }
        myString(string s1)
        {
            size = s1.size();
            str = new char[size + 1];
            strcpy(str, s1.c_str());
           // cout<<"有参构造"<<endl;
        }
        //拷贝构造
        myString(const myString &other)
        {
            size = other.size;
            str = new char[size + 1];
            strcpy(str, other.str);
            //cout<<"拷贝构造"<<endl;
        }
        //拷贝赋值函数
        myString& operator=(const myString &other)
        {
             if (this != &other) {
                 delete[] str;
                 size = other.size;
                 str = new char[size + 1];
                 strcpy(str, other.str);
                 //cout<<"拷贝赋值"<<endl;
             }
             return *this;
         }
        //析构函数
        ~myString()
        {
               delete[] str;
            //cout<<"析构"<<endl;
           }
        //判空函数
        bool empty()
        {
            return size==0;
 
        }
        //size函数
        void mysize()
        {
            cout<<"size = "<<size<<endl;
        }
        //c_str函数
        char* c_str()
        {
            return str;
        }
        //at函数
        char &at(int pos)
        {
            if (pos < 0 || pos >= size) {
                cout<<"位置不合法"<<endl;
            }
            return str[pos];
        }
    
};
//+
myString operator+(const myString s1,const myString s2)
{
    myString temp;
    temp.size = s1.size+s2.size;
    temp.str=strcpy(temp.str,strcat(s1.str,s2.str));
    return temp;
}

//左移运算符重载
ostream &operator<<(ostream &out,myString s1)
{
    out<< s1.str <<"  "<<s1.size;
    return cout;
}
//右移运算符重载
istream &operator>>(istream &in,myString &s1)
{
    string s;
    in>>s;
    s1.size = s.size();
    strcpy(s1.str, s.c_str());
 
    return cin;
}
bool operator>(const myString s1,const myString s2)
{
    string s3 =s1.str;
    string s4 =s2.str;
    return s3>s4;
}
bool operator<(const myString s1,const myString s2)
{
    string s3 =s1.str;
    string s4 =s2.str;
    return s3<s4;
}
bool operator==(const myString s1,const myString s2)
{
    string s3 =s1.str;
    string s4 =s2.str;
    return s3==s4;
}
bool operator!=(const myString s1,const myString s2)
{
    string s3 =s1.str;
    string s4 =s2.str;
    return s3!=s4;
}