那么大部分人首先会问 什么是继承呢?
一个派生类可以从一个基类派生,也可以从多个基类派生。
从一个基类派生的继承称为单继承;从多个基类派生的继承称为多继承。
继承的格式如下:
class<派生类名>:<继承方式><基类名>{
<派生类新定义成员>
};
继承分为三种方式:公有继承,保护继承,私有继承。
三种继承的不同:
其中通过保护继承 我们在派生类中可以访问基类的保护成员 但是保护成员却不能在类外访问。
所以能看出来,保护权限是因为继承才出现的。
那么问题又来了 继承关系中怎么调用构造函数以及析构函数的呢?
我们用图来表示:
那么理所当然析构函数的调用就是相反的
我们用代码来验证:
class Base
{
public:
Base()//2
{
cout<<"Base()"<<endl;
}
~Base()//4
{
cout<<"~Base()"<<endl;
}
int data1;
public:
int _pub;
protected:
int _pro;
private:
int _pri;
};
class Derived:public Base
{
public:
Derived()//1
{
cout<<"Derived()"<<endl;
}
~Derived()//3
{
cout<<"~Derived()"<<endl;
}
int _data2;
};
void FunTest()
{
Derived d;
};
我们要注意
1.继承体系中基类和派生类属于两个不同的作用域
2. 子类和父类中有同名成员,子类成员将屏蔽父类对成员的直接访问。
例如:
class B
{
public:
int _data;
};
class D:public B
{
public:
int _data;
};
void FunTest()
{
B b;
D d;
d._data = 10;//由于_data在基类和派生类中重复定义,派生类对象会屏蔽基类访问派生类的_data;
d.B::_data = 20;//若重复定义可通过此方法访问基类_data;
}
int main()
{
FunTest();
system("pause");
return 0;
}
继承与转换--赋值兼容规则--public继承
1.子类对象可以赋值给父类对象(切割/切片)
2.父类对象不能赋值给子类对象
3.子类的指针/引用不能指向父类对象(可以通过强制类型转换完成)
4.父类的指针/引用可以指向子类对象
class B
{
public:
int _data;
};
class D:public B
{
public:
int _data;
};
void FunTest()
{
B b;
D d;
b = d;//派生类可以给基类赋值
//d = b;//基类不能给派生类赋值
B *pb = &b;
pb = &d;//父类的指针/引用可以指向子类对象
D *pd = &d;
//pd = &b;//子类的指针/引用不能指向父类对象
pd = (D*)&b;//强制类型转换可以 但是不安全
}
友元与继承
友元关系不能继承,也就是说基类友元不能访问子类私有和保护成员。
class Person
{
friend void Display();
protected:
int data1 ;
};
class Student: public Person
{
public :
int data2 ;
};
void Display(Person &p , Student &s)
{
cout<<p.data1<<endl;//不能访问因为是保护类型
cout<<s.data1<<endl;//不能访问有缘类不能继承
cout<<s.data2<<endl;
}
void FunTest()
{
Person p;
Student s;
Display (p, s);
}
*静态成员可以继承
class B
{
public:
static int _count;
};
int B::_count =0;
class D:public B
{
};
void FunTest()
{
D d;
d._count = 10;
cout<<d._count<<endl;
}
接下来我们讲一下 继承的分类
继承大体分为三类 单继承 多继承 菱形(钻石)继承
我们先讲单继承
1.单继承
一个派生类只有一个直接基类时,这种继承称为单继承。
2.多继承
一个子类有两个或以上直接父类时称这个继承关系为多继承。
3.菱形继承
//菱形继承
class B
{
public:
int data1;
};
class C1:public B
{
public:
int data2;
};
class C2:public B
{
public:
int data3;
};
class D:public C1,public C2
{
public:
int data4;
};
void FunTest()
{
D d;
d.data1 = 10; //编译器会提示访问不明确 就是说编译器并不知道访问data1为哪个类中的。会导致存储有冗余并且存在二义性。
d.data2 = 20;
d.data3 = 30;
d.data4 = 40;
}
派生类中有两个B类对象data1,在菱形继承中会产生二义性和数据冗余的问题
图解如下:
那么怎么解决这个问题呢?
解决方法:1.显示指定访问的哪个基类成员
2.虚拟继承
虚拟继承:(类的大小+4-----指针)
虚拟继承:存放一个地址 存放偏移量
class B
{
public:
int _data1;
};
class c1:virtual public B//虚拟继承
{
public:
int _data2;
};
class c2:virtual public B//虚拟继承
{
public:
int _data3;
};
class D:public c1,public c2
{
public:
int _data4;
};
void FunTest()
{
D d;
d._data1 = 10;
d._data2 = 20;
d._data3 = 30;
d._data4 = 40;
}
经过内存窗口 我们可以看到 大概的地址分布情况为: