c++（8.24）拷贝赋值对象，匿名对象，友元，常成员和常对象，mutable关键字，运算符重载

作业：

实现关系运算符重载（仅>,<,==）：

#include <iostream>

using namespace std;

class Person
{
    int a;
    int b;
   friend bool operator== (const Person &L,const Person&R);
public:
    Person(){}
    Person(int a,int b):a(a),b(b){}
    bool operator> (const Person&R)const
    {
        if(a>R.a&&b>R.b)
        {

            return true;
        }
        else
        {

            return false;
        }
    }
    bool operator< (const Person&R)const
    {
        if(a<R.a&&b<R.b)
        {

            return true;
        }
        else
        {

            return false;
        }
    }
};
bool operator== (const Person &L,const Person&R)
{
    if(L.a==R.a&&L.b==R.b)
    {

        return true;
    }
    else
    {

        return false;
    }
}

int main()
{
    Person p1(10,10),p2(10,10),p3(20,20);
    if((p1>p2)==true)
    {
        cout << "p1大于p2" << endl;
    }
    else
        cout << "p1不大于p2" << endl;
    if((p1==p2)==true)
    {
        cout << "p1等于p2" << endl;
    }
    else
        cout << "p1不等于p2" << endl;
    if((p1<p2)==true)
    {
        cout << "p1小于p2" << endl;
    }
    else
        cout << "p1不小于p2" << endl;
    if((p2>p3)==true)
    {
        cout << "p2大于p3" << endl;
    }
    else
        cout << "p2不大于p3" << endl;
    if((p2==p3)==true)
    {
        cout << "p2等于p3" << endl;
    }
    else
        cout << "p2不等于p3" << endl;
    if((p2<p3)==true)
    {
        cout << "p2小于p3" << endl;
    }
    else
        cout << "p2不小于p3" << endl;
    return 0;
}

拷贝赋值函数实例：

#include <iostream>

using namespace std;
class stu
{
    string name;
    int age;
public:
    void show ()
    {
        cout << name << age << endl;
    }
    stu(string name,int age):name(name),age(age)
    {
        cout << "这是stu的构造函数" << endl;
    }
    stu(stu &other):name(other.name),age(other.age)//构造函数，需要初始化列表
    {
        cout << "这是stu的拷贝构造函数" << endl;
    }
    stu& operator=(const stu& other)//拷贝赋值函数，不需要初始化列表
    {
        if(this != &other)//避免自己被赋值给自己
        {
            name=other.name;
            age=other.age;
        }
            cout <<"这是stu的拷贝赋值函数"  << endl;
            return *this;
    }
    ~stu()
    {
        cout << "这是stu的析构函数" << endl;
    }
};

int main()
{
    stu s1("张三",20);
    stu s2=s1;
    stu s3("",0);
    s3=s2;
    return 0;
}

 

 匿名对象实例：

#include <iostream>

using namespace std;
class stu
{
    string name;
    int age;
public:
    stu(string name,int age):name(name),age(age)
    {
        cout << "这是stu的构造函数" << endl;
    }
    stu(const stu& other):name(other.name),age(other.age)
    {
        cout << "这是stu的拷贝构造函数" << endl;
    }
    stu& operator=(const stu& other)
    {
        name=other.name;
        age=other.age;
        return *this;
    }
    ~stu()
    {
        cout <<"这是stu的析构函数" << endl;
    }
};

int main()
{
    stu s1=stu("张三",20);//用匿名类做赋值操作
    stu s[3]={stu("a",1),stu("b",2),stu("c",3)};//用匿名类做类数组的赋值操作
    return 0;
}

 友元实例:

#include <iostream>

using namespace std;

class Room
{
    friend void good(Room &s);//声明good函数是友元函数，就可以调用本类中的所有成员
    friend class bad;//声明bad类是友元，bad类就可以调用本类中的所有成员
    string badroom;
public:
    string livingroom;
    Room(string badroom,string livingroom):badroom(badroom),livingroom(livingroom)
    {
        cout<< "这是Room的构造函数" << endl;
    }
    Room()//无参构造
    {}
};
void good(Room &s)
{
    cout << s.livingroom << endl;
    cout << s.badroom <<endl;
}
class bad
{
public:
    Room s1;
    void visit()
    {
        cout << s1.badroom << endl;//调用s1中的私有成员
        cout << s1.livingroom <<endl;
    }

};

int main()
{
    Room s("卧室","客厅");
    good(s);
    bad a;
    return 0;
}

常成员和常对象实例:

#include <iostream>

using namespace std;

class Stu
{
    string name;
    mutable int age;//加了mutable，就可以在常成员函数中修改
public:
    Stu()//无参构造函数
    {}
    Stu(string n,int a):name(n),age(a)//有参构造类型
    { }
    void show()const//常成员函数，不做修改
    {
        age=30;//会报错，因为是const类型的成员函数，不能做修改,当age加了mutable，就变成可以在常成员函数中修改
        cout << "名字是:" << name << endl;
        cout << "年龄是:" << age << endl;
    }
    void show()//非常成员函数
    {
        age=25;
        cout << "名字是:" << name << endl;
        cout << "年龄是:" << age << endl;
    }
};

int main()
{
    Stu s1("张三",18);//非常对象
    s1.show();//有常成员函数和非常成员函数，优先调用非常成员函数，只有常成员函数，调用常成员函数
    const Stu s2("里斯",20);//常对象
    s2.show();//调用常成员函数，年龄不会发生改变
    //当只有非常成员函数时，s2无法调用非常成员函数
    return 0;
}

算数运算符重载:

 

#include <iostream>

using namespace std;

class Person
{
    friend const Person operator+(const Person &L,const Person &R);
    friend const Person operator>(const Person &L,const Person &R);
    int a;
    int b;
public:
    Person(){};
    Person(int a,int b):a(a),b(b)
    {}
//    const Person operator+(const Person &R)
//    {
//        Person temp;
//        temp.a=a+R.a;
//        temp.b=b+R.b;
//        return temp;
//    }
    void show()
    {
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
    }
};
const Person operator+(const Person &L,const Person &R)//全局
{
    Person temp;
    temp.a = L.a + R.a;
    temp.b = L.b + R.b;
    return temp;
}
const Person operator>(const Person &L,const Person &R)
{
    Person temp;
    temp.a = (L.a > R.a) ? L.a : R.a;
    temp.b = (L.b > R.b) ? L.b : R.b;
    return temp;
}
int main()
{
    Person p1(10,10);
    Person p2(10,10);
    Person p3=p1+p2;//假设调用类内的运算符重载，本质:p3=p1.operator+(p2)
    p3.show();
    Person p4=p2+p3;//假设调用类外的运算符重载，本质:p4=operator(p2,p3)
    p4.show();
    Person p5(5,11);
    Person p6;
    p6 = p5 > p1;
    p6.show();
    return 0;
}