2017C++基础——网课笔记（59到62）

五十九. 友元类和友元的关系性质

#include <iostream>

using namespace std;

class A
{
public:
    A(int a){
        this->a = a;
    }

    void printA(){
        cout<<"a= "<<this->a<<endl;
    }
    //声明一个友元类B
    friend class B;

private:
    int a;

};

class B
{
public:
    B(int b){
        this->b =b;
    }
    void printB(){
        A objA(100);
        cout<<objA.a<<endl;
        cout<<"b= "<<this->b<<endl;
    }
private:
    int b;
};

int main()
{
    B bobj(200);
    bobj.printB();
    return 0;
}

友元和友类的重要关系性质

六十. 操作符重载的基本语法

#include <iostream>

using namespace std;

class Complex
{
public:
    Complex(int a,int b)
    {
        this->a = a;
        this->b = b;
    }

    void printComplex()
    {
        cout<<"("<<this->a<<","<<this->b<<"i)"<<endl;
    }

    //friend Complex complexAdd(Complex &c1,Complex &c2);
    //friend Complex operator+ (Complex &c1, Complex &c2);

    Complex CompleAdd2(Complex & another)
    {
        Complex temp(this->a+ another.a, this->b+another.b);
        return temp;
    }

    Complex operator+ (Complex &another) //注意operator与后面的操作符，必须中间没有空格，视operator为一个函数
    {
        Complex temp(this->a+ another.a, this->b+another.b);
        return temp;
    }

private:
    int a;
    int b;
};

#if 0
Complex complexAdd(Complex &c1,Complex &c2)
{
    Complex temp(c1.a+c2.a,c1.b+c2.b);
    return temp;
}
#endif

#if 0
//操作符重载写在全局
Complex operator+ (Complex &c1, Complex &c2) //注意operator与后面的操作符，必须中间没有空格，视operator为一个函数
{
    Complex temp(c1.a+ c2.a, c1.b+c2.b);
    return temp;
}
#endif


int main()
{
    Complex c1(1,2);
    Complex c2(2,4);

    c1.printComplex();
    c2.printComplex();

    //Complex c3=complexAdd(c1,c2);
    //Complex c3= c1+c2; //操作符重载写在全局，调用方法1
    //Complex c3 = operator+(c1,c2); //操作符重载写在全局，调用方法2

    //Complex c3= c1+c2; //操作符重载写在类中，调用方法1
    Complex c3= c1.operator+(c2); //操作符重载写在类中，调用方法2


    c3.printComplex();
    return 0;
}

六十一. 操作符重载的规则

六十二. 单目和双目运算符重载

#include <iostream>

using namespace std;

class Complex
{
public:
    Complex(int a,int b)
    {
        this->a = a;
        this->b = b;
    }

    void printComplex()
    {
        cout<<"("<<this->a<<","<<this->b<<"i)"<<endl;
    }

    //friend Complex complexAdd(Complex &c1,Complex &c2);
    //friend Complex operator+ (Complex &c1, Complex &c2);

    Complex CompleAdd2(Complex & another)
    {
        Complex temp(this->a+ another.a, this->b+another.b);
        return temp;
    }

    Complex operator+ (Complex &another) //注意operator与后面的操作符，必须中间没有空格，视operator为一个函数
    {
        Complex temp(this->a+ another.a, this->b+another.b);
        return temp;
    }

    Complex& operator- (Complex & another)
    {
        this->a -= another.a;
        this->b -= another.b;
        return *this;
    }

    Complex & operator++()//重载的是前++运算符，类中实现
    {
        this->a ++;
        this->b ++;

        return *this;
    }

    const Complex operator++(int) //重载的是后++运算符，类中实现，亚元
    {
        Complex temp(this->a,this->b);
        this->a++;
        this->b++;
        return temp;
    }
    //friend Complex & operator++(Complex & c);
    //friend const Complex operator++(Complex & c1,int);
private:
    int a;
    int b;
};

#if 0
//重载的是前++运算符，全局实现
Complex & operator++(Complex & c)
{
    c.a++;
    c.b++;
    return c;
}

//重载的是后++运算符，全局实现
const Complex operator++(Complex & c1,int)
{
    Complex temp(c1.a,c1.b);

    c1.a++;
    c1.b++;

    return temp;
}
#endif // 0


int main()
{
    Complex c1(1,2);
    Complex c2(2,4);

    c1.printComplex();
    c2.printComplex();

    c1++;
    c1.printComplex();

    return 0;
}