基于C++的面向对象程序设计：类与对象的深入剖析
面向对象程序设计的基本特点
面向对象程序设计的基本特点包括：抽象、封装、继承、多态。
抽象
抽象是指对具体问题或对象进行概括，抽出其公共性质并加以描述的过程。一般情况抽象分为数据抽象和行为抽象，其中数据抽象是指一个对象区别于另一个对象的特征，行为抽象是指某类对象的共同特征。
封装
封装是指将抽象得到的数据和行为相结合，隐藏对象属性和实现细节且仅对外提供公共访问方式的过程。
继承
继承是指通过代码复用在保持原有类特性的基础上对子类进行具体说明的过程，通俗来说继承就是精简重复代码的手段。
多态
多态是指一段程序能够处理多种类型对象的能力，函数重载就是实现多态的一种手段。在 C++ 语言中多态可分为强制多态、重载多态、类型参数化多态和包含多态。
类
类是 C++ 语言支持面向对象思想的重要机制，是实现封装的基本单元。类和对象是面向对象程序设计（OOP）的基本概念。在C++中，类是一种用户自定义的数据类型，它封装了数据成员和成员函数。对象是类的实例化，通过创建对象可以访问类的成员。
类的定义通常包括以下部分：
- 类名：用于标识类的名称。
- 数据成员：用于存储类的属性。
- 成员函数：用于操作类的属性。
- 访问控制符：用于控制类成员的访问权限，如public、protected和private。
对象的创建和使用如下：
- 声明对象：使用类名声明一个对象，例如
ClassName objectName;。 - 初始化对象：可以在声明对象时进行初始化，例如
ClassName objectName(parameters);。 - 访问对象成员：使用对象名和点运算符访问对象的成员，例如
objectName.memberName;。
类的定义
类一般由类名、数据成员、函数成员三部分组成，定义类的基本形式为：
class 类的名称
{
public：
外部接口
protected：
保护性成员
private：
私有成员
}其中 public、protected、private 表示访问控制属性，用于控制类成员的访问权限。特别的，没有分配控制属性的默认为 private 私有成员。
类成员访问控制
使用 public 关键字声明的公有成员可在类外访问，即公有类型成员定义了外部接口。输入：
#include
using namespace std;
class area //定义 area 类。
{
public: //定义公有成员，外部可以访问。
double width;
double length;
};
int main()
{
area area1; //定义对象 area1。
double AREA; //定义双精度型变量 AREA。
area1.width=3; //外部访问公有成员，设置宽为 3。
area1.length=3.1; //外部访问公有成员，设置长为 3.1。
AREA=area1.width*area1.length; //计算面积。
cout << AREA < 此程序可以分为相对独立的两个部分，一是对 area 类的定义，二是主函数 main()。area 类定义了两个双精度型的公有成员，主函数访问类的公有成员实现数字相乘。
程序结果：
使用 protected 关键字声明的受保护成员可在子类中访问。输入：
#include
using namespace std;
class area //定义 area 类。
{
protected://定义受保护的成员。
double width;
};
class squarearea:area //定义 squarearea 子类。
{
public: //定义公有成员。
void setsquarewidth(double wid); //定义成员函数。
double getsquarewidth(void);
};
//定义子类的成员函数。
void squarearea::setsquarewidth(double wid)
{
width=wid; //通过 squarearea 子类访问 area 类中受保护的成员 width。
}
double squarearea::getsquarewidth(void)
{
return width;
}
//程序的主函数 。
int main()
{
squarearea square; //定义对象。
square.setsquarewidth(3.1); //设置宽度为 3.1。
cout <<"width:"< 此程序可以分为相对独立的三个部分，一是对 area 类的定义，二是对 squarearea 子类及子类函数的定义，三是主函数 main()。对于 area 类中受保护的成员 width 可以通过子类进行访问。
程序结果:
使用 private 关键字声明的私有成员只能被本类的成员函数访问。输入：
#include
using namespace std;
class area
{
public: //定义公有成员
double length;
void setwidth(double wid);
double getwidth(void);
private://定义私有成员
double width;
};
//定义公有成员函数
void area::setwidth(double wid)
{
width=wid;
}
double area::getwidth(void)
{
return width;
}
//主函数
int main()
{
area len1; //定义对象
area wid1;
len1.length=3.1; //访问 area 类公有成员。
cout<<"length:"< 此程序可以分为相对独立的两个部分，一是 area 类及其公有成员函数的定义，二是主函数 main()。私有成员 width 只能先被类中成员函数访问，再通过相关的公共成员函数实现外部访问。若在类外部使用 area.width=3.2; 方式访问 area 类的私有成员 width，则会报错。
程序结果：
对象
在 C++ 语言中，对象是某类事物的实例。其声明形式为：
类名 对象名；
例如声明 area 类的对象 square：
area square；
访问对象的成员
定义了类及其对象后，则可访问对象的成员。访问 数据成员 基本形式为：
对象名.成员名
例如访问 area 类的对象 square 的数据成员 width：
square.width=3.2;
访问 函数成员 的基本形式为：
对象名.函数名(参数表)
例如访问 area 类的对象 square 的函数成员 setwidth(double wid)：
square.setwidth(3.2);
类的成员函数
成员函数描述了类的行为。成员函数在类中只用说明其函数的返回类型、名字和参数表，而函数的具体实现在类外说明，其基本形式为：
class 类名
{
函数的返回类型 函数名(参数列表)
}
返回值类型 类名::函数名(参数列表) //特别的，在类外说明函数的具体实现时，需要使用类名限制成员函数，其形式为：类名::函数名(参数列表)。
{
函数体
}
例如在 area 类中有成员函数 void setwidth(double wid);：
class area
{
...
void setwidth(double wid);
...
}
//在类外说明函数的具体实现
void area::setwidth(double wid)
{
函数体
}访问类的公有成员计算体积
挑战
-
定义一个 volume 类，其中包含三个 double 型的公有成员 width、length、high。
-
在主函数中定义一个用于访问 volume 类成员的对象 volume1 和一个用于保存体积结果的双精度型变量 VOLUME。
-
返回 width 为 3、length 为 4，high 为 5.1 的体积结果。
目标
定义一个包含三个 double 型公有成员的类，主函数访问类的公有成员实现体积计算。
提示
- 一般使用 class 关键字来定义类。
- 对象的声明形式为：类名 对象名。
- 访问类的数据成员：对象名.成员名。
代码实现
#include
using namespace std;
class volume
{
public:
double width;
double length;
double high;
};
int main()
{
volume volume1;
double VOLUME;
volume1.width = 3;
volume1.length = 4;
volume1.high = 5.1;
cout << volume1.width << endl;
cout << volume1.length << endl;
cout << volume1.high << endl;
VOLUME = volume1.width * volume1.length * volume1.high;
cout << VOLUME << endl;
//3
//4
//5.1
//61.2
return 0;
} 希望对你有帮助！！加油各位！