成长随心记2

1）运算符的重载
    d）赋值运算符的重载
    例：class person
    {
    public:
        person():age(10){}
        person(int a):{age=new int(a);}
        person& operator=(person& p) {
            age =new int (*p.age);    //深拷贝，浅拷贝会导致堆区重复释放
            return *this;
        }

    private:
        int* age;
    };

    e)等号运算符的重载
    例：class person
    {
    public:
        person(int a){
            age = new int(a);
        }
        ~person() {
            delete age;
        }
        bool operator==(person& p) {    //注意：==运算符返回的是bool类型
            age = new int(*p.age);    //深拷贝
            if (*age == *p.age&&height==p.height)
                return true;
            else
                return false;
        }
    private:
        int* age;
        int height;
    };

2，继承
    1）作用：减少代码量，提高逼格
    2）语法：class 子类 ：继承方式（public，protect，private） 父类
    3）无论是何种继承方式，子类都无法访问父类的private，但是确实都继承了
    4）继承方式为public：子类照搬父类的继承
    5）继承方式为protect：子类继承父类的public，private改为protect
    6）继承方式为private：子类继承父类的private，private改为private
    例：class father
    {
    public:
        int a = 10;
    private:
        int b = 10;
    protected:
        int c = 10;
    };

    class son1:public father//继承方式为public
    {
    public:
        void fan1() {
            a = 20;//继承了父类的public属性，类内可以访问
            c = 20;//继承了父类的protact属性，类内可以访问
            //b = 20;无法访问父类的private属性
        }
    };

    void test1() {
        son1 s1;
        s1.a = 20;//继承了父类的public属性，类外可以访问
        //s1.c = 20;//继承了父类的protact属性，类外不可以访问
        //s1.b = 20;//无法访问父类的private属性
    }

    class son2 :protected father//继承方式为protected
    {
    public:
        void fan2() {
            a = 20;//将父类的public属性改为protact属性，类内可以访问
            c = 20;//继承了父类的protact属性，类内可以访问
            //b = 20;//无法访问父类的private属性
        }
    };

    void test2() {
        son2 s2;
        //s2.a = 20;//将父类的public属性改为protact属性，类外不可以访问
        //s1.c = 20;//继承了父类的private属性，类外不可以访问
        //s1.b = 20;//无法访问父类的private属性
    }

    class son3 :private father//继承方式为private
    {
    public:
        void fan3() {
            a = 20;//将父类的public属性改为private属性，类内可以访问
            c = 20;//将父类的protact属性改为private属性，类内可以访问
            //b = 20;//无法访问父类的private属性
        }
    };

    void test3() {
        son3 s3;
        //s3.a = 20;//将父类的public属性改为private属性，类外不可以访问
        //s3.c = 20;//将父类的protact属性改为private属性，类内不可以访问
        //s3.b = 20;//无法访问父类的private属性
    }