C++中继承的有关知识

1、继承的概念

 在C++中所谓的继承就是在一个已存在的类的基础上建立一个新的类。已存在的类称为“基类”或者“父类”，新建立的类称为“派生类”或者“子类”，一个新类从已有的类那里获得其已有特性，这种现象称为类的继承，类的继承是用已有的类来建立专用类的编程技术。

 class Base//基类Base{                                
Public：
int _pub;
protected:
int _pro;
private:
int _pri;
};
class Derived:public Base       
{
public:
int _dpub;
}

 

2.继承限定符和访问限定符

 

  1.公有继承（public）

   例如：

 

class Base//基类Base
{
Public：
int _pub;
protected:
int _pro;
private:
int _pri;
};
class Derived:public Base //派生类Derived公有继承基类Base的所有成员
{
public:
Void fun()
{
_pub = 1;//派生类中可以访问基类中的公有成员变量
_pro = 2;//派生类中可以访问基类中的保护成员变量
_pri = 3;//派生类继承了积累的私有成员但不可见
}
};

 2.私有继承（private）

class Base//基类Base
{
public:
int _pub;
protected:
int _pro;
private:
int _pri;
};
 
class Derived:protected Base //派生类Derived保护继承基类Base
{
public:
Void fun()
{
_pub = 1;
_pro = 2;
_pri = 3;
//私有基类的公有成员和保护成员在派生类中的访问属性相当于派生类中的私有成员，即派生类的成员函数能访问他们，而派生类外中不能访问他们，私有基类的私有成员在派生类中成为不可访问的成员
}
};

  3.保护继承（protected）

class Base
{
public:
int _pub;
protected:
int _pro;
private:
int _pri;
};
 
class Derived:private Base 
{
public:
Void fun()
{
_pub = 1;
_pro = 2;
_pri = 3;
}
//保护基类的公有成员和保护成员在派生类中都成了保护成员，其私有成员仍为基类私有，也就是把基类原有的公有成员也保护起来，不让在类外任意访问。
}；

 

 

                       基类成员在派生类中的访问属性表

在基类的访问属性	继承方式	在派生类中的访问属性
Private(私有)	Public（公有）	不可访问
Private(私有)	Private(私有)	不可访问
Private(私有)	Protected（保护）	不可访问
Public（公有）	Public（公有）	Public（公有）
Public（公有）	Private(私有)	Private(私有)
Public（公有）	Protected（保护）	Protected（保护）
Protected（保护）	Public（公有）	Protected（保护）
Protected（保护）	Private(私有)	Private(私有)
Protected（保护）	Protected（保护）	Protected（保护）

 

                            派生类中成员的访问属性

派生类中的访问属性	在派生类中	在派生类外	在下一层公有派生类中
Public（公有）	√	√	√
Protected（保护）	√	×	√
Private(私有)	√	×	×

 

3.派生类的六个默认成员函数

 

继承关系中构造函数和析构函数的调用顺序

 

基类构造函数->派生类构造函数

派生类析构函数->基类析构函数

 

注意：

     1.基类没有缺省函数，派生类必须在初始化列表显示给出基类名和参数列表；

     2.基类没有定义构造函数，派生类也不用定义，全部使用缺省的构造函数；

     3.基类定义了带形参表的构造函数，派生类也一定要定义构造函数。

用代码验证调用顺序如下：

 

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. 子类和父类中有同名成员，子类成员将屏蔽父类对成员的直接访问。（在子类成员函数中，可以使用 基类::基类成员 访问）--隐藏 --重定义

3. 注意在实际中在继承体系里面最好不要定义同名的成员

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

赋值兼容规则——————（必须是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;
pb->_data = 30;//可以强制类型转化，但是不安全，有可能造成程序崩溃
}

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

class B
{
friend void Show(B &b , D &s);
protected :
int _data1 ;
};
class D: public B
{
protected :
int _data2 ;
}
void Show(B &b , D &d)
{
cout<<b._data1<<endl;
cout<<d._data1<<endl;//无法访问protected成员，因为友元关系未继承
cout<<d._data2<<endl;
}
void TestPerson1()
{
B b;
D d;
Show( b, d);
}
 
*静态成员可以继承
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.单继承

 一个派生类只有一个直接基类时，这种继承称为单继承

class B
{
public:
int data1;
};
class C:public B
{
public:
int data2;
};

</pre><p></p><p>2.多继承</p><p>一个子类有两个或以上直接父类时称这个继承关系为多继承</p><p></p><pre code_snippet_id="1969784" snippet_file_name="blog_20161106_11_5057542" name="code" class="html">class B1
{
public:
int data1;
};
class B2
{
public:
int data2;
};
class D:public B1,public B2
{
public:
int data3;
};
 
 
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:
 
};
 

继承对象模型

 

派生类中有两个B类对象_data1,在菱形继承中会产生二义性和数据冗余的问题

解决方法：1.显示指定访问的哪个基类成员

          2.虚拟继承

虚拟继承：（类的大小+4-----指针）

class B
{
public:
int _data1;
};
 
class C: public B//sizeof(c) = 4;
{
 
};
 
 
class C:virtual public B//sizeof(c) = 8;
{
public:
int _data2;
 
};
 

虚拟继承解决二义性问题：（使用地址偏移量）

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 = 1;
d._data2 = 2;
d._data3 = 3;
d._data4 = 4；
}

菱形继承解决二义性问题时的对象模型

 

从内存中可看出菱形继承解决二义性时的参数布局

 

 以上编译环境：vs2010