C++中继承方式与访问标号的学习笔记

今天药忘吃喽~ 2022-05-17 12:56 189阅读 0赞

# C++中继承方式与访问标号的学习笔记 #

## 1 无虚函数的情况 ##

基类有一个public函数，一个protected函数，一个private函数：

class A {
    public:
        voidf() {
           cout<<"A::f"<<endl;
            g();
           h();
        }
    protected:
       void g() {cout<<"A::g"<<endl;}
    private:
        voidh() {cout<<"A::h"<<endl;}
    };

### 1.1 第一种情况：public继承 ###

派生类public继承基类，没有新增的函数。

class B:public A {
    
    };
    int main(int argc, char *argv[]) {
        B b;
        b.f();
       return 0;
    }

运行结果：

A::f
    A::g
    A::h

只覆盖public函数：

class B:public A {
    public:
       void f() {
           cout<<"B::f"<<endl;
           g();
    h();
        }
    };

编译错误： \`void A::h()' is private。

只覆盖protected和private函数：

class B:public A {
    protected:
       void g() {cout<<"B::g"<<endl;}
    private:
        voidh() {cout<<"B::h"<<endl;}
    };

运行结果：

A::f
    A::g
    A::h

覆盖所有函数：

class B:public A {
    public:
       void f() {
           cout<<"B::f"<<endl;
           g();
           h();
        }
    protected:
       void g() {cout<<"B::g"<<endl;}
    private:
        voidh() {cout<<"B::h"<<endl;}
    };

运行结果：

B::f
    B::g
    B::h

### 1.2 第二种情况：protected继承 ###

只覆盖public函数：

编译错误： \`void A::h()' is private。

只覆盖protected与private函数：

编译错误：\`A' is not an accessible base of \`B'。

覆盖所有函数：

正常运行，结果与public继承时相同。

### 1.3 第三种情况：private继承 ###

与protected情况相同。

### 1.4 本节总结 ###

C++Primer中对此的总结：

1) public继承：基类成员保持自己的访问级别。

2) protected继承：基类的public和protected成员在派生类中为protected成员。

3) private继承：基类所有成员在派生类中为private成员。

这段文字我理解起来有点头疼，下面是自己对它的理解：

1) C++Primer中提到的，派生类对象中包含之前的所有基类子对象。所以当运行由基类继承而来的函数时，就相当于是派生类对象将请求转发给了基类对象，才会出现当B覆盖了g()和h()后运行f()，结果与直接运行A中的f()相同的情况，因为此时运行的f()就是A中的版本。

2) 派生类从基类继承来的成员中，public成员可被外界访问，protected成员可在类中使用，private成员只能被基类中的函数使用。所以B覆盖了f()后出现h()不可使用的编译错误，因为此时是B中的成员f()试图调用继承来的private成员h()，而不是A中的成员f()。而B在protected继承A，且没有覆盖f()时，无法在main函数中运行b.f()，因为此时f()是B中的protected成员，不能被外界访问。

3) 在没有虚函数时，派生类对象与基类子对象相当于简单的并列关系，是两个独立的个体，且基类子对象中的private函数对派生类对象是封闭的。所以在这种情况下覆盖基类中继承过来的private函数是没有覆盖的意义的，比如B::h()，与A::h()只是单纯的名字相同。

## 2 有虚函数的情况 ##

派生类与测试函数：

class B:public A {
    public:
       void f() {
           cout<<"B::f"<<endl;
           g();
           h();
        }
    protected:
       void g() {cout<<"B::g"<<endl;}
    private:
        voidh() {cout<<"B::h"<<endl;}
    };
    
    int main(int argc, char *argv[]) {
       A*b=new B;
       b->f();
       return 0;
    }

### 2.1 第一种情况：protected与private继承 ###

这两种继承方式时，出现编译错误： \`A' is an inaccessible base of \`B'。百度了一下原因，自己总结了一下：

A \*b=new B这种方式相当于将A当作一个接口，而这两种继承方式下B并没有从A中继承到public成员，也就等于是没有利用到A这个接口，所以编译器拒绝将派生类的指针或引用赋值给A的指针，因为没有意义。

### 2.2 第二种情况：public函数为虚函数 ###

基类：

class A {
    public:
       virtual void f() {
           cout<<"A::f"<<endl;
           g();
           h();
        }
    protected:
       void g() {cout<<"A::g"<<endl;}
    private:
        voidh() {cout<<"A::h"<<endl;}
    };

不覆盖public函数（注释掉B中的f()）：

运行结果：

A::f
    A::g
    A::h

不覆盖protected函数：（注释掉g()）：

运行结果：

B::f
    A::g
    B::h

不覆盖private函数：（注释掉h()）：

编译错误： \`void A::h()' is private。

### 2.3 第三种情况：protected函数为虚函数 ###

不覆盖public函数（注释掉B中的f()）：

运行结果：

A::f
    B::g
    A::h

不覆盖protected函数：（注释掉g()）：

运行结果：

A::f
    A::g
    A::h

不覆盖private函数：（注释掉h()）：

编译错误： \`void A::h()' is private。

### 2.4 第四种情况：private函数为虚函数 ###

不覆盖public函数（注释掉B中的f()）：

运行结果：

A::f
    A::g
    B::h

不覆盖protected函数：（注释掉g()）：

运行结果：

A::f
    A::g
    B::h

不覆盖private函数：（注释掉h()）：

编译错误： \`void A::h()' is private。

### 2.5 本节总结 ###

C++实现虚函数的方式是在类的开头存放一个虚函数表，表中每个函数名项都指向了一个实际的函数地址。派生类如果覆盖了基类中的虚函数，则派生类的虚函数表中此项将指向派生类的实现版本。C++通过这种方法几乎没有额外消耗的实现了运行时多态。

简单的说，A或A的子类中有这么一张表：

如果B覆盖了A中的一个函数，比如f()，B中的表就变成了：

这样，即使A \*b=new B中a的静态类型为A\*，在运行时也能找到正确的函数版本，即B::f()。

而对于B中没有覆盖的函数，比如g()和h()，通过B::f()调用时仍然遵循类继承时的访问原则：派生类中可见基类继承过来的protected成员，不可见继承过来的private成员。因此当B覆盖h()时，B::f()可以成功运行，并调用B::h()；但如果B没有覆盖h()，而是从基类中继承过来h()，因为它是private成员，B::f()中不可见，因此编译不通过。

## 3 访问同类型的其它对象的情况 ##

刚开始学习这部分时我成功的被书上的话给绕晕了，以为派生类对象可以访问其它的基类对象的protected成员，导致对下面这种问题迷惑不解：

class A {
    public:
       virtual void f(A *a) {
           cout<<"A::f"<<endl;
           a->g(this);
        }
    protected:
       virtual void g(A *a) {cout<<"A::g"<<endl;}
    };
    
    class B:public A {
    public:
       void f(A *a) {
           cout<<"B::f"<<endl;
           a->g(this);
        }
    protected:
       void g(A *a) {cout<<"B::g"<<endl;}
    };
    
    int main(int argc, char *argv[]) {
       A*b=new B;
       b->f(b);
       return 0;
    }

编译错误： \`virtual void A::g(A\*)' is protected。

摸索了一段时间，才弄清楚原来书上说的派生类对象与基类对象，都指的是派生类对象内部，派生类部分和基类部分，而如果要访问一个独立的基类对象的protected成员是不可能的，这里要遵循类中成员的访问标号原则。

刚才在C++Primer的15.2.2里找到一句话：派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限。

## 4 怎么选择继承方式与访问标号 ##

以下是我的一些理解：

基类应该把想让用户使用的功能设为public，或者是把所有子类都需要的通用的功能设为public，这样就相当于发挥了接口的作用。

基类应将派生类需要重定义的函数定义为虚函数。如果基类不想让派生类可以调用基类的版本，也就是强制派生类实现自己的版本的话，就将这样的函数设为private，而将允许派生类调用的版本设为protected。

如果派生类只需要利用基类已有的功能，不想实现自己的版本，就不应该重载或实现基类的public函数。

在继承方式上，一般来说都使用public继承。private继承会将基类中的所有成员都设为private，相当于派生类无法使用基类的任何成员和功能，C++Primer中说这种继承的情况非常少见，我也从来没见过这种继承方式。protected继承会将基类中的public成员变成protected，这样就无法利用基类的接口了，也就无法利用到运行时多态的好处，所以一般也是不推荐的。