您的位置:首页 > 新闻 > 会展 > 初始c++的继承

初始c++的继承

2024/11/13 16:27:48 来源:https://blog.csdn.net/nainaire/article/details/142284680  浏览:    关键词:初始c++的继承

概念:

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用,继承是类设计层次的复用

格式:

//    派生类/子类    继承方式    基类/父类
class class_name1 : public   class_name2
{
public: int a;
};

子类继承了父类全部的函数和变量吗?

不一定(子类访问父类成员的层面看,),要看继承方式 和 外界对父类中函数和变量的访问权限(就是访问限定符)

子类实际上从父类拿到的资源(函数和变量)要经过继承方式和这个资源在父类里是被“public ,  private, protected ” 中哪个限定符修饰,的双重限制,

子类访问父类的成员:

总结:

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私 有成员还是被继承到了派生类对象中,但是语法上限制派生类对象不管在类里面还是类外面 都不能去访问它。(这是很显而易见的事,毕竟你不会闲的没事在继承创建子类的时候还要把private的资源剔除,而且说不定父类的还有用到这个资源的public函数,后续提到的子类的构造也可对此印证,当然最好自己写个调试看看)

2. 基类private成员在派生类中是不能被访问,如果基类成员不想在类外直接被访问,但需要在 派生类中能访问,就定义为protected。可以看出保护成员限定符是因继承才出现的

3. 实际上面的表格我们进行一下总结会发现,基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符,继承方式),public > protected > private。

4. 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,不过最好显示的写出继承方式。

5. 在实际运用中一般使用都是public继承,几乎很少使用protetced/private继承,也不提倡 使用protetced/private继承,因为protetced/private继承下来的成员都只能在派生类的类里 面使用,实际中扩展维护性不强。

子类和父类的类型转换: 

父类转子类,要重载 = 操作符, 

子类转父类,“ 切片 ” 

#define _CRT_SECURE_NO_WARNINGS 1
#include<string>
using namespace std;
class Person
{
protected:string _name; // 姓名string _sex;  // 性别int _age;// 年龄
};
class Student : public Person
{
public:int _No; // 学号
};
void Test()
{Student sobj;// 1.子类对象可以赋值给父类对象/指针/引用Person pobj = sobj;Person* pp = &sobj;Person& rp = sobj;//2.父类对象不能赋值子类对象sobj = pobj;// 3.父类的指针可以通过强制类型转换赋值给子类的指针pp = &sobj;Student * ps1 = (Student*)pp; // 这种情况转换时可以的。 因为这个指针本身指向的就是一个子类对象ps1->_No = 10;pp = &pobj;Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以,但是会存在越界访问的问题ps2->_No = 10;
}
int main()
{Test();return 0;
}

隐藏 / 重定义

1. 子类和父类中有同名成员,子类成员将屏蔽父类的同名成员的直接访问,这种情况叫隐藏, 也叫重定义。(在子类成员函数中,可以使用 父类::父类成员 显示访问)

2.只需要函数名相同就构成隐藏。

class A 
{
public:void func(int a = 1) {cout << "void func(int a = 1)";}
private:int a;
};
class B :public A 
{
public:void func() {cout << "void func()";}
private:int b;
};
int main()
{//Test();B b;b.A::func(1);return 0;
}

总结:

编译器是个偷懒的小伙,你指定它去找,你不指定,它只会找到能交差的就回来。

子类的默认成员函数行为逻辑:

 

子类对象初始化先调用父类构造再调子类构造。

子类对象析构清理先调用子类析构再调父类的析构。

子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员

class A 
{
public:void func(int a = 1) {cout << "void func(int a = 1)";}A(int a) {cout << "A(int a) ";}A& operator=(A& a) {cout << "A& operator=(A& a)";}A(A& a) {;}
private:int a;
};
class B :public A 
{
public:B(B& b) {}void func() {cout << "void func()";}B& operator=(B& b) {cout << "阿巴阿巴";}B() :A(1),b(2){}private:int b;
};
int main()
{B b;b.A::func(1);return 0;
}

总结,相对而言,构造要求的更严格一些,operator= 要求低。

继承与友元:

友元关系不能继承,也就是说父类友元不能访问子类私有和保护成员

继承与静态成员:

父类定义了static静态成员,则整个继承体系里面只有一个这样的成员。无论派生出多少个子类,都只有一个static成员实例。

菱形继承和菱形虚拟继承:

简单的,博主自己给自己写的。

菱形继承有数据冗余和二义性,需要虚拟继承,

虚拟继承 :virtual public ...

借助虚基表指针,利用表里存的偏移量来找继承的公共的那部分。

到此结束,终于写完了。

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com