第4章  C++的面向对象编程
　　C++是面向对象的程序设计语言，类是其实现面向对象的工具。类是面向对象程序设计（OOP）实现信息封装的基础，是C++语言最重要的特性。其是进行数据封装和数据保护的工具。本章讲解的知识点包括：
* 类和对象的基本概念；
* 友元；
* 派生类；
* 继承与多重继承；
* 多态；
* 函数重载和运算符重载；
* 虚函数。
　　通过本章的学习，读者可以掌握C++面向对象方面的特点，了解C++中类的出现的基本理论，掌握类的定义和使用，掌握类的特性。
4.1  类和对象的基本概念
　　类是现实事物共有特征的抽象，而对象是类的具体实例。在面向对象的程序设计中，总是先声明类，再由类生成其对象。类是建立对象的模板，对象则是类的一个实例。
4.1.1  从结构到类
　　在C语言中有一种自定义的数据类型，即结构体。结构体中可以包含不同的数据类型。C++语言把结构体进行扩充，它不仅可以含有不同的数据类型，而且可以含有函数。在C++中结构体的定义形式如下：
　　
struct 结构体名
{
成员表列
}变量名表列;
　　
　　struct是定义结构体的关键字，后面的结构体名是结构体的名称。在结构体中可以定义一个或多个成员变量或函数。当然也可以不定义变量，此时称为空结构体。变量名表列是在定义结构体时，同时定义结构体变量。也可以不定义变量，在后面用到的地方再定义结构体变量。需要注意的是，结构体右括号的变量名表列后需要添加一个“;”。
　　【示例4.1】 声明一个结构体，并定义一个结构体变量A。
　　
struct student		//定义结构体
{
	//结构体成员
	int math;
	int english;
	int chemistry;
	int all(int a,int b,int c)
	{
		return a+b+c;
	}
}A；				//定义结构体变量
　　
　　分析：在这个声明的结构体中，含有3个整数，分别代表数学，英语和化学成绩。另外含有一个函数用于计算总成绩。并且定义了一个结构体变量A。此时可以使用“.”访问结构体的成员变量和成员函数。可以进行赋值，访问等操作。
?注意：一个空的结构体的大小并不为0，空结构体的大小为1。
　　结构体中的数据和函数都是结构体的成员，分别叫做结构体的数据成员和函数成员。下面看一个完整的例子。
　　【示例4.2】 利用上面声明的结构体，输入3门课成绩，输出总成绩。
　　
#include "iostream.h"
struct student			//定义结构体
{
	int math;
	int english;
	int chemistry;
	int all()			//成员函数
	{
		return math+english+chemistry;
	}
}A;						//定义结构体变量
void main()
{
	int a;int b;int c;
	cin>>a>>b>>c;	
	A.math=a;			//结构体成员的访问
	A.english=b;
	A.chemistry=c;
	cout<<A.all()<<endl;
}
　　
　　分析：在C++中，一个结构的成员分为两类，私有成员和公有成员。私有成员只可以被该成员内的其他成员所访问。公有成员可以被结构外的部分所访问。默认情况下，所有成员是公有成员。
　　类是比结构更为安全的数据类型。类实际上是结构的一种发展。类和结构的扩充形式十分相似，形式如下：
　　
class 类名{
private：
  私有成员
public：
  公有成员
protected:
   保护成员
};
　　
　　上面是C++语言中定义类的基本形式。其中class是类定义的关键字。类名则是说明所定义的类的名称。在大括号内有3个关键字：private:、public: 和protected:。每个关键字后面所定义的变量分别称为私有成员、公有成员和保护成员。类的定义与结构体类似，在右括号的后面需要添加一个“;”号。
　　对象是类的一个实例。类和对象就像int和整型变量i的关系一样。类是一种自定义的数据类型，而对象是一种具体化了的数据的集合。
?注意：C++中的结构与C语言中的结构不同，而C++的结构与类是相同的，也就是说C++中把结构体作为类。在C++中的结构可以在项目工作区的“Class View”控制面板中看到。
4.1.2  成员函数的定义
　　类中含有两种成分，即数据成员和函数成员。函数成员又称为成员函数。成员函数的定义有两种方式。
　　1．方式一
　　类声明时给出函数原型，函数体在外部定义。函数定义形式为：
　　
返回类型 类名::函数名（参数列表）
{
}
　　
　　上面的函数定义形式与普通的函数定义基本类似，只不过由于该函数是类的成员函数，因此在函数名前面需要添加类的说明，即添加“类名::”来说明这是类的成员函数。下面看一个类的成员函数定义的例子。
　　【示例4.3】 成员函数的定义，在类声明时给出函数原型，而在类的外部定义函数体。
　　
class point					//声明类point
{
private:
	int x;int y;
public:
	float distance();		//类的成员函数的函数原型
};
int point::distance()		//类的成员函数定义
{
	return sqrt(x*x+y*y);
}
　　
　　分析：上面的代码首先在point中给出distance()函数的原型，在类的外部定义该函数。这种定义方式使得程序可读性增强，但如果函数体很短则应使用下面的定义方式。
　　2．方式二
　　第二种方法是将成员函数定义在类的内部。这样定义的函数为内置函数。如果直接在类内部编写函数体，则称为隐式定义，如果函数仍然写在类外部，则需要在函数定义前添加inline，称为显式定义。下面列出隐式定义和显式定义的例子。
　　【示例4.4】 成员函数的隐式定义。即将函数直接定义在类的内部。
　　
class point					//声明类point
{
private:
	int x;int y;
public:
	float distance()		//定义函数
	{
		return sqrt(x*x+y*y);
	}
};
　　
　　分析：上面类的成员函数定义是直接在类的内部进行的。这样定义函数称为内置函数。而且是直接在类的内部实现，又称为隐式定义的内置函数。
　　【示例4.5】 成员函数的显式定义，即将函数的定义在外部实现，但是添加了关键字inline修饰。此时的函数仍然为内置函数。
　　
class point				//声明类point
{
private:
	int x;int y;
public:
	float distance();
};
//类的内置成员函数
inline int point::distance()	
{
	return sqrt(x*x+y*y);
}
　　
　　分析：上面类的成员函数虽然是在类的外部实现的，但是添加了关键字inline，则说明此函数仍然为一个内置函数。
?说明：所谓的内置函数与#define相似。在实际应用中，它把函数过程嵌入调用程序，避免频繁入栈出栈，只能用于简单的函数。
4.1.3  对象的定义与使用
　　对象是类的具体实例，定义好类以后必须去定义类的对象才可以真正实现类的功能。一般情况下对象的定义有下面两种情况。
　　1．声明类时直接定义对象
　　这种形式的对象定义是指在声明类的同时，直接定义该类的对象。在声明类的右括号“}”后直接列出对象名，并且可以定义多个对象。对象之间用“,”隔开，并且在最后一个对象的后边添加一个“;”。
　　【示例4.6】 声明类的同时直接定义对象。
class point				//声明类
{
private:
	int x;int y;
public:
	float distance()	
	{
		return sqrt(x*x+y*y);
	}
}A,B;					//定义类的对象
　　
　　分析：上面的形式首先声明一个类point，在声明中直接定义了该类的对象A和B。
　　2．声明类之后再定义对象
　　声明类以后，再定义类的对象，定义形式与一般变量定义一样。其基本形式为：
　　
类名 对象;
　　
　　当然实际中也可以同时定义类的多个对象，相邻对象之间使用“,”隔开，最后一个对象的后面添加一个“;”。
　　【示例4.7】 声明类point之后，再定义该类的对象A和B。
　　
class point						//声明类point
{
private:
	int x;int y;
public:
	float distance()			//类的成员函数
	{
		return sqrt(x*x+y*y);
	}
};
point  A,B; 						//定义对象
　　
　　分析：上面首先声明了point类，声明结束之后，利用类名定义了类的对象A和B。对象的定义完成以后就可以在程序中使用该对象。无论是数据成员还是函数成员，只要其类型为公有的，在类的外部都可以通过对象进行访问。访问的形式如下：
　　
对象名.数据成员
对象名.函数成员（实参列表）
?注意：对于类的包含成员和私有成员，类的对象并不能直接访问。因此一般情况下都会        利用一定的接口对类的包含成员和私有成员进行访问。
　　【示例4.8】 定义了类point，在声明类的时候直接定义对象。并且在主程序中利用类的对象使用类的成员变量和成员函数。
　　
#include"iostream.h"
#include"math.h"
class point			//声明类point
{
private:
	int x;int y;
public:
	float distance()		//成员函数
	{
		return sqrt(x*x+y*y);
	}
	void init(int a,int b)
	{
		x=a;y=b;
	}
}A;							//定义类的对象A
void main()
{	
	point B;				//定义类的对象B
	A.init(3,4);			//调用类的函数
	B.init(6,8);		
	cout<<A.distance()<<"   "<<B.distance()<<endl;
}
　　
　　分析：上面的例子中增加了一个函数init()，因为其数据成员是私有的，在类外部无法访问，所以定义一个共有的成员函数对其进行访问。
?说明：类中的所有成员应该都可以经过一定机制进行访问，如果不能访问类的数据成员，则定义此成员就没有任何意义。定义为保护或私有的目的是为了使之在类的外部不能被访问。
4.1.4  对象的作用域
　　类是面向对象的体现，它具有一定的数据保护功能。类的作用域就是类的保护功能的机制。类的作用域是指类的声明部分中的一对花括号所形成的作用域。一个类的所有成员都在该类的作用域内。在上面的例子中已经看到，类的私有成员变量不可以在类的外部访问，因此需要定义一个公有成员函数间接访问类的私有成员。
　　【示例4.9】 定义一个类，并且定义类的成员变量。在主函数中访问类的变量。
　　
#include<iostream.h>
class number				//声明类number
{
private:
	int num;
public:
	void fun(int i);		//类的成员函数
};
void number::fun(int i)
{
	num=i;					//访问类的私有成员
}
void main()
{
	int num=9;				//定义变量
	number A;		
	A.num=3;				//错误，类的私有成员
	A.fun(3);		
    num=10；					//访问主函数中定义的变量num
}
　　分析：上面的number类中定义了一个私有成员变量num，在main()函数中对该变量进行访问是错误的。因为超出了类的变量作用域。而在fun()函数中，虽然该函数的定义在类的外部实现，但它本身还是类的一部分。num仍然在作用域内。在后面主程序num赋值时，访问的是主函数中定义的变量，而不是类的成员变量。
4.2  构造函数和析构函数
　　类是一种用户自定义的数据类型。定义一个类的对象时，编译程序需要为对象分配存储空间，进行必要的初始化工作。在C++中类的构造函数就是去实现这部分功能。
4.2.1  构造函数
　　构造函数是一种特殊的成员函数，它主要进行一些初始化工作。构造函数有以下基本         性质。
* 构造函数和类的名字相同。
* 构造函数不具有返回值。
* 定义对象时，系统自动调用构造函数。
* 构造函数是公有函数，但它不可以被显式调用。
　　【示例4.10】 给出一个构造函数定义的例子，该类在其声明中定义了一个成员函数，函数名称与类名相同。并且该函数没有返回值，即定义了类的构造函数。
　　
class point					//声明类
{
private:
	int x;int y;
public:
	float distance()		//类的成员函数
	{
		return sqrt(x*x+y*y);
	}
	point(int a,int b)		//类的构造函数
	{
		x=a;y=b;
	}
}A;
　　
　　分析：上面的代码首先定义一个类，可以看到，仅仅把上例中的init函数名字换为构造函数的名字，即类名。这个函数就称为构造函数。
　　创建对象时，构造函数会自动被调用，不用显式调用。当程序员没有定义构造函数           时，编译系统会自动生成一个构造函数。构造函数可以带参数，也可以不带参数。当构造函数有参数时，创建对象必须指定构造函数的参数，否则，由于构造函数得不到实参，系统会报错。
4.2.2  默认参数的构造函数
　　对于有参数的构造函数，在定义对象时必须给构造函数传递参数。实际情况中，虽然有些构造函数有参数，但其参数是不变的，这就是默认参数的构造函数。此时构造函数的形式如下：
　　
类名(函数名)(参数1=默认值，参数2=默认值，…)
　　
　　构造函数中的参数与普通函数的参数是一样的，所谓的默认参数即为该参数设置一个默认的取值。可以为全部或者部分参数设置默认值。
　　【示例4.11】 利用前面的point类，用带默认参数的构造函数计算（2，3）、（7，3）、（4，6）到原点的距离。
　　
#include"iostream.h"
#include"math.h"				//包含头文件
class point
{
private:
	int x;int y;
public:
	float distance()			//类的成员函数
	{
		return sqrt(x*x+y*y);
	}
	point(int a=2,int b=3)		//默认参数的构造函数
	{
		x=a;y=b;
	}
};
void main()
{
	point A;					//全部使用默认值
	point B(7);					//只取一个默认值
	point C(4,6);				//不取默认值
	cout<<A.distance()<<"   "<<B.distance()<<"  "<<C.distance()<<endl;
}
　　
　　输出结果如下：
　　
3.60555   7.61577  7.2111
　　
　　分析：上面的函数中有一个构造函数，并且该构造函数有默认值。在主函数中如果定义对象时不给出参数，则使用默认参数。如果给出部分参数，则把前面的参数改变取值，而后面的参数仍取默认值。当给定参数与形式参数个数相同时，则全部使用实参。
?说明：程序中如果定义了构造函数，无论它是否带有参数，系统不会再添加构造函数。因此，如果此时的构造函数带有参数，并且没有指定默认值，那么在创建对象时必须指定参数。
　　【示例4.12】 利用构造函数的默认参数计算（1，3）、（4，3）两个点到原点的距离。上面的各个点的纵坐标都是3，因此可以采用默认参数。代码如下：
#include"iostream.h"
#include"math.h"
class point
{
private:
	int x;int y;
public:
	float distance()			//类的成员函数
	{
		return sqrt(x*x+y*y);
	}
	point(int a,int b=3)		//只要一个默认值的构造函数
	{
		x=a;y=b;
	}
};
void main()
{
	point A(1); 				//使用默认值
	point B(4);					//使用默认值
	cout<<A.distance()<<"   "<<B.distance()<<endl;
}
　　
　　分析：上面的程序是部分参数使用默认值的例子。当使用部分默认参数时，应该把拥有默认参数的参数放在参数列表的最右边，此时传递实参时可以正确地得到参数。
?注意：如果将默认参数设置在参数列表的左侧，例如point(int a=3,int b)，此时系统会报错。
4.2.3  析构函数
　　析构函数也是一种特殊的成员函数，它执行和构造函数相反的工作。析构的特殊性质          如下：
* 析构函数名称与类名相同，但前面加一个“～”。
* 一个类中只有一个析构函数，并且该函数不带任何参数。
* 当撤销对象时编译系统自动调用析构函数。
* 若程序员没有定义析构函数，编译系统会生成析构函数。
　　【示例4.13】 析构函数的使用。在类中定义一个成员函数，该函数的名称与类名相同，并且在前面添加一个“～”，即定义了析构函数。
　　
#include"iostream.h"
#include"math.h"
class point
{
private:
	int x;int y;
public:
	float distance()			//类的成员函数
	{
		return sqrt(x*x+y*y);
	}
	point(int a,int b)			//类的构造函数
	{
		cout<<"构造函数被调用"<<endl;
		x=a;y=b;
	}
	~point()				//类的析构函数
	{
		cout<<"析构函数被调用"<<endl;
	}
};
void main()
{
	point A(2,3);			//定义对象

}
　　
　　程序运行结果如下所示。
　　
构造函数被调用
析构函数被调用
　　
　　分析：上例中在定义类的对象时，会自动调用类的构造函数。此时会输出一行，应用程序结束之前，系统会自动撤销对象，此时会调用析构函数。同时需要注意的是析构函数是不可以拥有参数的。
?注意：前面在讲解函数时说过，如果一个函数没有定义一个返回类型，那么它会返回一个整数。然而，构造函数和析构函数都不可以被显式调用，它没有返回值。所以定义构造函数和析构函数时不可以指定返回类型，甚至定义为void类型也是错误的。
4.2.4  重载构造函数与拷贝构造函数
　　C++允许重载构造函数，所谓的重载构造函数是指允许在类中有多个构造函数。当然这些构造函数肯定是有区别的。各个构造函数必须拥有不同的参数个数或者参数类型。
　　【示例4.14】 定义类classexample有3个构造函数，代码如下所示。
　　
class classexample
{
public:
	classexample();			//构造函数1，此函数没有参数
	classexample(int);		//构造函数2，有一个整型参数
	classexample(int,int);	//构造函数3，有两个整型参数
     …
}
　　
　　分析：上面的例子中类classexample有3个构造函数，在定义对象时，根据不同的参数调用相应的构造函数。
　　【示例4.15】 利用重载构造函数创建对象，在定义对象时，如果使用有参数的构造函数，那么必须指定参数值。定义对象时就可以调用相应的构造函数。
　　
#include <iostream.h>
class classexample
{
private:
	int i; double d;
public:
	classexample()				 			//构造函数1
	{
		i=0;d=0.0;
	}
	classexample(int numi) 	    				//构造函数2
	{
		i=numi;	d=0.0;
	}
	classexample(int numi,double numd)		//构造函数3
	{
		i=numi;
		d=numd;
	}
	void print()
	{
		cout<<"i="<<i<<" "<<"d="<<d<<endl;
	}
};
void main()
{
	classexample A;							//调用构造函数1
	classexample B(3);						//调用构造函数2
	classexample C(3,2.2);					//调用构造函数3
	A.print();								//调用类的成员函数
	B.print();
	C.print();

}
　　
　　分析：上面的代码中首先定义一个类，并且对构造函数进行重载，在定义对象时，则会根据具体的参数选择合适的构造函数建立对象。上面程序的输出结果如下：
　　
i=0 d=0
i=3 d=0
i=3 d=2.2
　　
　　前面介绍了重载构造函数的基本用法。在类中还存在一种构造函数，称为拷贝构造函数。拷贝构造函数是依据已经存在的对象建立新的对象，该构造函数的性质有以下几点：
* 函数名称和类名一样。
* 每个类都有一个拷贝构造函数，如果程序中没有显示定义，编译系统会自动生成一个拷贝构造函数。
* 拷贝构造函数有一个参数，是类的对象的引用。
　　【示例4.16】 利用拷贝构造函数实现point类的新对象，且把横纵坐标互换加倍。
　　
#include"iostream.h"
#include"math.h"
class point					
{
private:
	int x;int y;
public:
	float distance()				//类的成员函数
	{
		return sqrt(x*x+y*y);
	}
	point(int a,int b) 			//构造函数
	{
		x=a;y=b;
	}
	point(const point &p) 		//拷贝构造函数
	{
		x=2*p.y;y=2*p.x;
	}

};
void main()
{
	point A(4,5); 				//调用构造函数
	point B(A); 				//调用拷贝构造函数
	cout<<A.distance()<<"   "<<B.distance()<<endl;;
}
　　
　　分析：上面的拷贝构造函数是代入法，除此之外还可以采用赋值法。即利用赋值语句实现。如果用户未定义拷贝构造函数，那么系统会利用默认的拷贝构造函数实现赋值。
4.3  友    元
　　类的主要特点是数据隐藏，即类的私有成员只可以被类的内部使用。但是有的时候需要在类的外部访问类的私有成员，为此C++利用了一种新的机制——友元。
4.3.1  友元函数
　　友元函数不是类的成员函数，而是独立于当前类的外部函数，但它可以访问该类的所有成员。在类的定义中声明友元函数时，需要在函数名前面加上friend。友元函数可以定义在类的内部，也可以在类的外部定义。
?注意：友元在类的封装性中打了个孔，使封装性的强度下降。程序中如非必要，应尽量减少友元的使用。
　　【示例4.17】 利用友元函数实现类point的变量的初始化。
　　
#include"iostream.h"
#include"math.h"
class point
{
private:
	int x;int y;
public:
	float distance()							//定义成员函数
	{
		return sqrt(x*x+y*y);
	}
	friend void init(point &,int a,int b); 		//声明友元函数
};
void init(point &p,int a,int b) 			//函数定义
{
	p.x=a;
	p.y=b;
}
void main()
{
	int x;int y;
	cin>>x>>y;
	point pt;					 			//定义类的对象
	init(pt,x,y);							//使用友元函数
	cout<<pt.distance()<<endl;				//调用类的成员函数
}
　　
　　分析：因为友元函数不是类的成员函数，因此友元函数一般都有一个该类的入口参数。上面的例子利用了友元函数对类的私有成员变量进行访问。虽然友元函数解决了对类的成员的访问，但它同时也造成了类的不安全性，类本来是要保证数据安全性的。因此在使用友元函数时要谨慎判断其访问权限，防止出现数据被不合法地访问。
4.3.2  友元成员
　　除了一般的函数可以作为类的友元外，一个类的成员函数也可以作为另一个类的友元。这样的函数不仅可以访问本类的所有成员，还可以访问其友元类的所有成员。需要注意的是当在一个类中的某个成员函数定义为另一个类的友元函数时需要首先定义此类。例如要定义类A的某个函数为类B的友元函数，那么需要先定义类B，然后再进行类A的成员函数与B友元的定义。
　　【示例4.18】 利用友元成员访问其类的数据成员。
　　
#include"iostream.h"
#include"math.h"
class line;							//类的声明
class point							//类point
{
private:
	int x;int y;
public:
	point(int a,int b) 				//构造函数
	{
		x=a;y=b;
	}
	void print(line &);				//成员函数
};
class line
{
private:
	int x1;int y1;
	int x2,int y2;
public:
	line(int a,int b,int c,int d) 	//构造函数
	{
		x1=a;x2=b;
		y1=c;y2=d;
	}
	friend void point::print(line &);	//声明友元成员
};
void point::print(line &p)	//友元成员定义实现对line类的数据成员的访问
{
	cout<<x<<y<<endl;
	cout<<p.x1<<p.x2<<p.y1<<p.y2<<endl;
}
void main()
{
	point A(7,8); 						//定义对象
	line l(1,2,3,4);				 	//定义对象
	A.print(l);
}
　　
　　分析：上面类的友元成员的定义可以实现对类的数据成员进行访问。上面利用类point的成员函数，定义为类line的友元函数，实现了对友元的数据的访问。运行结果如下：
　　
78
1234
　　
　　对于一个友元成员来说，它不仅可以访问自己所在类中的私有成员和公有成员，同时还可以对声明为友元类的类的成员进行访问。使用友元成员可以使得两个类之间出现互相访问的一个“门”。这样解决了由于类的保护机制而出现的其他类绝对不允许访问的情况。
4.3.3  友元类
　　不仅函数可以作为一个类的友元，一个类也可以作为另一个类的友元。定义方法是在类的声明中加入语句friend类名。
　　【示例4.19】 定义两个类X和Y，并且把类X声明为类Y的友元类。
　　
class X
{
	...
};
class Y
{
	...
	friend X;							//声明类X为类Y的友元类
};
　　
　　分析：上面的代码把X声明为类Y的友元类。则在X中可以对类Y的所有成员进行访问。其使用方法与一般的友元函数相同。
?注意：友元类不具有交换性和传递性，例如X是Y的友元，那么Y不一定是X的友元。类X是类Y的友元，类Y是类Z的友元，那么类X不一定是类Z的友元。
4.4  派  生  类
　　继承是面向对象程序设计的一个重要特性，它允许在现有类的基础上创建新的类，可以继承原有类数据和函数，同时可以添加新的成员。继承特性增加了代码的重复利用率，提高了开发效率。通过继承已有的一个或多个类产生一个新类的过程称为派生。通过派生可以创建一种新的类，所创建的新类称为派生类。
4.4.1  派生类的引出
　　现实世界中，继承的概念十分广泛。人们认识世界就是一个层次结构。越靠近上层就表示越为普遍的概念，例如图4.1所示一个层次结构。
　　在类中，继承的概念就是从父辈得到其属性。即产生的新类就是原有类的派生。原有类就是派生类的基类。派生类的声明形式如下：
　　
class 类名：继承方式 基类
{
}
　　
　　上面的派生类的声明形式与一般类的声明是一致的。只不过添加了一个基类的声明。基类的声明包括继承方式和类名。继承方式规定了派生类如何继承基类的属性，其包括公有继承、私有继承和保护继承。派生类中可以进行自己的成员定义。可以定义新的成员变量和成员函数，也可以重新定义基类中的成员。
4.4.2  基类成员在派生类中访问属性
　　派生类继承基类的方式有3种情况，那么继承过来的成员其属性如何呢？下面给出3种继承方式下的基类成员在派生类中的访问属性，如表4.1所示。
表4.1  基类成员在派生类中的访问属性
基类中的属性
继 承 方 式
在派生类中的访问方式
公有成员
公有继承
　　　　　公有
保护成员

　　　　　保护
私有成员

　　　　　不可直接访问
公有成员
保护继承
　　　　　保护
保护成员

　　　　　保护
私有成员

　　　　　不可直接访问
公有成员
私有继承
　　　　　私有
保护成员

　　　　　私有
私有成员

　　　　　不可直接访问
4.4.3  派生类对基类成员的访问规则
　　派生类对基类成员的访问形式包括内部访问和对象访问两种方式。下面对3种继承方式下的访问规则分别进行介绍。
　　1．私有继承
　　通过私有继承方式，基类的公有成员和保护成员变为私有性质的，则派生类的其他成员可以直接访问基类的成员。但是派生类的对象不可以访问基类的成员，同时基类的私有成员不可以被派生类所访问。
　　2．保护继承
　　通过保护继承，基类的公有成员和保护成员变为保护性质的，则派生类的其他成员可以直接访问基类的成员。但是派生类的对象不可以访问基类的成员，同时基类的私有成员不可以被派生类所访问。这种方式与私有继承基本相同。
　　3．公有继承
　　通过公有继承，基类的公有成员和保护成员仍为公有和保护成员。派生类的其他成员可以直接访问基类的公有成员和保护成员，但是派生类的外部只可以访问基类的公有成员。派生类的私有成员不能直接被访问，只可以通过公有成员和保护成员间接访问。
?说明：继承方式的选择应该根据实际应用中的设计需要而定。一般来说选择公有继承方式的较多。
4.5  派生类的构造函数与析构函数
　　派生类继承了基类的成员，实现了代码的重复利用，但是继承的目的更主要的是功能的扩充。基类的构造函数和析构函数不能被继承。如果在派生类中需要对新增加的成员进行初始化，则需要加入派生类的构造函数。同样派生类也需要添加析构函数来实现一些结束工作。
4.5.1  派生类构造函数和析构函数的执行顺序
　　当创建对象时，编译系统会自动调用构造函数。当撤销对象时，编译系统会自动调用析构函数。当创建派生类的对象时，首先执行基类的构造函数，然后执行派生类的构造函数。当撤销对象时，则先执行派生类的析构函数，然后再执行基类的析构函数。
　　【示例4.20】 定义基类和派生类，查看构造函数和析构函数的调用次序。
　　
#include"iostream.h"
class A								//定义一个类
{
public:
	A()								//类的构造函数
	{cout<<"基类的构造函数"<<endl;}
	~A()							//类的析构函数
	{cout<<"基类的析构函数"<<endl;}
};
class B:public A					//派生类
{
public:
	B()								//派生类的构造函数
	{cout<<"派生类的构造函数"<<endl;}
	~B()							//派生类的析构函数
	{cout<<"派生类的析构函数"<<endl;}
};
void main()
{
	B p;							//派生类的对象
} 
　　
　　程序输出结果如下所示。
　　
基类的构造函数
派生类的构造函数
派生类的析构函数
基类的析构函数
　　
　　分析：在定义对象时，系统会自动调用构造函数，而撤销对象时则会调用析构函数。在派生类中需要对基类的构造函数和析构函数进行处理。通过上面的例子可以清楚地看到在派生类中构造函数和析构函数的调用次序。如果有层派生时，首先调用基类的构造函数，然后逐层向上调用构造函数。析构函数的执行顺序与构造函数的调用次序相反。
　　【示例4.21】 多层派生构造函数和析构函数的执行次序。
　　
#include"iostream.h"
class A								//定义类
{
public:
	A()
	{cout<<"基类的构造函数"<<endl;}
	~A()
	{cout<<"基类的析构函数"<<endl;}
};
class B:public A					//从A类派生
{
public:
	B()
	{cout<<"派生类B的构造函数"<<endl;}
	~B()
	{cout<<"派生类B的析构函数"<<endl;}
};
class C:public B					//从B类派生，而B从A派生
{
public:
	C()
	{cout<<"派生类C的构造函数"<<endl;}
	~C()
	{cout<<"派生类C的析构函数"<<endl;}
};
void main()
{
	C c;							//定义对象
}
　　
　　程序输出结果如下：
基类的构造函数
派生类B的构造函数
派生类C的构造函数
派生类C的析构函数
派生类B的析构函数
基类的析构函数
　　
　　通过上面的例子可以清楚地看到多层派生时的构造函数和析构函数依次被调用的顺序。在多层派生的情况下需要从底层开始执行构造函数，撤销对象时，则从高层撤销对象。
4.5.2  派生类构造函数和析构函数的构造规则
　　派生类不能继承基类的构造函数，如果基类中含有带参数的构造函数，则派生类中必须定义构造函数，用以向基类传递参数。派生类构造函数的定义必须包含基类的参数，其定义的一般格式为：
　　
派生类名（全部参数列表）：基类名（参数列表）
　　
　　派生类的析构函数和基类的析构函数关系不大，程序中可以分别进行设计。
4.6  继承与多重继承
　　继承使得派生类既保持了基类的特性，又可以增加新的功能。如果一个类，其属性可以从多个基类中获得，这就需要多重继承的概念。
4.6.1  继承和多重继承概述
　　继承是一个类从一个基类中派生，多重继承则是指一个类从多个基类进行派生。现在有一个类A和类B，要设计一个类C，它需要既继承类A的特性，又继承类B的特性，那么类C就需要多成继承类A和类B。
4.6.2  多重继承的声明
　　在C++中，类的多重继承与单继承的声明相似，其一般形式是：
　　
class 派生类名：继承方式1 基类1，…继承方式n 基类n
{ }
　　
　　在多重继承中，派生类的构造函数要进行基类的初始化工作，因此如果任何一个基类的构造函数含有参数，那么派生类必须添加构造函数。构造函数的执行顺序是先执行基类的构造函数，再执行派生类的构造函数。同一层次的基类的执行顺序与声明时的顺序有关。析构函数的执行与构造函数的顺序相反。
?说明：多重继承可以从多个基类进行继承，而且基类之间也可以存在继承关系。
　　【示例4.22】 是多重继承的使用实例。
　　
#include"iostream.h"
class A								//声明类A
{
public:
	A()
	{cout<<"基类A的构造函数"<<endl;}
	~A()
	{cout<<"基类A的析构函数"<<endl;}
};
class B								//声明类B
{
public:
	B()
	{cout<<"基类B的构造函数"<<endl;}
	~B()
	{cout<<"基类B的析构函数"<<endl;}
};
class C:public A,public B			//多重继承，C在类A和类B继承
{
public:
	C()
	{cout<<"派生类C的构造函数"<<endl;}
	~C()
	{cout<<"派生类C的析构函数"<<endl;}
};
void main()
{
	C p;							//定义类C的对象
}
　　
　　运行结果如下所示。
　　
基类A的构造函数
基类B的构造函数
派生类C的构造函数
派生类C的析构函数
基类B的析构函数
基类A的析构函数
　　
　　分析：派生类C是从A和B继承派生，声明时先声明继承A，又声明继承B，因此先执行A的构造函数，再执行B的构造函数，最后执行派生类C的构造函数。析构函数与构造函数的执行顺序相反。
4.6.3  虚基类
　　如果一个派生类的基类是从一个共同的基类派生出来的，那么派生类的对象就是底层基类的间接派生，它会出现多个基类的拷贝。程序中如何进行分辨呢？一种方法是利用作用域运算符，即在访问基类的成员时明确指出要访问的是哪一个基类的数据成员。另一种方法是利用虚基类。虚基类是让基类只有一个拷贝，程序中的访问就不会出现访问的不确定性。虚基类在派生类中声明，其格式为：
class 派生类名：virtual 继承方式 基类
{}
　　
　　虚基类的声明与普通的继承形式相同，只不过要在继承方式的前面添加关键字：virtual。当使用虚基类时，基类只有一个拷贝，程序中的访问具有确定性。
　　【示例4.23】 下面给出虚基类的例子。
　　
#include"iostream.h"
class base							//类base
{
	public:
	base()
	{cout<<"基类base的构造函数"<<endl;}
	~base()
	{cout<<"基类base的析构函数"<<endl;}
};
class A:virtual public base			//虚基类，类A在类base派生
{
public:
	A()
	{cout<<"基类A的构造函数"<<endl;}
	~A()
	{cout<<"基类A的析构函数"<<endl;}
};
class B:virtual public base			//虚基类，类B在类base派生
{
public:
	B()
	{cout<<"基类B的构造函数"<<endl;}
	~B()
	{cout<<"基类B的析构函数"<<endl;}
};
class C:public A,public B			//多重继承，类C继承类A和类B
{
public:
	C()
	{cout<<"派生类C的构造函数"<<endl;}
	~C()
	{cout<<"派生类C的析构函数"<<endl;}
};
void main()
{
	C p;							//定义对象
}
　　
　　程序运行结果如下：
　　
基类base的构造函数
基类A的构造函数
基类B的构造函数
派生类C的构造函数
派生类C的析构函数
基类B的析构函数
基类A的析构函数
基类base的析构函数
　　这样程序对基类base只有一个拷贝，因此执行构造函数时，只要从基类base开始就可以了。如果未使用虚基类，那么程序的输出结果为：
　　
基类base的构造函数
基类A的构造函数
基类base的构造函数
基类B的构造函数
派生类C的构造函数
派生类C的析构函数
基类B的析构函数
基类base的析构函数
基类A的析构函数
基类base的析构函数
　　
　　此时类base有两个拷贝。当创建类C的对象时，需要逐层次的向前进行访问，出现基类base被构造两次。
?警告：一个类由多个基类派生出来，则虚基类的构造函数先于非虚基类的构造函数的执行。
4.7  多态的基本概念
　　程序的多态性是指不同的对象收到相同的消息而作出不同的动作。多态性包括运行时的多态性和编译时的多态性。编译时的多态性是指编译时的多态，通过函数重载和运算符重载来实现。运行时的多态则通过继承和虚函数来实现。
　　1．编译时的多态性
　　编译时的多态性是指编译时的多态实现，即在编译阶段就确定具体的程序结构。函数重载和运算符重载是实现此种多态性的主要方法。所谓函数重载就是在派生类中重新定义函数。这样在函数编译阶段就可以实现访问不同的函数。
　　2．运行时的多态性
　　所谓运行时的多态性是指在运行时刻才动态地选择所有调用的内容。在C++语言中利用类的继承和虚函数来实现运行时的动态选择。
　　上面介绍了多态性的基本概念。在C++程序设计中经常利用多态性实现系统功能的不断加强。多态性可以实现面向对象的基本机制。不同的对象可以对相同的消息或者其他相同情况调用不同的函数，进而实现不同的功能。在下面的章节中将具体讲解实现编译多态性和运行时多态性的具体实现方法。
4.8  函数重载和运算符重载
　　函数重载和运算符重载可以实现编译时的多态性，从而可以动态地决定程序的动作。函数重载可以使程序设计更加灵活。运算符重载利用运算符函数来实现。
4.8.1  函数重载
　　派生类可以改写基类的成员函数，从而实现新的功能。这就是函数重载。函数重载后，程序员使用派生类的对象可以访问基类或者是派生类的成员函数。函数重载提高了程序设计的灵活性。
　　【示例4.24】 函数重载输出不同的内容，实现编译时的多态性。
　　
#include"iostream.h"
class A						//定义类A
{
public:
	print()					//类的成员函数
	{
		cout<<"基类输出"<<endl;
	}
};
class C:public A			//定义派生类C从A派生
{
public:
	print()					//派生类的成员函数
	{
		cout<<"派生类输出"<<endl;
	}

};
void main()
{
	A p1;           			//基类的对象
	C p2;	         		 	//派生类对象
	p2.print();    			//执行派生类的print函数
	p1.print();      		//执行基类的print函数
	p2.A::print();    		//执行基类的print函数

}
　　
　　分析：上面的例子对基类的成员函数进行了重载。在派生类中重载了基类的成员函数以后，在派生类访问该函数时调用的就是派生类的函数。这就是所谓的编译时的多态性。C++在编译时采用改变名字的办法执行函数，即编译后生成新的函数名称。从而可以区分重载后的函数。
4.8.2  运算符重载
　　在C++中，除了可以对函数进行重载外，还可以对运算符进行重载。运算符的重载通过创建运算符函数operator来实现。运算符重载定义了重载的运算符的操作。函数operator的操作对象是一个类，同时operator可以是这个类的成员函数，可以是类的友元函数。
　　运算符重载在实际运用中有十分重要的意义，例如复数的四则运算就可以借助运算符重载来实现。运算符重载包括两种形式，一是重载为类的成员函数，一是重载为类的友元函数。其形式如下：
　　1．重载为类的成员函数
函数类型 operator 运算符（参数表）
{}
　　2．重载为友元函数
friend 函数类型 operator 运算符（参数表）
{}
　　
　　重载为成员函数和重载为友元函数具有如下不同之处：
　　（1）对于双目运算符，成员函数只带有一个参数，而友元函数带两个参数。
　　（2）对于单目运算符，成员函数不带参数，而友元函数带一个参数。
　　上面介绍了运算符重载的基本内容。如何进行运算符重载，以及运算符重载的具体应用将在本章实例中进行介绍。
4.9  虚  函  数
　　虚函数是重载的另一种表现形式，它提供了一种动态机制，使程序运行更加灵活。一个基类的指针可以指向派生类的对象，但是利用基类指针调用类的函数时调用的仍然是基类的成员函数。例如下面的例子。
　　【示例4.25】 未使用虚函数时的使用实例。在本例中，仅仅是重载了基类的成员函数。在主函数中将派生类的对象赋值给基类的指针。此时利用该指针调用类的函数。
　　
#include "iostream.h"
class A
{
public:
	void print()			//定义类A的成员函数
	{
		cout<<"基类输出"<<endl;
	}
};
class B:public A			//派生类B，从类A派生
{
public:
	void print()			//成员函数
	{
		cout<<"派生类输出"<<endl;
	}
};
void main()
{
	A opa;					//定义基类A的对象
	B opb;					//定义派生类B的对象
	A *p=&opa;				//定义指向基类的指针，并且使用类A的对象初始化
	p->print();				//调用基类的成员函数
	p=&opb;					//将类B的对象赋给指针
	p->print();				//调用基类的成员函数，而不是调用派生类的成员函数

}
　　
　　程序输出结果如下：
　　
基类输出
基类输出
　　
　　这是因为函数在编译时是静态联编的。如果想调用派生类则可以采用显式调用，即利用派生类对象调用，必须采用虚函数。虚函数的定义形式如下：
　　
virtual  函数类型 函数名（参数表）
{}
　　
　　把函数声明为虚函数，编译系统就可以进行动态联编，既可以正确调用派生类的成员函数。把上面基类的print函数声明为虚函数，代码如下：
　　
virtual void print()
　　
　　程序输出结果如下：
　　
基类输出
派生类输出
　　
　　通过上面的分析可以看到，利用虚函数可以实现对派生类的成员函数正确调用。
　　有时基类表示一个抽象的概念，它并不与任何实际事物联系，这就是抽象类。抽象类中的所有函数并不具有任何意义，但是可以为它的派生类打下基础。抽象类中声明的虚函数则称为纯虚函数。它在基类中没有定义，但它要求在派生类中去定义。
?注意：抽象类中至少含有一个纯虚函数，而且抽象类不可以创建对象，只可以作为其派生类的基类。
4.10  本章实例——类的使用
　　前面介绍了继承、多态和重载的基本概念和使用方法。C++作为面向对象的程序设计语言，继承、多态和重载的出现使C++面向对象的特点体现的更加明确。本节给出几个例子。
　　【示例4.26】 创建复数类，利用运算符重载，实现其加法和减法。
　　
#include <iostream.h>
class complex								//定义一个复数类
{
public:
complex(double xx = 0.0, double yy = 0.0)	//默认参数的构造函数
{x = xx;y = yy;}
    complex operator+(complex);				//重载运算符
    complex operator-(complex);
    void show();
private:
    double x;
    double y;
};
complex complex::operator+(complex b)		//重载运算符+
{
    complex a;
    a.x = x+b.x;
    a.y = y+b.y;
    return a;
}
complex complex::operator-(complex b) 		//重载运算符-
{
    complex a;
    a.x = x-b.x;
    a.y = y-b.y;
    return a;
}
void complex::show()						//成员函数
{
	if(y>=0)
		cout<<x<<"+"<<y<<"j"<<endl;			//输出变量
	else
		cout<<x<<y<<"j"<<endl;
}
void main()
{
    complex a(1.1, 1.2);					//定义对象a
    complex b(2.1, 2.2);					//定义对象b
    complex c;								//定义对象c，使用默认参数
    c = a+b;									//使用运算符重载+
    cout<<"a = ";
    a.show();
    cout<<"b = ";
    b.show();
    cout<<"c = a+b =";
    c.show();
    c = a-b;									//使用运算符重载-
    cout<<"c = a-b =";
    c.show();
}
　　
　　程序输出如下所示。
　　
a=1.1+1.2j
b=2.1+2.2j
c=a+b=3.2+3.4j
c=a-b=-1-1j
　　
　　分析：上面介绍了一个使用运算符重载进行程序设计的例子。运算符重载可以实现编译时的多态性，也就是在编译阶段实现多态性的选择。运算符重载仅仅可以实现编译时的多态性，并不能在程序执行时进行多态性。下面的例子中将利用抽象类实现运行时的多态性。
　　【示例4.27】 创建抽象类circle，利用纯虚函数求解圆的内接正方形面积和周长。
　　
#include"iostream.h"
class circle								//定义类
{
public:
	void set(double x)
	{r=x;}
	virtual double area()=0;			//纯虚函数
	virtual double length()=0;			//纯虚函数
protected:
	double r;
};
class square:public circle				//派生类
{
public:
	double area()						//成员函数
	{return 2*r*r;}
	double length()
	{return 4*1.414*r;}
};
void main()
{
	square op;							//定义对象
	op.set(2.68);
	cout<<"The area is: "<<op.area()<<endl;
	cout<<"The length is: "<<op.length()<<endl;
}
　　
　　分析：上面是抽象类的具体使用。对于一个拥有纯虚函数的抽象类来说，此虚函数在基类中没有定义，但它要求在派生类中去定义。上面程序的输出结果如下：
　　
The area is: 14.3648
The length is: 15.1581
　　
　　抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，它处于继承层次结构的较上层。抽象类是不能定义对象的，在实际中为了强调一个类是抽象类，可将该类的构造函数说明为保护的访问控制权限。
4.11  上 机 实 践
　　类point表示一个坐标点，其原型为：
　　
class point
{
public：
point(double a=0,double b=0){x=a;y=b;}
…
private:
double x;double y;
};
　　
　　要求编写程序，完成如下功能。
　　（1）定义类point的成员函数，计算一个点到当前点的距离。其原型如下：double dis(point &p)。
　　（2）由类point定义一个共有派生类circle，类circle中增加一个数据成员double r，r表示半径。该类有两个构造函数和计算面积的函数area()。
　　（3）定义main()函数，按下面的要求编写程序。
main()
{
//定义类point的对象p1，坐标为（2.5，3.5）
//定义类point的对象p2，坐标（3.0，2.0）
//用拷贝构造的方式定义point对象p3，坐标与p1相同
//计算并输出p2，p3距离
//定义类circle的对象c，圆心坐标（2.0，2.0），半径1.5
//计算并输出c的面积
}
　　
?提示：本例主要考察类的基本使用方法，包括类的成员函数的定义，构造函数的使用、类的派生和对象的使用等。参考代码如下：
　　
#include <iostream.h>
#include <math.h>
class point
{
public:
	point(double a=0,double b=0){X = a;Y = b;}		//构造函数
    point(const point &p)            					//拷贝构造函数
	{
		X = p.X;Y = p.Y;
	}
	~point(){}
    double distance(point &p)     					//成员函数    
    {
        double dis;
        dis = sqrt(pow(this->X-p.X,2)+pow(this->Y-p.Y,2));
        return dis;
    }
    void print()                                
    {
        cout<<"X= "<<this->X<<"   "<<"Y= "<<this->Y<<endl;
    }
private:
	double X;
	double Y;
};
class circle:public point							//派生类
{
private :
	double r;
public:
	circle(double a,double b,double c):point(a,b)   
	{ r = c;}
	~circle(){}
	double area(){return 3.14159 *r *r;}	
};

int main()
{
    point p1(2.5,3.5),p2(3.0,0.0);					//定义类point对象
    point p3(p1);									//使用拷贝构造函数定义对象
    cout<<"the distance between p2 and p3 is : "<<p2.distance(p3)<<endl;
	
    circle c1(2.0,2.0,1.5);							//定义类circle对象
    cout<<"the area of circle c1 is: "<<c1.area()<<endl;
    return 0;
}
4.12  常见问题及解答
　　1．友元关系可以传递吗？
　　答：友元关系不能传递，即你是我的朋友，他是你的朋友，但不一定他是我的朋友。实际应用应注意其不可传递性。
　　2．友元关系可逆吗？
　　答：友元关系不可逆，即甲是乙的友元，并不意味着乙是甲的友元。
　　3．所有的运算符都可以重载吗？
　　答：不是的。C++规定，有些运算符不能重载。例如类属关系运算符“.”，作用域运算符“：：”，条件运算符“？：”等。
　　4．空类的大小是0吗？
　　答：空类的大小并不是0。如果一个空类具有两个对象，空类大小都是0的话，编译器如何去区分呢？所以空类的大小是1，可以用sizeof()进行查看。
4.13  小    结
　　继承、封装和多态是面向对象程序设计的3大特性。本章详细介绍了C++的面向对象程序设计理论，介绍了类的基本概念和基本操作，并对派生类和基类的构造函数和析构函数的执行顺序进行分析。本章还讨论了如何通过虚函数实现多态，介绍了纯虚函数如何将接口与实现进行分离。Visual C++提供类库，其是一整套的类，掌握类的继承、封装和多态是利用MFC进行程序设计的基础。
4.14  习    题
　　1．构造函数和析构函数的作用是什么？写出其基本性质。
　　2．什么是友元？什么是友元函数和友元类？
　　3．继承方式有哪几种？每种方式的派生类对基类成员的继承性如何？
　　4．派生类的构造函数和析构函数的构造规则如何？其执行顺序又是怎样的？
　　5．虚函数与多态性有什么关系？
　　6．虚函数在派生类中的特征是否被继承？
第2篇  C++语法篇
　　
第4章  C++的面向对象编程
　　
·82·
　　
　　
·57·