c++day8 操作符重载

//操作符重载
#include <iostream>
using namespace std;

class Complex
{
public:
    int a;
    int b;
    friend Complex operator+(Complex &c1,Complex &c2);
public:
    Complex(int a=0,int b=0){
        this->a = a;
        this->b = b;
    }
    void printCom(){
        cout<<a<<"  +"<<b<<"i"<<endl;
    }
    Complex operator-(Complex &c2)
    {
        Complex tmp(this->a - c2.a,this->b - c2.b);
        
        return tmp;
    }
    Complex operator--(int){
        //return c1;先使用再++
        Complex tmp  = *this;//这一句很关键
        this->a--;
        this->b--;
        
        return tmp;
    }
protected:
private:

};
    Complex operator+(Complex &c1,Complex &c2)
    {
        Complex tmp(c1.a+c2.a,c1.b+c2.b);
        return tmp;
    }
    //重载前置++
Complex & operator++(Complex &c1){
    c1.a++;
    c1.b++;
    return c1;
}
Complex & operator--(Complex &c1){
    c1.a--;
    c1.b--;
    return c1;
}

//后置++，这里先返回元素,这里就涉及到了占位符知识
Complex operator++(Complex &c1,int){
        //return c1;先使用再++
        Complex tmp  = c1;
        c1.a++;
        c1.b++;
        
        return tmp;
    }

void main(){

    Complex c1(1,2),c2(3,4);
    Complex c3  = c1+c2;
    c3.printCom();
    //1.全局函数实现
    //operator+(Complex &c1,Complex &c2);

    //2.成员函数实现- 运算符重载
    //c1.operator-(this,c2);this指针可以隐藏
    //Complex operator-(Complex &c2)
    
    c3=c1-c2;
    c3.printCom();

    //前置++操作符  用全局函数实现
    //Complex & operator++(Complex &c1)
    

    ++c1;
    c1.printCom();

    //前置--
    --c1;
    c1.printCom();

    //后置++

    c1++;
    c1.printCom();

    //后置--.用成员函数实现
    c1--;
    c1.printCom();
    //c1.operator--();

 

    cout<<"hello"<<endl;
    system("pause");
    return ;
}

//但是一般用的是成员函数
//友元函数实现运算符重载的应用场景
//重载左移操作符<<
//友元函数多用于实现运算符的左右操作类型不同的情形

#include <iostream>
using namespace std;

class Complex
{
public:
    int a;
    int b;
    friend ostream& operator<<(ostream &out,Complex &c1);
public:
    Complex(int a=0,int b=0){
        this->a = a;
        this->b = b;
    }
    void printCom(){
        cout<<a<<"  +"<<b<<"i"<<endl;
    }
    Complex operator-(Complex &c2)
    {
        Complex tmp(this->a - c2.a,this->b - c2.b);
        
        return tmp;
    }
    Complex operator--(int){
        //return c1;先使用再++
        Complex tmp  = *this;//这一句很关键
        this->a--;
        this->b--;
        
        return tmp;
    }
        Complex operator+(Complex &c2)
    {
        Complex tmp(this->a+c2.a,this->b+c2.b);
        return tmp;
    }
    

    //重载前置++
Complex & operator++(){
    this->a++;
    this->b++;
    return *this;
}
Complex & operator--(){
    this->a--;
    this->b--;
    return *this;
}

//后置++，这里先返回元素,这里就涉及到了占位符知识
Complex operator++(int){
        //return c1;先使用再++
        Complex tmp  = *this;
        this->a++;
        this->b++;
        
        return tmp;
    }
/*Complex operator+(Complex &c1){
        //return c1;先使用再++
        
        this->a = this->a + c1.a;
        this->b = this->b + c1.b;
        return *this;
    }*/

protected:
private:

};

//注意，这个&符号很重要，如果没有就会出现冲突定义
ostream & operator<<(ostream &out,Complex &c1){

    out<<c1.a<<"+"<<c1.b<<"i"<<endl;
    return out;
}
void main(){

    Complex c1(1,2),c2(3,4);
    Complex c3  = c1+c2;
    c3.printCom();
    //1.全局函数实现
    //operator+(Complex &c1,Complex &c2);

    //2.成员函数实现- 运算符重载
    //c1.operator-(this,c2);this指针可以隐藏
    //Complex operator-(Complex &c2)
    
    c3=c1-c2;
    c3.printCom();

    //前置++操作符  用全局函数实现
    //Complex & operator++(Complex &c1)
    

    ++c1;
    c1.printCom();

    //前置--
    --c1;
    c1.printCom();

    //后置++

    c1++;
    c1.printCom();

    //后置--.用成员函数实现
    c1--;
    c1.printCom();
    //c1.operator--();

    int a =10;
    Complex c6(5,6);
    cout<<a<<endl;

    //步骤1，先写测试案例
    cout<<c6;
    //2 在ostream类中添加成员函数 .operator<<
    //成员函数实现
    //operator<<(ostream &out,Complex &c1)
    //cout.operator<<(c1);其实ostream你是拿不到的。友元函数多用于实现这种情况

    //cout<< c6 <<"Aaaaaa"<<endl;注意这里报错，提示左边需要void类型
/*    cout.operator(c6).operator;
    Aaaaaa.operator("aaaa");
    这两句就是上面实际的调用方式，函数左值需要返回引用，才能实现链式编程
    */
    cout<< c6 <<"Aaaaaa"<<endl;
    //细心看，这句语句有不同。
    cout<<"hello"<<endl;
    system("pause");
    return ;
}

//友元函数没有this指针，所需操作数都必须在参数表显式声明，很容易实现类型的yinshizhuanhuan
//C++中不能用友元函数重载的运算符有= ，[],->

#include <iostream>
using namespace std;

class Name
{
public:
    int mlen;
    char *mspace;
    Name(const char *myp)
    {
        mlen = strlen(myp);
        mspace  = (char * )malloc(mlen+1);
        strcpy(mspace,myp);
        cout<<"调用构造函数"<<endl;
    }
    //自定义深拷贝
    Name (const Name &obj1)
    {
        mlen = obj1.mlen;
        mspace = (char * )malloc(mlen+1);
        strcpy(mspace,obj1.mspace);
        cout<<"调用深拷贝构造函数"<<endl;
    }
        //obj2.operator=(obj2);
    Name operator=(Name &obj){
        if(mspace != NULL){
            delete[] mspace;//1.先把旧的内存释放
            mlen = 0;
        }
        //2.根据obj1分配内存
        this->mlen = obj.mlen;
        //    this->mspace  = (char *)malloc(strlen(obj.mspace)+1);
        this->mspace = new char[mlen + 1];

        //3.把obj1赋值
        strcpy(this->mspace,obj.mspace);
        cout<<"调用=操作符重载"<<endl;
        return *this;
    }
    ~Name(){
        if(mspace != NULL){
            cout<<"调用析构函数"<<endl;
            delete(mspace);
        }
    }
public:
protected:
private:

};
void viewLife(){
        Name obj1("avc");
        Name obj2("csa");
        Name obj3("yj");
        obj2 = obj1;//C++编译提供的等号操作也属于浅拷贝
        obj3 = obj2 = obj1;//等号操作符，从右到左的顺序
        

}

void main(){
    viewLife();
    
    cout<<"hello"<<endl;
    system("pause");
    return ;
}

//操作符重载的需求：比如数组的赋值
//难点：[] ==  !=,因为这些要返回自身的引用，和++，--不一样