C++学习记录（五）this指针，常对象常函数，静态对象静态函数，友元对象友元函数，运算符重载

这是第五天的记录。

#include <iostream>

using namespace std;

class Student
{
private:
    string name;
    int age;
    static int amount;
public:
    Student() {}
    ~Student() {}

    Student(string name, int age)        // this指针的用法一
    {
        this->name = name;
        this->age = age;
    }
    Student& setName(string name)        // this指针的第二种用法，返回对象
    {
        this->name = name;
        return *this;
    }

    void setAge(int age, Student* student)
    {
        student->age = age;                // 函数隐藏有this指针(即student)
    }
    void getAge()
    {
        cout << this->age << endl;
    }

    void showInfo()
    {
        cout << "Student name is: " << this->name << ", age is: " << this->age << endl;
    }
    void showThis()
    {
        cout << "This pointer address is: " << this << endl;
    }

    static int getAmount()
    {
        return amount;                      // 静态函数只能访问静态成员
    }
};

int Student::amount = 100;

int main()
{
    Student s1("Zhangsan", 18);
    Student s2 = s1.setName("Lisi");
    s2.showInfo();

    cout << "-------------" << endl;
    cout << sizeof (Student) << endl;       // this指针不占用类大小和类对象的大小

    s2.showThis();
    cout << "-------------" << endl;        // this保存本对象地址
    cout << &s2 << endl;

    // 类中静态函数没有this指针(无法访问类中属性)，加载静态区时就已经存在，是先于对象产生的；
    // 普通函数默认隐藏有this指针
    s2.setAge(20,&s2);
    s2.getAge();

    // 无需类对象存在，就可调用类中静态函数
    // static修饰的函数，仅表示修饰作用域，仅限本源码使用
    // 静态函数可以定义重名函数，且不能被其他文件调用
    cout << "-------------" << endl;
    cout << "Amount student: " << Student::getAmount() << endl;

    //cout << "Hello World!" << endl;
    return 0;
}

#include <iostream>

using namespace std;
class Desk
{

public:
    Desk() { cout << "Desk construction " << endl; }
    ~Desk() { cout << "Desk deconstruction " << endl; }
};

class Chair
{
public:
    Chair() { cout << "Chair construction " << endl; }
    ~Chair() { cout << "Chair deconstruction " << endl; }
};

class Room
{
private:
    //Desk _desk[3];                 // 对象数组
    //Chair _chair[3];

    Desk _desk1;
    Chair _chair1;
    //const string name;
    //const Computer _computer;

    string name;
    int size;
    static int amount;
public:
    //Room():name("office213")
    Room()
    {
        cout << "Room construction " << endl;
    }
    Room(string name, int size)
    {
        this->name = name;
        this->size = size;
    }
    ~Room() { cout << "Room deconstruction " << endl; }

    string getName() const                  // 常函数
    {
        return this->name;
    }
    const Room& setName(string name)        // 常对象
    {
        this->name = name;
        return *this;
    }

    void showInfo()
    {
        cout << "Room information, name: " << this->name << ", size: " << this->size << endl;
    }
    static int getAmount()                  // 静态成员或函数，属于进程的，不可以访问非静态成员
    {                                       // 它是所以对象共享
        return amount;
    }
private:
    void state()
    {
        cout << "It has been used. Size is "<< this->size << endl;
    }
    // 友元函数可以不受访问权限的约束，可以直接访问类中的所有属性
    friend void checkState(Room& _room);
    // 友元类
    friend class Space;
};

int Room::amount = 4;

void checkState(Room& _room)
{
    _room.state();
}

class Space
{
private:
    string name;
    int size;
public:
    Space();
    Space(string name, int size)
    {
        this->name = name;
        this->size = size;
    }
    void checkPosition(Room& _room, string ok)
    {
        cout << _room.name << " is belong to " << this->name << ok << endl;
    }
};

int main()
{
    // 当本类生成时，先构造类中的对象(按顺序)，在构造本对象，先析构本对象，再析构类中的对象(逆顺序)
    Room r1;

    // 常对象，const修饰的对象(只读)，用于保护数据不被修改
    cout << "Room name is " << r1.getName() << endl;

    // 常对象只能调用常函数，常函数可以读取类中成员，不能修改
    cout << r1.setName("classroom001").getName() << endl;;
    //cout << "Room name is " << r1.getName() << endl;

    // 静态成员与静态函数
    Room r2("classroom002", 80);
    Room r3("classroom003", 90);
    cout << "Amount of classrooom002 is: " << r2.getAmount() << endl;
    cout << "Amount of classrooom003 is: " << r3.getAmount() << endl;

    // 友元，友元函数，友元类
    // 友元函数：类中任意位置申明，即可申明某个全局函数
    // 友元不能传递
    checkState(r3);
    Space s1("Space", 200);
    s1.checkPosition(r3,"No");

    //cout << "Hello World!" << endl;
    return 0;
}

#include <iostream>

using namespace std;

class A
{
private:
    int number;
public:
    A() = default;
    A(int number) { this->number = number; }
    void setNumber(int num)
    {
        this->number = num;
    }
    int getNumber()
    {
        return this->number;
    }
    A& operator=(A& a)                  // 编译器提供的
    {
        this->number = a.number;
        cout << "This is the of operator of equal of the class A. " << endl;
        return *this;
    }
    A& operator+(A& a)
    {
        this->number += a.number;
        return *this;
    }
    A& operator-(A& a)
    {
        this->number -= a.number;
        return *this;
    }
    A& operator*(A& a)
    {
        this->number *= a.number;
        return *this;
    }
    A& operator/(A& a)
    {
        //cout << "first " << this->getNumber() << " Scend " << a.getNumber() << endl;
        //cout << this->number / a.number << endl;;
        this->number /= a.number;
        return *this;
    }
};
int main()
{
    A a1;
    a1.setNumber(1);
    A a2;
    a2.setNumber(2);

    a1 = a2;
    cout << a1.getNumber() << endl;

    A a3(4);
    A a4(2);
    //cout << (a3 + a4).getNumber() << endl;
    //cout << (a3 - a4).getNumber() << endl;
    //cout << (a3 * a4).getNumber() << endl;
    cout << (a3 / a4).getNumber() << endl;

    //cout << "Hello World!" << endl;
    return 0;
}