大二c++实验课学习类的继承的总结

文中许多概念转自::https://blog.csdn.net/weixin_44179269/article/details/105751667?ops_request_misc=&request_id=&biz_id=102&utm_term=c++%E7%B1%BB%E7%9A%84%E7%A7%81%E6%9C%89%E7%BB%A7%E6%89%BF%E5%92%8C%E5%85%B1%E6%9C%89%E7%BB%A7%E6%89%BF&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-1-105751667.142^v9pc_search_result_control_group,157^v4control&spm=1018.2226.3001.4187

类的继承

• 一、类的公有继承
• • • 1.公有继承的特点
    • 2.虚拟继承
• 二、类的保护继承
• • • 1.保护继承的特点
• 三、类的私有继承
• • • 1.私有继承的特点

一、类的公有继承

先来认识基类和派生类
例如：类B继承A而来
则称A是B的基类，B是A的派生类

//语法规则
class A {
//A时B得基类
};

class B :public A{
//B是A得派生类
};

1.公有继承的特点

• 对基类的公有属性成员和保护属性成员属性的访问权限不变
• 派生类的新增成员可以访问基类的公有成员和保护成员，但是访问不了基类的私有成员。
• 会继承基类的所有共有成员（注意B中完全继承了A，只不过是限制了访问的权限，并不代表他不存在）

#include

using namespace std;

class A {
    private:
        int a;
    
    protected:
        int b;

    public:
        int c;
        A(int _a = 0, int _b = 0, int _c = 0) {
            a = _a, b = _b, c = _c;
        }
};

class B :public A{
    public:
        B(int _a = 0, int _b = 0, int _c = 0):A(_a, _b, _c) {

        }
        int get_a() {
            return a;//private不可访问
        }

        int get_b() {
            return b;//可以访问protected
        }

        int get_c() {
            return c;//可以访问public
        }
};

int main() {
    B test(1, 2, 3);
    cout << test.a << endl;//不可访问private
    cout << test.b << endl;//不可访问protected
    cout << test.c << endl;//可以访问public
    return 0;
}

2.虚拟继承

• 函数的重写

#include

using namespace std;

class A {
    public:
        void show() {
            cout << "This is A" << endl;
        }
};

class B :public A{
    public:
        void show() {
            cout << "This is B" << endl;
        }
};

• 重写的应用，可以用来扩展基类的通类函数

#include

using namespace std;

class A {
    public:
        void show() {
            cout << "This is A" << endl;
        }
};

class B :public A{
    public:
        void show() {
            A::show();
            cout << "This is B" << endl;
        }
};

• 可以定义一个基类的指针指向派生类，但此时也只能使用对象实例化后的A中数据成员

#include

using namespace std;

class A {
    private:
        int a;
    public:
        A(int _a = 0) {
            _a = a;
        }
        int get_a() {
            return a;
        }
};

class B :public A{
    private:
        int b;
    public:
        B(int _a = 0, int _b = 0):A(_a){
            _b = b;
        }
        int get_b() {
            return b;
        }
};

int main() {
    B b(1, 2);
    A *a = &b;
    cout << a -> get_a() << endl;//可以访问
    cout << a -> get_b() << endl;//不可以访问，A中没有成员函数get_b()
    return 0;
}

• 函数重写加上基类指针
• 析构函数写也应在基类上加上virtual应先销毁A再销毁B

#include

using namespace std;

class A {
    private:
        int a;
    public:
        A(int _a = 0) {
            a = _a;
        }
        int get_a() {
            return a;
        }
};

class B :public A{
    private:
        int b;
    public:
        B(int _a = 0, int _b = 0):A(_a){
            b = _b;
        }
        int get_a() {
            return b;
        }
};

int main() {
    B b(1, 2);
    A *a = &b;
    cout << a -> get_a() << endl;//此时访问的基类自己的get_a()函数
    //将基类的get_a()函数改为 virtual get_a()就可以访问派生类B中的get_a()
    return 0;
}

二、类的保护继承 1.保护继承的特点

• 基类的公有成员和保护成员被派生类继承后变成保护成员，
• 派生类的新增成员可以访问基类的公有成员和保护成员，但是访问不了基类的私有成员。
• 派生类的对象不能访问派生类继承基类的公有成员，保护成员和私有成员。
• 我认为类的的保护继承，派生类会把访问权限比protected全部都升到到与proteced一样

#include

using namespace std;

class A {
    public:
        int a;
        A(int _a = 0) {
            a = _a;
        }
};

class B :protected A{
    public:
        B(int _a):A(_a) {}
        int get() {
            return a;//可以访问
        }
};

int main() {
    B b(2);
    cout << b.get() << endl;//可以访问
    cout << b.a << endl;//不可以访问
    return 0;
}

三、类的私有继承 1.私有继承的特点

• 基类的公有成员和保护成员都被派生类继承下来之后变成私有成员。
• 派生类的新增成员可以访问基类的公有成员和保护成员，但是访问不了基类的私有成员。
• 派生类的对象不能访问派生类继承基类的公有成员，保护成员和私有成员。
• 我认为类的私有继承，派生类会把访问权限比paivate全部都升到到与paivate一样

#include

using namespace std;

class A {
    public:
        int a;
        A(int _a = 0) {
            a = _a;
        }
};

class B :private A{
    public:
        B(int _a):A(_a) {}
        int get() {
            return a;//可以访问
        }
};

int main() {
    B b(2);
    cout << b.get() << endl;//可以访问
    cout << b.a << endl;//不可以访问
    return 0;
}