继承
继承（Inheritance）是面向对象程序设计（Object Oriented Programming-OOP)中软件重用的关键技术。继承机制使用已经定义的类作为基础建立新的类定义，新的类是原有类的数据及操作与新类所增加的数据及操作组合。新的类把原有的类作为基类引用，而不需要修改原有类的定义。新定义的类作为派生类引用。这种方式减少代码数量，让代码简洁，易懂。
继承：在已有类的基础上创建新类的过程
一个 B 类继承A类，或称从类 A 派生类 B
类 A 称为基类（父类），类 B 称为派生类（子类）
类继承关系的语法形式
class 派生类名 : 基类名表
{
数据成员和成员函数声明
};
基类名表 构成
访问控制 基类名1， 访问控制 基类名2，… ， 访问控制 基类名n
访问控制 表示派生类对基类的继承方式，使用关键字：
public 公有继承 //最常用的
继承基类中的保护成员和公有成员，成为派生类中的保护成员和公有成员。
private 私有继承 //基本不用
继承基类中的保护成员和公有成员，成为派生类中的私有成员
protected 保护继承
★不论种方式继承基类，派生类都不能直接使用基类的私有成员
★省略访问控制符时，默认私有继承
派生类的生成过程经历了三个步骤：
●吸收基类成员（全部吸收(构造、析构除外),但不一定可见）
在C++的继承机制中，派生类吸收基类中除构造函数和析构函数之外的全部成员。但是私有成员不能继承。
●改造基类成员
通过在派生类中定义同名成员（包括成员函数和数据成员）来屏蔽（隐藏，这一实现需要函数的返回值 ，参数，名称全部相同，否则相当于重载而不是屏蔽）在派生类中不起作用的部分基类成员。
●添加派生类新成员
仅仅继承基类的成员是不够的，需要在派生类中添加新成员，以保证派生类自身特殊属性和行为的实现。
派生类拥有基类中除去去私有限定之外的所有数据成员与成员函数。
重名成员的处理
派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽（hide）了基类的同名成员，但是在派生类中用类名限定符使用基类的同名成员，显式地使用类名限定符：
类名 :: 成员
派生类中静态成员的访问
基类定义的静态成员，将被所有派生类共享（基类和派生类共享基类中的静态成员）
根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质
派生类中访问静态成员，用以下形式显式说明：
类名 :: 成员
或通过对象访问 对象名 . 成员
初始化的处理
在创建派生类对象时用指定参数调用基类的构造函数来初始化派生类继承基类的数据
派生类构造函数声明为
派生类构造函数 ( 变元表 ) : 基类 ( 变元表 ) , 对象成员1( 变元表 ) …对象成员n ( 变元表 ) ；
构造函数执行顺序：基类->对象成员->派生类。
注意，积累中没有无参构造函数时，派生中必须写有参构造函数，完成基类的构造。
派生类构造函数和析构函数的使用原则
l 基类的构造函数和析构函数不能被继承
l 如果基类没有定义构造函数或有无参的构造函数，派生类也可以不用定义构造函数
l 如果基类无无参的构造函数，派生类必须定义构造函数
l 如果派生类的基类也是派生类，则每个派生类只负责直接基类的构造
l 派生类是否定义析构函数与所属的基类无关
顺序总结
（1）当派生类中不含对象成员时
●在创建派生类对象时,构造函数的执行顺序是：基类的构造函数→派生类的构造函数；
●在撤消派生类对象时,析构函数的执行顺序是：派生类的析构函数→基类的析构函数。
（2）当派生类中含有对象成员时
●在定义派生类对象时，构造函数的执行顺序：基类的构造函数→对象成员的构造函数→派生类的构造函数；
●在撤消派生类对象时，析构函数的执行顺序：派生类的析构函数→对象成员的析构函数→基类的析构函数。
#include<iostream>
#include<iomanip>
using namespace std ;
class Point
{
public:
Point( int = 0, int = 0 ) ; // 带默认参数的构造函数
void setPoint( int, int ) ; // 对点坐标数据赋值
int getX() const
{
return x ;
}
int getY() const
{
return y ;
}
friend ostream&operator<< (ostream &, const Point &);
protected:
int x, y; // Point类的数据成员
};
class Circle : public Point
{
public:
Circle(double r=0.0, int x=0,int y=0); // 构造函数
void setRadius(double); //置半径*/
double getRadius() const; //返回半径
double area() const; // 返回面积
friend ostream&operator<< (ostream &, const Circle &); //友元函数
protected:
double radius; // 数据成员，半径
};
class Cylinder:public Circle
{
public:
Cylinder(double h=0.0, doubler=0.0, int x=0, int y=0); //构造函数
void setHeight(double); //置高度值
double getHeight() const; //返回高度值
double area() const; //返回面积
double volume() const; //返回体积
friend ostream &operator<<(ostream &, const Cylinder &); //友元函数
protected:
double height; // 数据成员，高度
};
// Point 类的成员函数
// 构造函数，调用成员函数对 x，y作初始化
Point::Point ( int a, int b )
{
setPoint ( a, b ) ;
}
// 对数据成员置值
void Point :: setPoint ( int a, int b )
{
x = a ;
y = b ;
}
// 重载插入算符，输出对象数据
ostream &operator<< ( ostream &output, const Point &p )
{
output << '[' <<p.x << "," << p.y << "]" ;
return output ;
}
// Circle 类的成员函数
// 带初始化式构造函数，首先调用基类构造函数
Circle::Circle( double r, int a, int b ): Point( a, b )
{
setRadius ( r );
}
// 对半径置值
void Circle::setRadius ( double r )
{
radius = ( r >= 0 ? r : 0 );
}
// 返回半径值
double Circle::getRadius() const
{
return radius;
}
// 计算并返回面积值
double Circle::area() const
{
return 3.14159 * radius * radius ;
}
// 输出圆心坐标和半径值
ostream & operator<< ( ostream &output, const Circle&c)
{
output << "Center =" << '[' << c.x << "," << c.y <<"]" << "; Radius = "
<<setiosflags(ios::fixed|ios::showpoint) << setprecision(2) <<c.radius ;
return output ;
}
Cylinder::Cylinder(double h, double r, int x, int y):Circle(r,x,y)
{
setHeight(h);
}
void Cylinder::setHeight(double h)
{
height = ( h >= 0 ? h : 0 );
}
double Cylinder::getHeight() const
{
return height;
}
double Cylinder::area()const
{
return 2*Circle::area()+2*3.14159*radius*height;
}
double Cylinder::volume() const
{
return Circle::area()*height;
}
ostream &operator<< ( ostream &output, const Cylinder&cy )
{
output << "Center =" << '[' << cy.x << "," << cy.y <<"]" << "; Radius = "
<<setiosflags(ios::fixed|ios::showpoint) << setprecision(2) <<cy.radius
<< "; Height= " << cy.height << endl ;
return output;
}
int main()
{
Point p ( 72, 115 ) ; //定义点对象并初始化
cout << "The initiallocation of p is " << p << endl ;
p.setPoint ( 10, 10 ) ; //置点的新数据值
cout << "\nThe newlocation of p is " << p << endl ; //输出数据
Circle c ( 2.5, 37, 43 ) ; //定义圆对象并初始化
cout<<"\nThe initiallocation and radius of c are\n"<<c<<"\nArea ="<<c.area()<<"\n" ;
c.setRadius ( 4.25 ) ;
c.setPoint ( 2, 2 ) ;
cout<<"\nThe newlocation and radius of c are\n"<<c<<"\nArea ="<<c.area()<< "\n" ;
Cylinder cyl ( 5.7, 2.5, 12, 23) ; //定义圆柱体对象并初始化
}多继承
一个类有多个直接基类的继承关系称为多继承
多继承声明语法
class 派生类名 : 访问控制 基类名1 , 访问控制 基类名2 , … , 访问控制 基类名n
{
数据成员和成员函数声明
}；
多继承的派生类构造和访问
多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员。
执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。
一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。
多继承的构造函数
派生类名(参数总表):基类名1(参数表1),基类名2(参数表2),…,基类名n(参数表n)
{
// 派生类新增成员的初始化语句
}
多继承方式下构造函数的执行顺序：
●先执行所有基类的构造函数
●再执行对象成员的构造函数
●最后执行派生类的构造函数
处于同一层次的各基类构造函数的执行顺序取决于定义派生类时所指定的基类顺序。
与派生类构造函数中所定义的成员初始化列表顺序没有关系。
内嵌对象成员的构造函数执行顺序与对象在派生类中声明的顺序一致。
多继承方式下析构函数的执行顺序；
●析构函数名同样与类名相同，无返回值、无参数，而且其定义方式与基类中的析构函数的定义方式完全相同。
●功能是在派生类中对新增的有关成员进行必要的清理工作。
●析构函数的执行顺序与多继承方式下构造函数的执行顺序完全相反，首先对派生类新增的数据成员进行清理，再对派生类对象成员进行清理，最后才对基类继承来的成员进行清理。
★复制兼容规则
●赋值兼容规则指在程序中需要使用基类对象的任何地方，都可以用公有派生类的对象来替代。
派生类->基类（大->小）
//派生类
AdminCheckIn a;
//基类
CheckIn *c1=new UserCheckin();//赋值兼容规则；
CheckIn &c2=a; //赋值兼容规则；
赋值兼容规则中所指的替代包括以下的情况：
a 派生类的对象可以赋给基类对象
b 派生类的对象可以初始化基类的引用
c 派生类的对象的地址可以赋给基类类型的指针
可行性
通过公有继承，
l 派生类得到了除了构造、析构函数以外的所有成员
l 且这些成员的访问控制属性也和基类完全相同。
l 这样，它便具备了基类的所有功能。
利用赋值兼容规则
l 派生类的对象可以赋给基类对象(强制类型转换)
l 派生类的对象可以初始化基类的引用
l 派生类的对象的地址可以赋给基类类型的指针
★注意的问题
（1）声明为指向基类的指针可以指向它的公有派生类的对象，但不允许指向它的私有派生类的对象。
（2）允许将一个声明为指向基类的指针指向其公有派生类对象，但是不能将一个声明为指向派生类对象的指针指向其基类的一个对象。
(3) 声明为指向基类对象的指针，当其指向公有派生类对象时，只能用它来直接访问派生类中从基类继承来的成员，而不能直接访问公有派生类的定义的成员。
重要知识总结
继承可以传递，但是继承时单项的。
多继承的容易出现二义性，慎用。
私有成员不被继承，不能被派生类使用。
学西心得：
继承最大的特点就是代码重用，让代码变得简洁。
继承的学习貌似让我打开了另一扇窗户，换一种角度思考问题，采用新知识的方法解决旧问题，用一种简单的方法去解决复杂的问题。
继承的可以说让我在写代码时又了规范性，不在随便的命名，有意识的相似功能的函数，明明相似，目的就是为了可以使用继承，优化代码。
继承的学习让我又积累了优化代码的方法。
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
