c++中的继承

已于 2022-09-08 23:28:26 修改
阅读量611 收藏 1
点赞数 1
分类专栏： C++学习 文章标签： c++ java 开发语言
于 2022-09-02 11:43:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DUANJIAWEIDUANJIAWEI/article/details/126657986
版权

知识点1【继承和派生的概述】

在这里插入图片描述
继承的优点：减少代码的冗余，提高代码的重用性

知识点2【继承的格式】

派生类定义格式：
	class 派生类名:继承方式 基类名{
		//派生类新增的数据成员和成员函数
	};

继承方式分类：
public：公有继承（重要）
private：私有继承
protected：保护继承
父类个数分类：
单继承：指每个派生类只直接继承了一个基类的特征（一个父类派生出一个子类）。

class Derived : public BaseA   
{
 
   
};

多继承：一个子类可以有多个父类，子类拥有所有父类的成员变量，子类继承所有父类的成员函数，子类对象可以当作任意父类对象使用。

class Derived : public BaseA, public BaseB, public BaseC   
{
 
   
};

注意：子类继承父类，子类拥有父类中全部成员变量和成员方法（除了构造和析构函数之外的成员方法），但是在子类中，继承的成员并不一定能直接访问，不同的继承方式会导致不同的访问权限。
案例1：公有继承（public）

#include <iostream>

using namespace std;

class Base{
private:
    int B_a;
protected:
    int B_b;
public:
    int B_c;
};

class Son:public Base{
    //父类中的public数据 在子类中 也是public
    //父类中的private数据 在子类中 是不可见的
    //父类中的protected数据 在子类中 是protected的
public:
    void func(){
       B_b = 100;
       //B_a = 300;在子类中private数据，不可见
       B_c = 300;//在子类中内部protected数据，可以直接访问
    }

};

int main(int argc, char *argv[])
{
    Base *base = new Son();//注意：B PRIVATE/protected 继承A，那么 A 的指针不能指向B
    //base->B_b;//protected数据 在子类外是访问不了的
    //base->B_b;//protected数据 在子类外是访问不了的
    base->B_c;
    //base->B_a;//private数据在子类外是访问不了的


    cout << "Hello World!" << endl;
    return 0;
}

案例2：保护继承（protected）

#include <iostream>

using namespace std;

class Base{
private:
    int B_a;
protected:
    int B_b;
public:
    int B_c;
};

class Son:protected Base{
    //父类中的public数据 在子类中 是protected
    //父类中的private数据 在子类中 是不可见的
    //父类中的protected数据 在子类中 是protected的
public:
    void func(){
       B_b = 100;
       //B_a = 300;在子类中private数据，不可见
       B_c = 300;//在子类中内部protected数据，可以直接访问

    }

};

int main(int argc, char *argv[])
{
    Son *base = new Son();
    //base->B_b;//protected数据 在子类外是访问不了的
    //base->B_c;//public数据 在子类外是访问不了的
    //base->B_a;//private数据在子类外是访问不了的


    cout << "Hello World!" << endl;
    return 0;
}

案例3：私有继承（private）

#include <iostream>

using namespace std;

class Base{
private:
    int B_a;
protected:
    int B_b;
public:
    int B_c;
};

class Son:private Base{
    //父类中的public数据 在子类中 是private
    //父类中的private数据 在子类中 是不可见的
    //父类中的protected数据 在子类中 是private
public:
    void func(){
       B_b = 100;
       //B_a = 300;在子类中private数据，不可见
       B_c = 300;//在子类中内部protected数据，可以直接访问

    }

};

int main(int argc, char *argv[])
{
    Son *base = new Son();//注意：B PRIVATE/protected 继承A，那么 A 的指针不能指向B
    //base->B_b;//protected数据 在子类外是访问不了的
    //base->B_c;//public数据 在子类外是访问不了的
    //base->B_a;//private数据在子类外是访问不了的


    cout << "Hello World!" << endl;
    return 0;
}

总结：
在这里插入图片描述

知识点3【继承中的构造和析构的顺序】

#include <iostream>

using namespace std;

class Base{
private:
    int B_a;
protected:
    int B_b;
public:
    int B_c;
    Base(){
        cout << "父类的无参构造" << endl;
    }
    ~Base(){
        cout << "父类的析构函数" << endl;
    }
};

class Son:private Base{
public:
    Son(){
        cout << "子类的构造函数" << endl;
    }
    ~Son(){
        cout << "子类的析构函数" << endl;
    }


};

int main(int argc, char *argv[])
{
    Son *base = new Son();
    delete base;
    return 0;
}

运行结果：
在这里插入图片描述

总结：
构造顺序：父类（基类）构造------->子类（派生类）构造
析构顺序：子类（派生类）---------> 父类（基类）析构

知识点4【子类中有父类、对象成员，构造和析构的顺序】

#include <iostream>

using namespace std;

class Other{
public:
    int O_a;
    Other(){
        cout << "对象的无参构造" << endl;
    }
    ~Other(){
         cout << "对象的析构函数" << endl;
    }
};

class Base{
private:
    int B_a;
protected:
    int B_b;
public:
    int B_c;
    Base(){
        cout << "父类的无参构造" << endl;
    }
    ~Base(){
        cout << "父类的析构函数" << endl;
    }
};

class Son:private Base{
private:
    Other other;
public:
    Son(){
        cout << "子类的构造函数" << endl;
    }
    ~Son(){
        cout << "子类的析构函数" << endl;
    }


};

int main(int argc, char *argv[])
{
    Son *base = new Son();
    delete base;
    return 0;
}

运行结果：
在这里插入图片描述

知识点5【详解子类中的构造】

1、子类会默认调用父类的无参构造
2、子类必须显式使用初始化列表调用父类的有参构造
调用形式：父类名称

Son(int a,int b):Base(a),b(b){
	
}

#include <iostream>

using namespace std;

class Other{
public:
    int O_a;
    Other(int a){
        this->O_a = a;
        cout << "对象的无参构造" << endl;
    }
    ~Other(){
         cout << "对象的析构函数" << endl;
    }
};

class Base{
private:
    int B_a;
protected:
    int B_b;
public:
    int B_c;
    Base(int a,int b){
        this->B_a = a;
        this->B_b = b;
        cout << "父类的有参构造" << endl;
    }
    ~Base(){
        cout << "父类的析构函数" << endl;
    }
};

class Son:public Base{
private:
    Other other;
public:
    Son(int a,int b, int c):Base(a,b),other(c){
        cout << "子类的有参构造" << endl;
        cout << this->other.O_a << endl;
        cout << this->B_b << endl;
    }
    ~Son(){
        cout << "子类的析构函数" << endl;
    }


};

int main(int argc, char *argv[])
{
    Son *base = new Son(10,20,30);
    delete base;
    return 0;
}

运行结果：
在这里插入图片描述

知识点6【父类和子类的同名成员变量处理】

1、当父类和子类成员变量同名时，在子类就近原则，选择本作用域的子类的成员
2、如果在子类中，必须使用父类中的同名成员，必须加上父类的作用域

#include <iostream>

using namespace std;

class Base{
public:
    int num;
    Base(int num){
        this->num = num;
        cout << "父类有参构造" << endl;
    }
    ~Base(){
        cout << "父类析构函数" << endl;
    }
};

class Son:public Base{
public:
    int num;
    Son(int num1,int num2):Base(num1),num(num2){
        cout << "父类有参构造" << endl;
    }

    void showNum(){
        //当父类和子类成员变量同名时，在子类就近原则，选择本作用域的子类的成员 
        cout << num << endl;
        //如果在子类中 必须使用父类中的同名成员 必须加上父类的作用域
        cout << Base::num << endl;
    }

    ~Son(){
        cout << "子类析构函数" << endl;
    }
};

int main(int argc, char *argv[])
{

    Son *son = new Son(100,200);
    son->showNum();
    delete son;
    return 0;
}

运行结果：
在这里插入图片描述
3、子类可以借助父类的共有方法间接的操作父类的私有数据（不可见的数据）

#include <iostream>

using namespace std;

class Base{
private:
    int num;

public:
    Base(int num){
        this->num = num;
        cout << "父类有参构造" << endl;
    }

    int getNum(){
        return this->num;
    }

    ~Base(){
        cout << "父类析构函数" << endl;
    }
};

class Son:public Base{
public:
    int num;
    Son(int num1,int num2):Base(num1),num(num2){
        cout << "父类有参构造" << endl;
    }

    void showNum(){
        //当父类和子类成员变量同名时，在子类就近原则，选择本作用域的子类的成员
        cout << num << endl;
        //如果在子类中 必须使用父类中的private成员 以借助父类的共有方法间接的操作父类的私有数据
        cout <<this->getNum()<< endl;
    }

    ~Son(){
        cout << "子类析构函数" << endl;
    }
};

int main(int argc, char *argv[])
{

    Son *son = new Son(100,200);
    son->showNum();
    delete son;
    return 0;
}

知识点7【父类和子类的同名成员函数处理】

#include <iostream>

using namespace std;

class Base1{
private:
    int num;

public:
    Base(int num){
        this->num = num;
        cout << "父类有参构造" << endl;
    }

    int getNum(){
        return this->num;
    }

    ~Base1(){
        cout << "父类析构函数" << endl;
    }
};

class Base{
public:
   void func(){
       cout << "父类void-func函数" << endl;
   }

   void func(int a){
       cout << "父类a-func函数" << endl;
   }
};



class Son:public Base{
public:
    void func(int a){
        cout << "子类a-func函数" << endl;
    }
};

int main(int argc, char *argv[])
{

    Son *son = new Son();
    son->func(100);
    //son->func();//err 一旦子类 实现了 父类的同名成员函数 将屏蔽所有父类同名成员函数
    //如果用户 必须要调用父类 的同名成员函数 必须加作用域
    son->Base::func();
    son->Base::func(200);
    delete son;
    return 0;
}

运行结果：
在这里插入图片描述

知识点8【继承中的静态成员特性】

#include <iostream>

using namespace std;

class Base1{
private:
    int num;

public:
    Base(int num){
        this->num = num;
        cout << "父类有参构造" << endl;
    }

    int getNum(){
        return this->num;
    }

    ~Base1(){
        cout << "父类析构函数" << endl;
    }
};

class Base{
public:

   static int num;
   static int data;
   static void showData(){
       cout << "父类静态成员函数" << endl;
   }
};

int Base::num = 200;
int Base::data = 100;

class Son:public Base{
public:
    static int num;
    static void showData(){
        cout << "子类静态成员函数" << endl;
    }

};

int Son::num = 300;

int main(int argc, char *argv[])
{

    Son *son = new Son();
    //Son 也拥有了静态成员data
    cout<< Son::data << endl;

    //父和子类静态成员同名,在子类中访问子类中的成员
    cout << Son::num <<endl;
    //父和子类 静态成员 同名 访问父类中的成员 必须加 Base::
    cout << Son::Base::num <<endl;

    //父和子类 同名静态成员函数 子类默认访问子类的静态成员函数
    Son::showData();
    //父和子类 同名静态成员函数 子类访问父类的静态成员函数 必须加 Base::
    Son::Base::showData();
    delete son;
    return 0;
}

运行结果：
在这里插入图片描述

知识点9【多继承】（了解）

多继承的格式：

class 子类：继承方式1 父类名1，继承方式2 父类名2，继承方式3 父类名3，...{
};
//表示子类 是由 父类名1,父类名2,父类名3...共同派生出来

 class Base1
{
public:
	int a;
};
class Base2
{
public:
	int b;
};
class Son:public Base1,public Base2
{
	//Son类 拥有了a b
};
int main(int argc, char *argv[])
{
	Son ob;
	ob.a = 100;
	ob.b = 200;
	return 0;
}

多继承容易产生二义性：（解决办法1 使用作用域）

 class Base1
{
public:
	int a;
};
class Base2
{
public:
	int a;
};
class Son:public Base1,public Base2
{
	//Son类 拥有了a b
};
int main(int argc, char *argv[])
{
	Son ob;
	ob.a = 100;err Base1 和 Base2中都有a成员同名
	//解决办法：加作用域
	ob.Base1::a = 100;
	ob.Base2::a = 200;
	return 0;
}

知识点10【菱形继承】

在这里插入图片描述
上述类图中，Teacher类和Student类都会继承People的成员，Doctor会继承Teacher类和Student类的成员，因此Doctor将会有两份继承自顶层父类People的成员。

class Animal
{
	public:
	int data;
};

class Sheep:public Animal
{
public:
};
class Tuo:public Animal
{
public:
};

class SheepTuo:public Sheep,public Tuo
{
public:
};
int main(int argc, char *argv[])
{
	SheepTuo st;
	//SheepTuo 从Sheep中继承data 从Tuo继承data 就产生二义性
	//st.data = 200;//err
	//第一种方式：加作用域解决
	st.Sheep::data = 200;
	st.Tuo::data = 300;

	return 0;
}

普通继承：

class Animal
{
public:
	int data;
}

在这里插入图片描述

class Sheep:public Animal
{
public:
};

在这里插入图片描述

 class Tuo:public Animal
{
public:
};

在这里插入图片描述

class SheepTuo:public Sheep,public Tuo
{
public:
};

在这里插入图片描述

知识点11【虚继承】（了解）

virtual修饰继承方式：

//继承的动作 虚继承
//父类：虚基类
class 子类:virtual public 父类
{
};

class Sheep:virtual public Animal
{
public:
};

在这里插入图片描述
vbptr（虚基类指针） 其中v是virtual 虚 b是base 基类 prt指针（vbptr指向虚基类表）
vbtable(虚基类表 ） 保存了当前的虚指针相对于虚基类的首地址的偏移量

class Tuo:virtual public Animal
{
public:
};

在这里插入图片描述
总结：之所以 产生 vbptr和vbtable 目的 保证 不管多少个继承 虚基类的数据只有一份。

class SheepTuo:public Sheep,public Tuo
{
public:
};

在这里插入图片描述
在这里插入图片描述
案例1:

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include<string.h>
using namespace std;

class Animal
{
public:
	int data;
};

class Sheep :virtual public Animal
{
public:
};
class Tuo :virtual public Animal
{
public:
};

class SheepTuo :public Sheep, public Tuo
{
public:
};
int main(int argc, char* argv[])
{
	SheepTuo 2;
	st.data = 200;

	//通过Sheep的vbptr 寻找vbptr距离虚基类首地址的偏移量
	//&st == vbptr
	//*(int *)&st sheep 的虚基类表的起始位置
	int off_set = (int)*((int*)(*(int*)&st) + 1);
	cout << off_set << endl;

	//通过sheep的vbptr 和 off_set定位虚基类的首地址
	 cout << ((Animal*)((char*)&st + off_set))‐>data << endl;

	return 0;

在这里插入图片描述
注意： 虚继承只能解决具备公共祖先的多继承所带来的二义性问题，不
能解决没有公共祖先的多继承的。
虚继承：不管继承多少次 虚基类 只有一份数据。

知识点12【多态的概述】

1、概念
多态是c++d的特征之一
多态的分类：静态多态（静态联编）、动态多态（动态联编）
静态多态（静态联编）：函数入口地址 是在 编译阶段 确定（运算符重载、函数重载）
动态多态（动态联编）：函数入口地址 是在 运行阶段 确定（虚函数）
2、引入
在这里插入图片描述

#include <iostream>

using namespace std;

class Animal{
public:
    void sleep(void)
    {
        cout<<"animal 动物在睡觉"<<endl;
    }
};

class Cat:public Animal{
public:
    void sleep(void)
    {
        cout<<"cat 喵喵在睡觉"<<endl;
    }
};

int main(int argc, char *argv[])
{
    //用基类（指针或引用） 保存 子类对象（向上转换）
    Animal *ob = new Cat();
    ob->sleep();
    Animal* &ob1 = ob;
    ob1->sleep();
    return 0;
}

运行结果：
在这里插入图片描述
总结：基类指针、引用只能访问子类对象中，基类部分数据
3、使用基类指针、引用访问子类对象中的成员方法（虚函数）
使用virtual修饰成员函数 该成员函数就是虚函数

class Animal{
public:
    virtual void sleep(void)
    {
        cout<<"animal 动物在睡觉"<<endl;
    }
};

在这里插入图片描述
vfptr虚函数指针 指向的是虚函数表（vftable）
vftable表存放的是 vfptr做保存的函数入口地址
注意：//如果 Animal没有涉及到继承 函数指针变量 就指向自身sleep

class Animal{
public:
    //虚函数 本质 是一个函数指针变量

    virtual void sleep(void)
    {
        cout<<"animal 动物在睡觉"<<endl;
    }
};

void test01(){
    //如果 Animal没有涉及到继承 函数指针变量 就指向自身sleep
    Animal ob;
    ob.sleep();
}

4、拥有虚函数的类 涉及得到继承
在这里插入图片描述

class Cat:public Animal{
public:
    virtual void sleep(void)
    {
        cout<<"cat 喵喵在睡觉"<<endl;
    }
};

void test01(){
    //如果 Animal没有涉及到继承 函数指针变量 就指向自身sleep
    Animal *ob = new Cat();
    ob->sleep();
}

总结：当虚函数涉及到继承的时候 子类 会继承 父类的（虚函数指针vfptr 虚函数表vftable）,编译器会将虚函数表中的函数入口地址 更新 成子类的 同名（返回值、参数都相同）的函数入口地址。如果基类指针、引用 访问虚函数的时候 就会 间接的调用 子类的虚函数.
5、虚函数的应用案例（基类指针、引用 作为函数的参数）
在这里插入图片描述

#include <iostream>

using namespace std;
class Base
{
public:
virtual void sleep(void)
{
	cout<<"父亲在睡觉"<<endl;
}
};

class Son1:public Base
{
public:
	void sleep(void)
{
cout<<"Son1在安静的睡觉"<<endl;
}
};
class Son2:public Base
{
public:
	virtual void sleep(void)
	{
		cout<<"Son2在轻度的睡觉"<<endl;
	}
};
class Son3:public Base
{
public:
virtual void sleep(void)
{
cout<<"Son3在雨声般的睡觉"<<endl;
}
};
class Son4:public Base
{
public:
virtual void sleep(void)
{
	cout<<"Son4在鼾声如雷"<<endl;
}
};

//以基类指针作为函数的参数 函数可以操作该基类派生出的任意子类对象
void sleepFun(Base &ob)
{
	ob.sleep();
}

int main(int argc, char *argv[])
{
	Son1 ob1;
	Son2 ob2;
	Son3 ob3;
	Son4 ob4;
	sleepFun(ob1);
	sleepFun(ob2);
	sleepFun(ob3);
	sleepFun(ob4);
	return 0;
}

运行结果：
在这里插入图片描述
问题:C++的动态捆绑机制是怎么样的？
首先，我们看看编译器如何处理虚函数。当编译器发现我们的类中有虚函数的时候，编译器
会创建一张虚函数表，把虚函数的函数入口地址放到虚函数表中，并且在类中秘密增加一个
指针，这个指针就是vpointer(缩写vptr)，这个指针是指向对象的虚函数表。在多态调用的
时候，根据vptr指针，找到虚函数表来实现动态绑定。

知识点13【虚析构】

1、知识点的引入

#include <iostream>

using namespace std;

class Animal{
private:
    int name;
    int age;
public:
    //虚函数 本质函数指针 不涉及继承时 指向自身函数（sleep）
    virtual void sleep(){
        cout << "动物在睡觉" << endl;
    }

    Animal(){
      cout << "Animal构造函数" << endl;
    }

    ~Animal(){
        cout << "Aniaml析构函数" << endl;
    }
};


class Cat:public Animal{
public:
    //虚函数 设计到继承 指针子类的sleep
    virtual void sleep(){
        cout << "Cat 在睡觉" << endl;
    }
    Cat(){
        cout << "Cat构造函数" << endl;
    }
    ~Cat(){
        cout << "Cat析构函数" << endl;
    }

};


int main(int argc, char *argv[])
{
    //通过基类 指针、引用 访问子类的成员函数    
    Animal *ob = new Cat();
    ob->sleep();

    //出现的问题：只能释放 父类析构
    delete ob;
    return 0;
}

运行结果：
在这里插入图片描述
原因分析：
在这里插入图片描述

2、解决上面的问题 虚析构（虚函数）

虚析构：通过基类指针、引用释放子类的所有空间
虚析构：在析构函数前加virtual修饰

#include <iostream>

using namespace std;

class Animal{
private:
    int name;
    int age;
public:
    //虚函数 本质函数指针 不涉及继承时 指向自身函数（sleep）
    virtual void sleep(){
        cout << "动物在睡觉" << endl;
    }

    Animal(){
      cout << "Animal构造函数" << endl;
    }

    virtual ~Animal(){
        cout << "Aniaml析构函数" << endl;
    }
};


class Cat:public Animal{
public:
    //虚函数 设计到继承 指针子类的sleep
    virtual void sleep(){
        cout << "Cat 在睡觉" << endl;
    }
    Cat(){
        cout << "Cat构造函数" << endl;
    }
    virtual ~Cat(){
        cout << "Cat析构函数" << endl;
    }

};


int main(int argc, char *argv[])
{
    //通过基类 指针、引用 访问子类的成员函数
    Animal *ob = new Cat();
    ob->sleep();

    //如果设置成了 虚析构 就可以释放 子类以及父类的构造函数
    delete ob;
    return 0;
}

运行结果：
在这里插入图片描述
原理分析：
在这里插入图片描述

知识点14【纯虚函数和抽象类】

1、纯虚函数和抽象类格式

纯虚函数格式：virtual void sleep(void) = 0;

如果一个类中拥有纯虚函数，那么这个类就是抽象类，抽象类不能实例化对象。

void test02(){
	//Animal 抽象类 不能实例化 一个对象
	//Animal ob;//err
}

2、 抽象类派生出子类，那么子类必须实现所有的纯虚函数

#include <iostream>

using namespace std;

class Animal{
private:
    int name;
    int age;
public:
    //纯虚函数
    //如果一个类中拥有 纯虚函数 那么这个类 就是抽象类
    //抽象类 不能实例化对象
    virtual void sleep()= 0;

    Animal(){
      cout << "Animal构造函数" << endl;
    }

    virtual ~Animal(){
        cout << "Aniaml析构函数" << endl;
    }
};


class Cat:public Animal{
public:
    在子类中 必须实现 基类的纯虚函数
    virtual void sleep(){
        cout << "Cat 在睡觉" << endl;
    }
    Cat(){
        cout << "Cat构造函数" << endl;
    }
    virtual ~Cat(){
        cout << "Cat析构函数" << endl;
    }

};


int main(int argc, char *argv[])
{
    //通过基类 指针、引用 访问子类的成员函数
    Animal *ob = new Cat();
    ob->sleep();

    //出现的问题：只能释放 父类析构
    delete ob;
    return 0;
}

案例：饮料制作
在这里插入图片描述


//抽象类 提供一个固定的流程 接口
class AbstractDrinking{
public:
    //烧水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //倒入杯中
    virtual void PourInCup() = 0;
    //加入辅料
    virtual void PutSomething() = 0;
    //规定流程
    void MakeDrink(){
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};


//制作咖啡
class Coffee : public AbstractDrinking{
public:
    //烧水
    virtual void Boil(){
        cout << "煮农夫山泉!" << endl;
    }
    //冲泡
    virtual void Brew(){
        cout << "冲泡咖啡!" << endl;
    }
    //倒入杯中
    virtual void PourInCup(){
        cout << "将咖啡倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething(){
        cout << "加入牛奶!" << endl;
    }
};

//制作茶水
class Tea : public AbstractDrinking{
public:
    //烧水
    virtual void Boil(){
        cout << "煮自来水!" << endl;
    }
    //冲泡
    virtual void Brew(){
        cout << "冲泡茶叶!" << endl;
    }
    //倒入杯中
    virtual void PourInCup(){
        cout << "将茶水倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething(){
        cout << "加入食盐!" << endl;
    }
};

//业务函数
void DoBussiness(AbstractDrinking* drink){
    drink->MakeDrink();
    delete drink;
}

void test01(){
    //制作 咖啡
    DoBussiness(new Coffee);

    //制作 茶水
    DoBussiness(new Tea);
}

int main(int argc, char *argv[])
{
    test01();
    return 0;
}

`运行结果：
在这里插入图片描述

知识点15【纯虚析构】

纯虚函数：不需要实现函数体

//纯虚析构函数
class B{
	public:
	// 1、virtual修饰 加上=0
	//如果为纯虚析构函数，则不能实例化对象
	virtual ~B() = 0;
	};

//2、必须实现 析构函数的函数体
B::~B(){}
//原因：通过基类指针 释放子类对象时 先调用子类析构 再父类析构（如果父类的析构不实现，无法实现调用）

知识点15【虚函数 纯虚函数 虚析构 纯虚析构】（重要）

1、虚函数：只有virtual修饰函数体（作用于成员函数）

目的：通过基类指针或引用操作子类方法

class Base{
public:
	virtual void my_fun(){
		//有函数体
	}
};

2、纯虚函数：virtual修饰，加=0，没有函数，所在的类为抽象类

目的：为子类提供固定的流程和接口

class Base{
public:
	virtual my_fun(void)=0;
}

3、虚析构：virtual修饰，类中的析构函数

目的：为了解决基类的指针派生类对象，并用基类的指针删除派生类对象。

class Base{
public:
	virtual ~Base(){
		//有函数体
	}
}

4、纯虚析构：virtual修饰加=0，必须实现析构的函数体

目的：用基类的指针删除派生类对象、同时提供固定接口

class Base
{
public:
	virtual ~Base()=0;
}
Base::~Base(){
	//函数体
}

知识点16【重写 重载 重定义】

1、重载

同一作用域的同名函数、参数个数、参数顺序、参数类型不同（和函数返回值没有关系）
const也可以作为重载条件

int fun(int a){}
int fun(int b,int c){}
int fun(char b,int c){}
int fun(const char b,int c){}

2、重定义（隐藏）

有继承
子类（派生类）重写父类（基类）的同名成员。（非virtual函数）

class Base{
public:
	void fun(int){}
	void fun(int,int){}
}
class Son:public Base{
public:
	//当派生类重新定义函数时，参数可以不同
	void fun(){}//重定义
}

3、重写（覆盖）

有继承
子类（派生类）重写父类（基类）的virtual的函数。
函数返回值，函数名字，函数参数，必须和基类中的虚函数一致。

class Base{
public:
	virtual void fun(int){}
}
class Son:public Base{
public:
	virtual void fun(int){}//重写
}
米兰的小红黑
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++中继承与组合的区别详细解析
01-01
C++的“继承”特性可以提高程序的可复用性。正因为“继承”太有用、太容易用，才要防止乱用“继承”。我们要给“继承”立一些使用规则： 一、如果类A 和类B 毫不相关，不可以为了使B 的功能更多些而让B 继承A 的功能...
C++派生类和重载赋值运算符以及和复制构造函数的调用运行逻辑实例
xuchaoxin1375的博客
10-03 508
//program 14.10.1.cpp 派生类和赋值运算符 #include <iostream> using namespace std; class CBase { int a; public: CBase(int a_=0) :a(a_) { cout << "constructor_of_CBase is called!" << endl; cout << "a=" << a << endl;
C++ 核心篇 8 之类与对象 - 继承
weixin_51927215的博客
10-23 537
C++ 自学继承的基本语法继承方式继承中的对象模型构造和析构顺序同名成员处理同名静态成员处理继承语法 继承的基本语法 继承：为了实现类似于网站公共头部和公共底部，用来避免代码冗余 继承的语法：class 子类 :继承方式 1 父类 1,继承方式 2 父类 2… 别名：父类也称基类，子类也称派生类 #include <iostream> using namespace std; // 页面头部 class Head { public: // 构造函数 Head(){ cout &l
C/C++：newcode经典例子
猴子居士的博客
03-19 462
题目描述 给定一个 nowcoder.txt文件，其中有3列信息，如下实例，编写一个sheel脚本来检查文件第二列是否有重复，且有几个重复，并提取出重复的行的第二列信息： 实例： 20201001 python 99 20201002 go 80 20201002 c++ 88 20201003 php 77 20201001 go 88 20201005 shell 89 20201006 java 70 20201008 c 100 20201007 java 88 20201006 go 97 结果
C/C++编程：继承构造函数
OceanStar的博客
04-29 3226
引入 在传统C++中，如果派生类要使用使用基类的构造函数，通常需要在构造函数中显式声明： struct A{ public: A(int i) {} }; struct B : A{ B (int i) : A(i){} }; B派生自A，B又在构造函数中调用A的构造函数，从而完成构造函数的传递。但是如果基类中有大量的构造函数时，可能需要这样写： struct A{ A(int i){}; A(double d, int i){} A(float f, int i, con
C++类和对象（三）
weixin_58004346的博客
07-12 606
在创建对象时，编译器会通过调用构造函数，给对象中的各个成员变量一个合适的初始值： 虽然通过调用上述的构造函数后，对象中的每个成员变量都有了一个初始值，但是构造函数中的语句只能将其称作为赋初值，而不能称作为初始化。因为初始化只能初始化一次，而构造函数体内可以进行多次赋值。 接下来验证一下： const 修饰的变量必须在定义前初始化。 1.2初始化列表 初始化列表 ：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式。 注意事项： 一、每个成员变量在初始化列表中
C++ 中继承与动态内存分配的详解
12-26
C++ 中继承与动态内存分配的详解 继承是怎样与动态内存分配进行互动的呢？例如,如果基类使用动态内存分配，并重新定义赋值和复制构造函数，这将怎样影响派生类的实现呢？这个问题的答案取决于派生类的属性。如果派生...
C++ 中私有继承的作用
12-25
C++ 中私有继承的作用 私有继承的 第一个规则：和公有继承相反，如果两个类之间的继承关系为私有，编译器一般不会将派生类对象转换成基类对象。 第二个规则: 从私有基类继承而来的成员都成为了派生类的私有成员，...
C++（1）
qq_42447739的博客
03-08 858
#include<iostream> using namespace std; int main(){ cout << "hello world"; return 0; } 上面是C++的第一个程序 分析： #include<iostream> （1）为预处理命令，其中 <> 中的为头文件（提供输入/输出的所需要的一些信息） //为命名空间 using namespace std; //可以通过#include"std",表示要用到命名空间std中内
【星海出品】C++类的学习（通过代码）
weixin_41997073的博客
07-21 365
daydayup
day9 9C++面向对象进阶
LH is programming hard
03-31 258
C++ 面向对象进阶，拷贝构造函数、重载赋值运算符、转换构造函数、类型转换函数、C++的类型转换运算符 拷贝构造函数 在 C++ 中，拷贝是指用已经存在的对象创建出一个新的对象；从本质上讲，对象也是一份数据，因为它会占用内存； 严格来说，对象的创建包括两个阶段，首先要分配内存空间，然后再进行初始化： 分配内存：很好理解，就是在堆区、栈区或者全局数据区留出足够多的字节； 这个时候的内存还比较“原始”...
C++课堂学习(8)
weixin_43853077的博客
11-10 142
这节课主要讲继承与派生 代码： 1. #include<iostream> using namespace std； class CBaseClass//基类 { private: int a; int b; public: CBaseClass():a(0),b(0){} CBaseClass(int a1，int b1):a(a1),b(b1){} void Displa...
从c到c++学习
zhaicheng55的博客
08-04 544
有C语言基础的学习c++的方案，在对比中学习c++。用来写leetcode而学，后期随着刷题还会不断更新c++刷LeetCode常用的语法和数据类型
对继承的理解（新手教程）
ljl1064954803的博客
12-12 471
Java继承（1） 继承Java继承（1）继承的概念继承的特点==这只是一部分哦，后面还会继续更新！== 继承的概念 Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。 继承的特点 1、继承的关键字为extends 试举一例吧： class Dad{ public void Sleep(){} public void Eat(){} } class Son extends Dad{ public void
C++ 多继承
yyf_blog
04-15 716
写在前面 在腾讯面试时，面试官问： C++里面子类可以继承多个父类吗？（可以） 子类如果继承多个父类需要注意什么问题？（有点不知从何答起） 父类A，父类B，子类C继承父类A和父类B，父类A和父类B中有都有函数fun，在子类C中如何处理？ 多继承 多继承是指从多个直接基类中产生派生类，多继承的派生类继承了所有父类的成员。 多继承容易出现的问题： 命名冲突（成员变量名、成员函数名） 类A派生出类...
C++考试
weixin_69939913的博客
05-16 538
考试....
7.继承与多态
剑雨巍巍的博客
11-02 279
设计继承时,把共同的程序代码放入某个类,告诉其他类:此类是它们的父类 子类继承父类意味着继承了父类的成员,类的成员指的是实例变量和方法,但是子类可以加入自己的方法和实例变量,可以覆盖掉继承自父类的方法,实例变量不会被覆盖. 设计父类,辨别出所有子类共同的,抽象的特征,以此为基础设计. 当调用子类覆盖的父类方法时,会调用与该对象类型最接近的方法,即最低阶的会胜出,即层次树最下面. 继承关系通
C语言第二十五讲
Gwenrolynksxx的博客
11-30 176
/在每一轮交换后完成输出，是在内层完成后的外层。空的时候又不初始化会出现“unknown size”错误，因为系统不知道给b分配多少空间。第一个参数只是知道数组的首地址在哪里，第二个参数是控制元素个数。//两个下标，分别是行数和列数，一共要分配12个空间。在一维数组想省略元素个数（下标），一定要初始化。二维数组想省略元素个数（下标）至少有一个不为空。仍然代表的是数组的首地址 &a[0][0]显示的是在实际上排一行中的第几个位置。列 还是基于a[3][4]的例子。行下标表示前面有几个完整的行。
C++入门
wcsq0523的博客
03-22 1890
C++入门
c++中继承
最新发布
05-24
C++中的继承是一种面向对象编程中的重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的成员变量和成员函数。 在C++中，使用关键字`class`定义一个类，使用关键字`public`、`private`和`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值