C++ 继承机制详解（上）

C++ 继承机制详解（上） | 极客日志

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; // 职称
};

类成员 / 继承方式	public 继承	protected 继承	private 继承
父类的 public 成员	相当于派生类的 public 成员（外部可通过派生类对象直接访问，如`derivedObj.pubFunc()`）	相当于派生类的 protected 成员（仅派生类内部及子类可访问，外部无法直接调用）	相当于派生类的 private 成员（仅派生类内部可访问，子类无法继承此权限）
父类的 protected 成员	相当于派生类的 protected 成员（派生类内部可自由使用，子类也能继承此权限）	相当于派生类的 protected 成员（与 public 继承的 protected 权限效果一致）	相当于派生类的 private 成员（派生类内部可使用，但子类无法访问）
父类的 private 成员	在派生类中不可见（无论派生类如何操作，均无法直接访问基类 private 成员）	在派生类中不可见（同 public 继承，基类 private 成员完全隔离）	在派生类中不可见（所有继承方式下，基类 private 成员对派生类均不可见）

#include <iostream>
#include <string>
using namespace std;

class person {
public:
    void identity() { cout << "身份识别" << endl; }
protected:
    string mname = "张三"; // 姓名
    string maddress; // 地址
    string mtel; // 电话
    int mage = 18; // 年龄
};

class student : public person // 继承
{
public:
    // 学习
    void study() { cout << "学习" << endl; }
    void definestudent() { mage = 20; maddress = "太阳系"; }
    void printstudent() { cout << mage << " " << maddress << endl; }
private:
    string mstuid;
};

class teacher : public person // 继承
{
public:
    // 授课
    void teaching() { cout << "授课" << endl; }
    void defineteacher() { mage = 29; maddress = "地球"; }
    void printteacher() { cout << mage << " " << maddress << endl; }
protected:
    string title; // 职称
};

int main() {
    student s;
    teacher t;
    // 创建两个子类变量
    s.identity();
    t.identity(); // 可以在外面直接通过子类变量调用父类的 public 的成员函数
    s.definestudent();
    t.defineteacher(); // 可以在子类中定义父类的成员变量
    s.printstudent();
    t.printteacher(); // 打印出我们可以看出，两个子类所存储的父类是独立的
    return 0;
}

#include <vector>
using namespace std;

namespace win {
    template <typename T1>
    class stack : public vector<T1> {
    public:
        void push(const T1& val = T1()) {
            // push_back(val); // 注意，不能就像上面那么使用，
            // 因为虽然认了 vector 为爸爸，但是编译器没那么智能
            // 直到你用的 push_back 函数就是 vector 里面的
            // 所以我们要指定类域
            // 即指定是 vector 里面的 push_back 函数才行
            vector<T1>::push_back(val);
            // 因为 stack<int>实例化时，也实例化 vector<int>了
            // 但是模版是按需实例化，push_back 等成员函数未实例化，所以找不到
        }
        void pop() { vector<T1>::pop_back(); }
        T1& top() { return vector<T1>::back(); }
        size_t size() const { return vector<T1>::size(); }
        bool empty() const { return vector<T1>::size() == 0; }
    private:
        // 就不用设置容器作为成员变量了
        // 因为已经认 vector 为爸爸了，所以就不需要了
        // 在上面的成员函数可以直接使用父类模版 vector 的成员函数了
    };
}

#include <iostream>
#include <vector>
using namespace std;

namespace win {
    template <typename T1>
    class stack : public vector<T1> {
    public:
        void push(const T1& val = T1()) {
            // push_back(val); // 注意，不能像上面那样直接使用，
            // 因为虽然继承了 vector 作为父类，但编译器无法自动识别
            // 该 push_back 函数是来自 vector 的成员
            // 因此需要通过 this 指针明确访问父类成员
            this->push_back(val);
            // 原因：stack<int>实例化时会同时实例化 vector<int>，
            // 但模板采用按需实例化机制，未显式调用的成员函数（如 push_back）不会提前实例化，
            // 导致编译器无法直接找到该函数
        }
        void pop() { this->pop_back(); }
        T1& top() { return this->back(); }
        size_t size() const { return this->size(); }
        bool empty() const { return this->size() == 0; }
    private:
        // 无需再定义容器作为成员变量，
        // 因为已继承自 vector 父类，可直接使用其成员函数
    };
}

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

#include <iostream>
#include <string>
using namespace std;

class person {
public:
    void identity() { cout << "身份识别" << endl; }
protected:
    string mname = "张三"; // 姓名
    string maddress; // 地址
    string mtel; // 电话
    int mage = 18; // 年龄
};

class student : public person {
public:
    // 学习
    void study() { cout << "学习" << endl; }
    void definestudent() { mage = 20; maddress = "太阳系"; }
    void printstudent() { cout << mage << " " << maddress << endl; }
private:
    string mstuid; // 学生学号
};

class teacher : public person {
public:
    // 授课
    void teaching() { cout << "授课" << endl; }
    // 修正拼写错误：defineteavher → defineteacher
    void defineteacher() { mage = 29; maddress = "地球"; }
    void printteacher() { cout << mage << " " << maddress << endl; }
protected:
    string title; // 教师职称
};

int main() {
    // 子类对象实例化
    student s;
    teacher t;
    // 子类对象赋值给基类指针
    person* p1 = &s;
    person* p3 = &t;
    // 子类对象赋值给基类引用
    person& p2 = s;
    person& p4 = t;
    // 子类对象赋值给基类对象（通过基类拷贝构造完成，后续讲解）
    student sobj;
    person pobj = sobj;
    // 2. 基类对象不能赋值给派生类对象，以下代码编译会报错
    person p; // s = p; // 错误：没有与这些操作数匹配的"="运算符
    return 0;
}

// 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;//指定是父类 person 里面的_num
        cout << "学号:" << _num << endl;
    }
protected:
    int _num = 999; // 学号
};

int main() {
    Student s1;
    s1.Print();
    return 0;
};
//可以看出这样代码虽然能跑，但是非常容易混淆

#include <iostream>
using namespace std;

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;
}

class Base {
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
    // C++98 的方法
    Base() {}
};

class Derive : public Base // 编译报错
{
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};

// C++11 的方法
class Base final {
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
    // C++98 的方法
    /*Base() {}*/
};

class Derive : public Base // 不能将'final'类类型用作基类
{
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};

#include <iostream>
#include <string>
using namespace std;

class Student;

class Person {
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name; // 姓名
};

class Student : public Person {
protected:
    int _stuNum; // 学号
};

void Display(const Person& p, const Student& s) {
    cout << p._name << endl;
    cout << s._stuNum << endl;
}

int main() {
    Person p;
    Student s;
    // 编译报错：error C2248: 'Student::_stuNum': 无法访问 protected 成员
    // 解决方案：Display 也变成 Student 的友元即可
    Display(p, s);
    return 0;
}

class Parent {
public:
    static int count; // 基类定义静态成员变量
};

int Parent::count = 0; // 静态成员必须在类外初始化

class Child : public Parent {};

int main() {
    Parent p1;
    Child c1;
    p1.count++; // 基类对象修改：count 变为 1
    c1.count++; // 子类对象修改：count 变为 2
    cout << Parent::count; // 输出 2（所有访问共享同一实例）
    cout << Child::count; // 输出 2（与基类共享同一实例）
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    string _name;
    static int _count;
};

int Person::_count = 0;

class Student : public Person {
protected:
    int _stuNum;
};

int main() {
    Person p;
    Student s;
    // 这里的运行结果可以看到非静态成员_name 的地址是不一样的
    // 说明派生类继承下来了，父派生类对象各有一份
    cout << &p._name << endl;
    cout << &s._name << endl;
    // 这里的运行结果可以看到静态成员_count 的地址是一样的
    // 说明派生类和基类共用同一份静态成员
    cout << &p._count << endl;
    cout << &s._count << endl;
    // 公有的情况下，父派生类指定类域都可以访问静态成员
    cout << Person::_count << endl;
    cout << Student::_count << endl;
    return 0;
}

C++ 继承机制详解（上）

继承的概念

示例

注意点

继承的定义

继承的方式

补充说明：

继承的格式

示例代码：

继承类模板

示例代码：

按需实例化：

this 指针法

基类和派生类间的转换

示例代码：

继承中的作用域

隐藏规则

示例代码：

考察继承作用域相关选择题：

答案：

实现一个不能被继承的类

方法一：

方法二：

继承与友元

继承与静态成员

详解 C++ 继承体系中静态成员的'全局唯一性'特性

一、静态成员'全局唯一'的本质：不依赖对象，属于类本身

二、具体表现：子类与基类共享同一静态成员

三、核心逻辑：静态成员的归属与继承无关

总结

结语

更多推荐文章

相关免费在线工具

C++ 继承机制详解（上）

继承的概念

示例

注意点

继承的定义

继承的方式

补充说明：

继承的格式

示例代码：

继承类模板

示例代码：

按需实例化：

this 指针法

基类和派生类间的转换

示例代码：

继承中的作用域

隐藏规则

示例代码：

考察继承作用域相关选择题：

答案：

实现一个不能被继承的类

方法一：

方法二：

继承与友元

继承与静态成员

详解 C++ 继承体系中静态成员的'全局唯一性'特性

一、静态成员'全局唯一'的本质：不依赖对象，属于类本身

二、具体表现：子类与基类共享同一静态成员

三、核心逻辑：静态成员的归属与继承无关

总结

结语

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具