C++面向对象程序设计

多态性是面向对象程序设计的一个重要特征，多态的意思是一个事物的多种形态。在C++程序设计中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。面向对象方法中的多态性，比如说向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即方法）。

从系统实现的角度看，多态性分为两类：静态多态性和动态多态性。比如函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用的是哪个函数，因此又称编译时的多态性；静态多态性是通过函数的重载实现的，运算符重载实质上也是函数重载。动态多态性是在程序运行过程中才动态地确定操作所针对的对象，又称运行时的多态性。动态多态性是通过虚函数（virtual function）实现的。

该篇将通过承上启下的例子，一方面了解有关继承和运算符重载的内容，另一方面作为讨论多态性的基础用例。

一、声明基类Point类

先完成基类Point的声明，代码如下：

#include <iostream>
using namespace std;
// 声明类Point
class Point{
	public:
		Point(float x = 0, float y = 0);			//有默认参数的构造函数
		void setPoint(float, float);				// 设置坐标值
		float getX() const { 
			return x;
		}
		float getY() const {
			return y;
		}
		friend ostream & operator <<(ostream &, const Point&);		//重载运算符 <<
	protected:
		float x, y;
};
// Point构造函数
Point::Point(float a, float b){
	x = a;
	y = b;
}
// 设置x和y的坐标值
void Point::setPoint(float a, float b){
	x = a;
	y = b;
}
// 重载运算符 "<<"，使之能输出点的坐标
ostream & operator <<(ostream &output, const Point &p){
	output <<'[' <<p.x <<',' <<p.y <<']' <<endl;
	return output;
}
int main(){
	Point p(3.5, 6.4);
	cout <<"x=" <<p.getX() <<",y=" <<p.getY() <<endl;		//输出坐标
	// 修改坐标
	p.setPoint(8.5, 6.8);
	// 输出重载运算符的p坐标
	cout <<"p:" <<p <<endl;
	return 0;
}

输出结果如下图：

这里对运算符重载不熟悉的可以查看前面写过一篇，其中有讲到“六、重载流插入运算符和提取运算符”内容及相关案例。地址：C++面向对象程序设计 - 运算符重载-CSDN博客

二、声明派生类Circle

在前面的基础上，再声明派生类Circle的部分，代码如下：

#include <iostream>
using namespace std;
// 声明类Point
class Point{
	public:
		Point(float x = 0, float y = 0);			//有默认参数的构造函数
		void setPoint(float, float);				// 设置坐标值
		float getX() const { 
			return x;
		}
		float getY() const {
			return y;
		}
		friend ostream & operator <<(ostream &, const Point&);		//重载运算符 <<
	protected:
		float x, y;
};
// Point构造函数
Point::Point(float a, float b){
	x = a;
	y = b;
}
// 设置x和y的坐标值
void Point::setPoint(float a, float b){
	x = a;
	y = b;
}
// 重载运算符 "<<"，使之能输出点的坐标
ostream & operator <<(ostream &output, const Point &p){
	output <<'[' <<p.x <<',' <<p.y <<']' <<endl;
	return output;
}

// 声明Circle类，并公有继承基类Point
class Circle: public Point{
	private:
		float radius;
	public:
		// 定义Circle构造函数，对圆心坐标和半径初始化
		Circle(float x = 0, float y = 0, float r = 0): Point(x, y), radius(r){}		
		// 定义设置半径函数
		void setRadius(float r){
			radius = r;
		}
		// 定义获取半径的函数
		float getRadius() const{
			return radius;
		}
		// 声明计算面积的函数
		float area() const{
			return 3.1415926 * radius * radius;
		}
		// 声明重置运算符 << 的友函数	
		friend ostream & operator << (ostream &, const Circle &);		
};
// 定义重载运算符 << 输出圆的信息
ostream & operator << (ostream &output, const Circle &c){
	output <<"Center=[" <<c.x <<',' <<c.y <<"], r=" <<c.getRadius() <<", area=" <<c.area() <<endl;
	return output; 
}
int main(){
	Circle c(3.5, 6.5, 5.2);		//创建Circle对象c，并指定圆坐标和半径
	cout <<"Original information:" <<endl;
	// 输出圆的坐标和半径信息
	cout <<"x=" <<c.getX() <<",y=" <<c.getY() <<", radius=" <<c.getRadius() <<", area=" <<c.area() <<endl;	
	// 修改坐标
	c.setPoint(8.5, 6.8);
	// 修改圆的半径信息
	c.setRadius(8);
	cout <<endl <<"New information:" <<endl;
	// 重载运算符，使之输出对象c的信息
	cout <<"c object:" <<c <<endl;
	
	// 通过Point类的引用变量，被c初始化
	Point &p = c;
	// 输出引用变量p的信息
	cout <<"Point Reference:" <<p <<endl;
	return 0;
}

运行后输出结果如下图：

通过以上代码了解，类Circle公有继承了类Point，并且Circle类中继承了Point类中的保护成员和公有成员，在main()函数中通过c.setPoint()和c.getX()、c.getY()可见，这些成员函数是在基类Point中定义的公有成员函数，派生类Circle则可以直接调用；还有x和y坐标值在基类Point中为保护成员，所以在派生类Circle类内部可直接调用，类外部无法访问。

另外，Point &p引用变量用派生类Circle对象c进行初始化，注意的是引用变量p不是对象c的别名，而是基类Point的别名，与对象c中基类部分共享同一段存储单元。这块在前一篇中“四、基类与派生类的转换”有讲解过，派生类对象可以替代基类对象为基类对象的引用初始化或赋值。地址：C++面向对象程序设计 - 多继承，以及基类与派生类转换-CSDN博客。

三、声明派生类Cylinder

前面通过基类Point派生出Circle类，现在再通过Circle类派生出Cylinder（圆柱体）类。代码如下：

#include <iostream>
using namespace std;
// 声明类Point
class Point{
	public:
		Point(float x = 0, float y = 0);			//有默认参数的构造函数
		void setPoint(float, float);				// 设置坐标值
		float getX() const { 
			return x;
		}
		float getY() const {
			return y;
		}
		friend ostream & operator <<(ostream &, const Point&);		//重载运算符 <<
	protected:
		float x, y;
};
// Point构造函数
Point::Point(float a, float b){
	x = a;
	y = b;
}
// 设置x和y的坐标值
void Point::setPoint(float a, float b){
	x = a;
	y = b;
}
// 重载运算符 "<<"，使之能输出点的坐标
ostream & operator <<(ostream &output, const Point &p){
	output <<'[' <<p.x <<',' <<p.y <<']' <<endl;
	return output;
}

// 声明Circle类，并公有继承基类Point
class Circle: public Point{
	private:
		float radius;
	public:
		// 定义Circle构造函数，对圆心坐标和半径初始化
		Circle(float x = 0, float y = 0, float r = 0): Point(x, y), radius(r){}		
		// 定义设置半径函数
		void setRadius(float r){
			radius = r;
		}
		// 定义获取半径的函数
		float getRadius() const{
			return radius;
		}
		// 声明计算面积的函数
		float area() const{
			return 3.1415926 * radius * radius;
		}
		// 声明重置运算符 << 的友函数	
		friend ostream & operator << (ostream &, const Circle &);		
};
// 定义重载运算符 << 输出圆的信息
ostream & operator << (ostream &output, const Circle &c){
	output <<"Center=[" <<c.x <<',' <<c.y <<"], r=" <<c.getRadius() <<", area=" <<c.area() <<endl;
	return output; 
}

// 声明Cylinder类
class Cylinder: public Circle{
	private:
		float height;
	public:
		// 构造函数
		Cylinder(float x = 0, float y = 0, float r = 0, float h = 0): Circle(x, y, r), height(h){}
		// 设置圆柱高
		void setHeight(float h){
			height = h;
		}
		// 获取圆柱的高
		float getHeight(){
			return height;
		}
		// 计算圆柱表面试
		float area() const {
			// 圆柱体上下两个底面， 以及圆周长公式为 2πr，再乘以高只是柱面面积
			return 2 * Circle::area() + 2 * 3.1415926 * getRadius() * height;
		}
		// 计算圆柱体积
		float volume() const{
			return Circle::area() * height;
		}
		// 声明重载运算符 <<
		friend ostream & operator << (ostream &, const Cylinder &);		
};
// 定义Cylinder重载运算符
ostream & operator << (ostream &output, const Cylinder &c){
	output <<"Center=[" <<c.x <<',' <<c.y <<"], r=" <<c.getRadius() <<", area=" <<c.area() 
			<<", volume=" <<c.volume() <<endl;
	return output; 
}
int main(){
	Cylinder c(3.5, 6.5, 5.2, 10);		//创建Cylinder对象c，并指定圆柱体坐标和半径、高度
	cout <<"Cylinder Original information:" <<endl;
	// 输出圆的坐标和半径信息
	cout <<"x=" <<c.getX() <<",y=" <<c.getY() <<", radius=" <<c.getRadius() <<", area=" <<c.area() <<", volume=" <<c.volume() <<endl;	
	
	c.setPoint(8.5, 6.8);		// 修改圆柱体的坐标
	c.setRadius(8);				// 修改圆柱体的半径信息
	c.setHeight(15);			// 修改圆柱体的高度
	cout <<endl <<"Cylinder New information:" <<endl;
	// 重载运算符，使之输出对象c的信息
	cout <<"c object:" <<c <<endl;
	
	// 通过Point类的引用变量，被c初始化
	Point &p = c;
	// 输出引用变量p的信息
	cout <<"Point Reference:" <<p <<endl;
	
	// 通过Circle引用变量c1，被c初始化
	Circle &c1 = c;
	// 输出引用变量c1的信息
	cout <<"Circle Reference:" <<c1 <<endl;
	return 0;
}

运行结果如下图：

以上场景中，讨论的是圆柱体（Cylinder）对象，与点（Point）和圆（Circle）对象有所关联。另外两种不同的对象引用：一个点（Point）对象，另一个是圆（Circle）对象，它们共享相同的中心坐标（Center），但具有不同的属性和方法。它们之间的关系和所展示的结构体现了面向对象编程中的多态性（Polymorphism）。

多态性是面向对象编程中一个重要概念，它允许使用父类（基类）的引用指向子类（派生类）的对象，并且能调用子类中重写的方法，而不需要知道引用所指向的具体子类类型。

多态性允许不同的对象对同一消息（方法调用）做出不同的响应，这个例子中c1.area()函数调用的是Cylinder类中area()函数（求圆的表面积），而c1.area()函数调用的Circle类中area()函数（求圆的面积）。