C++ 继承机制：同名成员隐藏规则与默认函数详解

C++ 继承机制：同名成员隐藏规则与默认函数详解

前言

对于 C++ 来说，封装、继承、多态是面向对象编程（OOP）的经典三要素。这三个特性构成了 C++ 区别于纯面向过程语言的核心，也是理解面向对象思想的关键。之前我们利用类和对象的思想和 STL 中的适配器了解了封装，今天这篇文章就详细介绍一下继承这个特性。

一、什么是继承？

继承（inheritance） 机制是面向对象程序设计中代码复用的最重要手段。它允许我们在保持原有类（基类）特性的基础上进行扩展，增加方法和属性，从而产生新的类，称为派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

举个例子，假设我们设计了 Student 和 Teacher 两个类，它们都有姓名、地址、电话、年龄等成员变量，以及身份认证的成员函数。如果把这些都写进两个类里，代码就会大量冗余。当然，它们也有不同的部分，比如老师有职称，学生有学号；老师能授课，学生能学习。

class Student {
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity() {
        // ...
    }
    // 学习
    void study() {
        // ...
    }
protected:
    string _name = "peter";
    string _address;
    string _tel;
    int _age = 18;
    int _stuid;
};

class Teacher {
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity() {
        // ...
    }
    // 授课
    void teaching() {
        // ...
    }
protected:
    string _name = "张三";
    int _age = 18;
    string _address;
    string _tel;
    string _title;
};

int main() {
    return 0;
}

显然，这里出现了大量的重复代码。我们可以将这些公共成员放入一个 Person 类中，用继承的方法来处理，就不需要重复定义了。

class Person {
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity() {
        cout << "void identity()" << _name << endl;
    }
protected:
    string _name = "张三";
    int _age = 18;
    string _address;
    string _tel;
};

class Student : public Person {
public:
    void study() {
        cout << "void study()" << endl;
    }
protected:
    int _stuid;
};

class Teacher : public Person {
public:
    void teaching() {
        cout << "void teaching()" << endl;
    }
protected:
    string _title;
};

int main() {
    Student s;
    Teacher t;
    s.identity();
    t.identity();
    return 0;
}

二、继承的定义

定义的格式

在上面的例子中，Person 是基类，也称作父类；Student 是派生类，也称作子类。翻译的原因导致这两种叫法并存。

其实子类和父类比较好理解，那么继承方式是什么呢？继承方式和访问限定符有点类似，都有三种：public、protected、private。

继承基类访问方式的变化如下：

1. 看起来花里胡哨的，其实规则蛮简单的：public > protected > private，选其中小一点的。
2. 还有一些我们都知道的规则：使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public。不过最好显式地写出继承方式。
3. 在实际运用中一般使用都是 public 继承，几乎很少使用 protected/private 继承，也不提倡使用，因为 protected/private 继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

以上我们继承的 Person 是一个普通的类，继承不只能继承普通类，还能继承类模板。

继承类模板

namespace say_fall {
    template<class T>
    class stack : public std::vector<T> {
    public:
        void push(const T& x) {
            // 基类是类模板时，需要指定一下类域，否则编译报错
            // error C3861: 'push_back': 找不到标识符
            // 因为 stack<int> 实例化时，也实例化 vector<int> 了
            // 但是模版是按需实例化，push_back 等成员函数未实例化，所以找不到
            vector<T>::push_back(x);
        }
        void pop() {
            vector<T>::pop_back();
        }
        const T& top() {
            return vector<T>::back();
        }
        bool empty() {
            return vector<T>::empty();
        }
    };
}

int main() {
    say_fall::stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

注意到，这里用继承实现了一个 stack 类，而不是之前适配器的方法（用函数封装）。这里就要解释一下，原来适配器实现用的是组合的方法，还可以用继承实现。

三、基类和派生类之间的转换

继承就像是私有制极其严格的父子关系一样，有这么几条规则：

1. public 继承的派生类对象可以赋值给基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
2. 基类对象不能赋值给派生类对象。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用 RTTI (Run-Time Type Information) 的 dynamic_cast 来进行识别后进行安全转换。

• 类比：父亲给孩子的财产父亲是有权使用的，而孩子不能直接使用父亲的财产，必须经过父亲允许才可以。

class Person {
protected:
    string _name;
    string _sex;
    int _age;
};

class Student : public Person {
public:
    int _No;
};

int main() {
    Student sobj;
    // 1. 派生类对象可以赋值给基类的指针/引用
    Person* pp = &sobj;
    Person& rp = sobj;
    // 派生类对象可以赋值给基类的对象是通过调用基类的拷贝构造完成的
    Person pobj = sobj;
    
    // 2. 基类对象不能赋值给派生类对象，这里会编译报错
    sobj = pobj; // 报错：没有与这些操作数匹配的 "=" 运算符
    return 0;
}

四、继承的作用域

隐藏规则与重载比较

重载规则

在同一作用域下的同名函数，在参数不同的情况下构成函数重载。

隐藏规则

1. 在继承体系中基类和派生类都有独立的作用域。
2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用 基类::基类成员 显式访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。

// Student 的_num 和 Person 的_num 构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person {
protected:
    string _name = "小李子";
    int _num = 111;
};

class Student : public Person {
public:
    void Print() {
        cout << " 姓名:" << _name << endl;
        cout << " 身份证号:" << Person::_num << endl;
        cout << " 学号:" << _num << endl;
    }
protected:
    int _num = 999;
};

int main() {
    Student s1;
    s1.Print();
    return 0;
};

相关选择题

class A {
public:
    void fun() {
        cout << "func()" << endl;
    }
};

class B : public A {
public:
    void fun(int i) {
        cout << "func(int i)" << i << endl;
    }
};

int main() {
    B b;
    b.fun(10);
    b.fun();
    return 0;
};

1. A 和 B 类中的两个 func 构成什么关系？
   • 答案是 B（隐藏）。回顾重载，其定义是一个作用域中的同名函数，而继承出来的子类和父类实际上是在两个作用域的，所以是隐藏。
2. 上面程序的编译运行结果是什么？
   • 首先我们知道调用的 func() 是构成隐藏的，在调用 b.fun(); 的时候，却没有传入参数，很显然是编译错误。

五、派生类默认成员函数

自己手动写一个类的过程中，我们了解过这 6 个默认成员函数，也就是即使我们自己不实现，编译器也会自己实现的。而继承的类中会自动生成吗？生成的规则又是什么样子的？

这里说的四个默认构造函数是指构造、析构、赋值重载，拷贝构造：

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。需要注意的是派生类的 operator= 隐藏了基类的 operator=，所以显式调用基类的 operator=，需要指定基类作用域。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调用派生类构造。
6. 派生类对象析构清理先调用派生类析构再调用基类的析构。
7. 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成 destructor()，所以基类析构函数不加 virtual 的情况下，派生类析构函数和基类析构函数构成隐藏关系。

class Person {
public:
    Person(const char* name = "peter") : _name(name) {
        cout << "Person()" << endl;
    }
    Person(const Person& p) : _name(p._name) {
        cout << "Person(const Person& p)" << endl;
    }
    Person& operator=(const Person& p) {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p) _name = p._name;
        return *this;
    }
    ~Person() {
        cout << "~Person()" << endl;
    }
protected:
    string _name;
};

class Student : public Person {
public:
    Student(const char* name, int num) : Person(name), _num(num) {
        cout << "Student()" << endl;
    }
    Student(const Student& s) : Person(s), _num(s._num) {
        cout << "Student(const Student& s)" << endl;
    }
    Student& operator=(const Student& s) {
        cout << "Student& operator= (const Student& s)" << endl;
        if (this != &s) {
            // 构成隐藏，所以需要显式调用
            Person::operator=(s);
            // operator=(s); 会触发递归，因为调用的是自己的 operator=()
            _num = s._num;
        }
        return *this;
    }
    ~Student() {
        cout << "~Student()" << endl;
    }
protected:
    int _num;
};

int main() {
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
    return 0;
}

关于析构：析构子类时候会连带父类一起析构，所以父类不需要显式析构。