浅析继承

说到继承

那么大部分人首先会问 什么是继承呢？

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

一个派生类可以从一个基类派生，也可以从多个基类派生。

从一个基类派生的继承称为单继承；从多个基类派生的继承称为多继承。

继承的格式如下：

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

经过内存窗口 我们可以看到 大概的地址分布情况为：