【讨论C++继承】

烛九_阴2024-07-03 4:05

讨论C++继承

继承是面向对象程序设计中，使代码可以复用的重要手段，它允许程序员在保持原有类特性的基础上进行扩展。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

继承

定义

c++ 复制代码 
class Person {
public:
    void print() {
        cout << "这是一个人类" << endl;
    }
protected:
    string name;
    int age;
};

class Student : public Person{
private:
    int stuId;
};

int main() {
    Student s;
    Person p;
    s.print();
    p.print();
    return 0;
}

上述代码，Person是基类，Student是派生类。

使用:来实现继承。

继承方式和访问限定符

基类/继承方式 public继承 protected继承 private继承
public成员 派生类的public成员 派生类的protected成员 派生类的private成员
protected成员 派生类的protected成员 派生类的protected成员 派生类的private成员
private成员 在派生类中不可见 在派生类中不可见 在派生类中不可见
  1. 基类使用private修饰的成员在派生类中无论以什么方式继承，都不可见。不可见是指还是会继承，只是不能直接使用，因为private修饰的成员在类外不可使用。
  2. protected修饰的成员不可在类外使用，但是存在继承关系的，派生类可以直接访问基类的成员。
  3. 使用关键字class时，默认的继承方式是private，使用struct时，默认的继承方式是public。

基类和派生类的赋值转换

派生类对象可以直接赋值给基类的对象、指针、引用。

基类的对象不能赋值给派生类对象。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用，但必须是基类的指针指向派生类的对象时才安全。

c++ 复制代码 
class Person {
public:
    void print() {
        cout << "这是一个人类" << endl;
    }
protected:
    string name;
    int age;
};

class Student : public Person{
private:
    int stuId;
};

int main() {
    Student s;
    Person* ps = &s;
    Person& rps = s;
    Person p = s;
    return 0;
}
  • 派生类对象赋值给基类对象，基类对象只能访问基类拥有的成员变量，不能访问派生类特有的成员变量。
  • 派生类赋值给基类对象时，不产生临时变量。

继承中的作用域

  1. 在继承体系中，基类和派生类的作用域是独立的。
  2. 当基类和派生类中有同名成员时，派生类成员将屏蔽基类同名成员的直接访问，称为隐藏或重定义。
  3. 成员函数只需要函数名相同即可达成隐藏。
c++ 复制代码 
class Person {
protected:
    string name = "张三";
    int age = 10;
};

class Student : public Person{
public:
    void print() {
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
        cout << "学号：" << stuId << endl;
    }
private:
    int stuId;
    int age;
};

int main() {
    Student s;
    s.print();
    return 0;
}
  • 上述代码，Student类中的age和Person类中的age构成隐藏。Student对象使用自己类域中的age成员变量，因此是随机值。
  • 要想使用Person类中的age，需要Person::age。
c++ 复制代码 
class Student : public Person{
public:
    void print() {
        cout << "姓名：" << name << endl;
        cout << "年龄：" << Person::age << endl;
        cout << "学号：" << stuId << endl;
    }
private:
    int stuId;
    int age;
};

派生类的默认成员函数

  1. 派生类构造时必须调用基类的构造函数初始化基类的部分成员，如果基类没有默认构造函数，必须在派生类构造函数初始化列表中显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须调用基类的operator=完成基类的赋值。
  4. 派生类的析构函数会在调用完成后自动调用基类的析构函数清理基类成员。
  5. 派生类对象初始化先调用基类构造函数再调用派生类构造函数。
  6. 派生类对象析构时先调用派生类析构函数再调用基类析构函数。
c++ 复制代码 
class Person {
public:
    Person(const char *name = "张三")
            : _name(name) {
        cout << "Person(name)" << 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 stuId = 110)
            : Person(name), _stdId(stuId) {
        cout << "Student(name, stuId)" << endl;
    }

    Student(const Student &s)
            : Person(s), _stdId(s._stdId) {
        cout << "Student(const Student &s)" << endl;
    }

    Student& operator=(const Student& s) {
        cout << "Person& operator=(const Person& p)" << endl;
        if(this != &s) {
            Person::operator=(s);
            _stdId = s._stdId;
        }
        return *this;
    }

    ~Student() {
        cout << "~Student()" << endl;
    }

private:
    int _stdId;
};

int main() {
    Student s1("李四", 111);
    cout << "====================" << endl;

    Student s2(s1);
    cout << "====================" << endl;

    Student s3("王五", 112);
    s2 = s3;
    cout << "====================" << endl;

    return 0;
}
  • 根据规则，派生类构造前应完成基类构造，因此在创建派生类对象，一定会初始化基类，析构时先析构派生类，再析构基类。

继承和友元

友元关系不能被继承。

c++ 复制代码 
class Student;
class Person {
public:
    friend void print(const Person& p, const Student& s);
public:
    Person(const char *name = "张三")
            : _name(name) {
        cout << "Person(name)" << 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 stuId = 110)
            : Person(name), _stdId(stuId) {
        cout << "Student(name, stuId)" << endl;
    }

    Student(const Student &s)
            : Person(s), _stdId(s._stdId) {
        cout << "Student(const Student &s)" << endl;
    }

    Student& operator=(const Student& s) {
        cout << "Person& operator=(const Person& p)" << endl;
        if(this != &s) {
            Person::operator=(s);
            _stdId = s._stdId;
        }
        return *this;
    }

    ~Student() {
        cout << "~Student()" << endl;
    }

protected:
    int _stdId;
};

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

int main() {
    Student s("李四", 111);
    print(s, s);
    return 0;
}
  • 上述代码会报错，error: '_stdId' is a protected member of 'Student'。证明友元函数没有被继承，因为Student类使用private和protected修饰的成员变量不能在类外使用。

继承和静态成员

基类定义的static静态成员，整个继承体系中只有一个这样的成员。

c++ 复制代码 
class Person {
public:
    Person() {
        ++n;
    }
public:
    static int n;
};
int Person::n = 0;
class Student : public Person {
};


int main() {
    Student s;
    cout << Person::n << endl;
    s.n = 10;
    cout << Person::n << endl;

    return 0;
}

菱形继承

  • 单继承：一个派生类只有一个直接基类。Java只支持单继承。
  • 多继承：一个派生类继承于多个基类。C++支持多继承。
  • 菱形继承：它是多继承的一个特殊情况。

菱形继承所带来的问题是，最初继承的类内成员会存在两份，即数据冗余和二义性问题。

c++ 复制代码 
class A {
public:
    int _a;
};

class B : public A{
public:
    int _b;
};

class C : public A {
public:
    int _c;
};

class D : public B, public C {
public:
    int _d;
};


int main() {
    D d;

    return 0;
}
  • 想要直接通过d对象去修改_a是不被允许的，因为编译器不知道想要修改的是B类和C类中哪个类的_a。
  • 只能通过d.B::a = 10这种指定类域的方式来修改或赋值。这种方式可以解决二义性问题，但无法解决数据冗余问题。

虚拟继承

  • 使用virtual关键字建立虚拟继承，可以解决数据冗余和二义性问题。
  • 当不使用虚拟继承时，内存空间是这样的。
c++ 复制代码 
class A {
public:
    int _a;
};

class B : public A{
public:
    int _b;
};

class C : public A {
public:
    int _c;
};

class D : public B, public C {
public:
    int _d;
};


int main() {
    D d;
    d.B::_a = 1;
    d.C::_a = 9;
    d._b = 2;
    d._c = 3;
    d._d = 4;

    return 0;
}
  • 使用虚拟继承，_a就只存在一份，可以直接赋值。
c++ 复制代码 
class A {
public:
    int _a;
};

class B : virtual public A{
public:
    int _b;
};

class C : virtual public A {
public:
    int _c;
};

class D : public B, public C {
public:
    int _d;
};


int main() {
    D d;
    d.B::_a = 1;
    d.C::_a = 9;
    d._b = 2;
    d._c = 3;
    d._d = 4;

    return 0;
}
  • clang编译器通过B和C的两个指针，指向一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存在偏移量。通过偏移量可以找到A。
相关推荐
k09338 分钟前
sourceTree回滚版本到某次提交
开发语言·前端·javascript
神奇夜光杯16 分钟前
Python酷库之旅-第三方库Pandas(202)
开发语言·人工智能·python·excel·pandas·标准库及第三方库·学习与成长
Themberfue18 分钟前
Java多线程详解⑤（全程干货！！！）线程安全问题 || 锁 || synchronized
java·开发语言·线程·多线程·synchronized·锁
plmm烟酒僧20 分钟前
Windows下QT调用MinGW编译的OpenCV
开发语言·windows·qt·opencv
测试界的酸菜鱼31 分钟前
Python 大数据展示屏实例
大数据·开发语言·python
我是谁？？31 分钟前
C/C++使用AddressSanitizer检测内存错误
c语言·c++
晨曦_子画41 分钟前
编程语言之战：AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin
Black_Friend1 小时前
关于在VS中使用Qt不同版本报错的问题
开发语言·qt
发霉的闲鱼1 小时前
MFC 重写了listControl类（类名为A），并把双击事件的处理函数定义在A中，主窗口如何接收表格是否被双击
c++·mfc
小c君tt1 小时前
MFC中Excel的导入以及使用步骤
c++·excel·mfc
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解