C++继承权限-优快云博客

#include<iostream>
using namespace std;
class father {
public:
    int pub;
protected:
    int pro;
private:
    int pri; // 只是被隐藏了，会被一直继承下去
};
// 以私有的方式继承父类，父类中的所有成员在子类中的权限都是私有的
// son继承了father，father中包含的son中也包含
class son : private father {
    void fun() {
        pub = 2;//从共有的变为私有
        pro = 2;//从受保护的变为私有
        //   pri = 3;//不可以被访问，因为在在父类中是私有的
    }
};
// 因为son是以私有的方式继承father，所以father中的成员
//在son中都是私有的，所以son的子类不能访问到pro和pub 
class grandson : public son {
    void fun() {
        // pro = 2;
        // pub = 2;
    }
};
int main()
{
    cout << "类father的大小为："<<sizeof(father) << endl;
    cout << "类son的大小为：" << sizeof(son) << endl;
    cout << "类grandson的大小为：" << sizeof(grandson) << endl;
    return 0;

}

关于继承的权限可以看代码，在这里强调一下，如果父类中有私有的成员，子类也是会继承的，只是被隐藏了，千万不要以为父类中是私有的，就不会被继承。我们可以通过打印这个类的大小来确认。

protected

class father {
public:
    int pub;
protected:
    int pro;
private:
    int pri;
};
// 以受保护的方式继承，那么father中的共有成员
//在son中的访问权限是受保护的
class son : protected father {
    void fun() {
        pub = 2; // 从共有的变为受保护的
        pro = 2; // 仍然是受保护的
        //  pri = 3;//不可以被访问，因为在在父类中是私有的
    }
};

class grandson : protected son {
    void fun() {
        // 因为是受保护的，所以可以访问
        pro = 2;//受保护的
        pub = 2;//受保护的
    }
};

public:

class father {
public:
    int pub;
protected:
    int pro;
private:
    int pri;
};
// 以共有的方式继承，子类的权限不变
class son : public father {
    void fun() {
        pub = 2; // 共有的
        pro = 2; // 仍然是受保护的
        //  pri = 3;//不可以被访问，因为在在父类中是私有的
    }
};

class grandson : public son {
    void fun() {
        pro = 2;
        pub = 2;
    }
};

3.继承中的构造函数与析构函数

子类继承父类后，创建子类对象时，也会调用父类的构造函数

先调用父类的构造函数，然后调用自身的构造函数，析构函数的顺序相反。

#include <iostream>
using namespace std;
class A {
public:
    int num;
    A() { cout << "父类的构造" << endl; }
    ~A() { cout << "父类的析构" << endl; }
};
class B : public A {
public:
    B() { cout << "子类的构造" << endl; }
    ~B() { cout << "子类的析构" << endl; }
};
int main() {
    B b;
    return 0;
}

例如上述代码的运行结果为：

4.继承同名成员的处理方式

当子类和父类出现同名的成员，可以通过以下两种访问

1.访问子类同名成员直接访问即可

2.访问父类同名成员需要加作用域

#include <iostream>
using namespace std;
/*
    当父类和子类中有同名函数时，子类中的函数会将父类中的同名函数隐藏
    如果此时想通过子类对象访问父类对象，需要作用域
    父类对象不可以访问子类对象中的成员变量，因为创建父类对象不会创建子类对象
*/
class A {
public:
    int num;
    A(int val) { cout << "类A的有参构造" << endl; }
    void fun() {
        cout << num << endl;
        cout << "A" << endl;
    }
};
class B : public A {
public:
    int num;
    // 如果父类中没有无参构造函数，可以在子类的初始化参数列表中调用父类的构造函数
    B(int val) : A(val) { cout << "类B的有参构造" << endl; }
    void fun() {
        cout << num << endl;
        cout << "B" << endl;
    }
};
int main() {
    B b(2);
    b.num = 2;    // 此时的num是类B中的num
    b.fun();      // 调用的是类B中的fun函数
    b.A::num = 3; // 类A中的num
    b.A::fun();   // 类A中的fun函数
    return 0;
}

5.多继承

在C++中是允许一个类继承多个类的

语法：class 子类：继承方式父类1，继承方式父类2......

多继承可能会引起父类中的同名成员的出现，需要加作用域区分

#include <iostream>
using namespace std;
class A {
public:
    int num;
};
class B {
public:
    int num;
};
class C : public A, public B {
public:
};
int main() {
    C c;
    c.A::num = 2; // 通过作用域解决多继承中的二义性问题
    return 0;
}

例如在上述代码中，让类C以共有的方式继承了类A和类B，此时类A和类B都有一个叫做num的成员变量，类C中都可以访问到这两个对象，如果c.num访问时，就会报二义性的错误，编译器不知道这个num是类A中的num还是类B中的num，所以此时需要加作用域区分。