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;

    }

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<< 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 ;

}

//操作符重载的需求：比如数组的赋值

//难点：[] ==  !=,因为这些要返回自身的引用，和++，--不一样