更适合滑湿宝宝的类的定义与使用笔记

一、情境引入

为了更好地体会类和对象的定义与使用，我们以sgq御用白皮书项目1（A）的第一题为例，逐步学习。

题目：编写一个people类。该类的数据成员有年龄，身高，体重。函数成员有进食，运动，睡眠。其中进食函数使体重加1，运动函数使身高加1，睡眠函数使年龄、身高、体重各加1。要求所有成员为public公有访问权限，在主函数中通过类对象直接访问类的所有成员。

二、代码实现

        1、基于过程的程序设计：

        我们先基于过程的程序设计思路来解决这道题，分别调用几个函数，同时在函数的编写中同时用到了C++的三种函数调用方式：传值调用，传址调用以及引用调用，程序如下：

#include<iostream>
using namespace std;
int eatting(int weight);
void sporting(int* height);
void sleeping(int&, int&, int&);//三个函数的声明
int main()
{
	int age;
	int height;
	int weight;//三个数据的定义
	cout << "请分别输入年龄，身高与体重：";
	cin >> age >> height >> weight;
	weight=eatting(weight);
	sporting(&height);
	sleeping(age, weight, height);
	cout << "执行函数后各参数如下：" << endl;
	cout << age << " " << height << " " << weight << endl;
}
int eatting(int weight) {
	weight++;
	return weight;
}
void sporting(int* height) {
	*height+=1;
}
void sleeping(int& age, int& weight, int& height){
	age++;
	weight++;
	height++;
}

2、面向对象的程序设计：

概念1：对象

        客观世界任何一个事物都可以看做一个对象。题目中的一个人就可以看做一个对象，他有很多静态特征，如年龄，身高，体重等；同时它也具有诸多动态的特征，比如进食，睡眠，运动等。一个对象应当具有两个要素，属性和行为，也就是说：对象是由一组属性和一组行为构成的。这里的“属性”就是“数据”，“行为”就是“函数”。

概念2：类（class）

        类是对象的抽象，对象是类的具体实例。与结构体相类似，我们一般先声明一个类类型，然后用它去定义若干个同类型的对象。对象就是类类型的一个变量。

概念3：成员访问限定符public

类声明中的成员访问限定符public代表着“公用的”，被声明为公用的成员，既可以被本类中的成员函数所引用，也可以被类的作用域内的其他函数所引用。

概念4：成员运算符（.）

我们在结构体中"p1.age=19"的语句表示将整数19赋值给对象p1中的数据成员age。其中“.”是成员运算符，用来对成员进行限定，指明所访问的是哪个对象中的成员。访问对象成员的一般形式为“对象名.成员名”。不仅可以在类外引用对象的公用数据成员，而且还可以调用对象的公用成员函数，同样需要指出对象名。

2.1 提取静态属性

        这里我们将对象的静态属性从程序中抽离出来，形成一个people类，其中的age，height，weight就是对象具有的静态属性，为了在主函数中可以使用它们，我们在类中将其访问属性设定为public。主函数中声明类的成员后，我们利用“成员名.数据名”的语句就可以进行相关数据的引用。修改后代码如下：

#include<iostream>
using namespace std;
int eatting(int weight);
void sporting(int* height);
void sleeping(int&, int&, int&);//三个函数的声明
class people {//类的声明
public:
	int age;
	int height;
	int weight;//三个静态属性的定义
};
int main()
{
	people p1;//对象的声明（类名 对象名;）
	cout << "请分别输入年龄，身高与体重：";
	cin >> p1.age >> p1.height >> p1.weight;//(用对象名.变量名来使用public数据)
	p1.weight=eatting(p1.weight);
	sporting(&p1.height);
	sleeping(p1.age, p1.weight, p1.height);
	cout << "执行函数后各参数如下：" << endl;
	cout << p1.age << " " << p1.height << " " << p1.weight << endl;
	return 0;
}
int eatting(int weight) {
	weight++;
	return weight;
}
void sporting(int* height) {
	*height+=1;
}
void sleeping(int& age, int& weight, int& height){
	age++;
	weight++;
	height++;
}

概念5：成员访问限定符private

        与public相对，被声明为私有的成员，只能被本类中的成员函数引用，类外不能调用（友元类除外）需要注意的是：如果在类的定义中既不指定private，也不指定public，则系统默认为是私有的。

2.2 提取动态属性

        这里我们将对象的动态属性从程序中抽离出来，继续完善people类，其中的eatting,sporting,sleeping就是对象具有的动态属性，因为只有类中的成员需要调用这几个函数，所以我们将数据声明为private,把函数声明为public以供调用。由于我们将数据声明为private，导致主函数无法直接引用它的值，所以我们还需要编写input函数与output函数完成输入与输出，修改后代码如下：

#include<iostream>
using namespace std;

class people {
private://本行可以省略
	int age;
	int height;
	int weight;//三个静态属性的定义
public:
	//三个动态属性的定义以及输入输出函数的定义
	void eatting() {
		weight++;
	}
	void sporting() {
		height ++;
	}
	void sleeping() {
		age++;
		weight++;
		height++;
	}
	void input()
	{
		cout << "请分别输入年龄，身高与体重：";
		cin >> age >> height >> weight;
	}
	void output()
	{
		cout << "执行函数后各参数如下：" << endl;
		cout << age << " " << height << " " << weight << endl;
	}
};

int main()
{
	people p1;
	p1.input();//调用成员函数（成员名.函数名）
	p1.eatting();
	p1.sporting();
	p1.sleeping();
	p1.output();
	return 0;
}

概念6：作用域限定符（::）

        “::”是作用域限定符，或称作用域运算符，可以用它声明函数是属于哪个类的，如people::input(）表示people类的作用域中的input函数，也就是people类中的input函数。如果没有“people::”的限定，则不是people类中的input函数。由于不同的类中可能有不同名的函数（功能也可能不同），用作用域运算符就可以加以限定，明确地指明了它是哪一个作用域的函数，也就是哪个类的函数。

2.3 在类外定义成员函数

        学习了作用域限定符后，我们可以在类体中只对成员函数进行声明，而在类的外面进行函数的定义，修改如下：

#include<iostream>
using namespace std;

class people {
private://本行可以省略
	int age;
	int height;
	int weight;//三个静态属性的定义
public:
	//三个动态属性的声明以及输入输出函数的声明
	void eatting();
	void sporting();
	void sleeping();
	void input();
	void output();
};
//在类外进行函数的定义
void people::eatting() {
	weight++;
}
void people::sporting() {
	height++;
}
void people::sleeping() {
	age++;
	weight++;
	height++;
}
void people::input() {
	cout << "请分别输入年龄，身高与体重：";
	cin >> age >> height >> weight;
}
void people::output() {
	cout << "执行函数后各参数如下：" << endl;
	cout << age << " " << height << " " << weight << endl;
}

int main()
{
	people p1;
	p1.input();
	p1.eatting();
	p1.sporting();
	p1.sleeping();
	p1.output();
	return 0;
}

前面几个代码的运行结果均如下图所示：

 

 2.4批量处理对象

        我们在2.3已经完成了基本的类的定义与使用，但只处理了一个对象的信息，我们可以多定义几个对象，完成对象的批量处理，用时我还在主函数添加了num变量来统计处理的数据并赋值给类中的number中，完成每个人的编号，再输出时就可以省略参数的部分，直接引用类内的编号即可，展示了主调函数与类沟通的方式之一。代码实现如下：

#include<iostream>
using namespace std;

class people {
private://本行可以省略
	int age;
	int height;
	int weight;//三个静态属性的定义
public:
	int number;
	//三个动态属性的声明以及输入输出函数的声明
	void eatting();
	void sporting();
	void sleeping();
	void input(int num);
	void output();
};
//在类外进行函数的定义
inline void people::eatting() {
	weight++;
}
void people::sporting() {
	height++;
}
void people::sleeping() {
	age++;
	weight++;
	height++;
}
void people::input(int num) {
	cout << "请分别输入第"<<num<<"个人的年龄，身高与体重：";
	cin >> age >> height >> weight;
}
void people::output() {//再输出时就可以直接引用类中的public成员number
	cout << "执行函数后第"<<number<<"个人的年龄，身高与体重如下：" << endl;
	cout << age << " " << height << " " << weight << endl;
}

int main()
{
	people p1, p2;
	int num=1;//编号从1开始
	p1.input(num);//把主函数中的num变量作为参数传入类中
	p1.number = num;//编号赋值
	num++;
	p2.input(num);
	p2.number = num;
	p1.eatting();
	p1.sporting();
	p1.sleeping();
	p2.eatting();
	p2.sporting();
	p2.sleeping();
	p1.output();
	p2.output();
	return 0;
}

 代码执行结果如下图所示：

三、结语：

对应的简单练习与解析已经上线啦~点击下方链接趁热打铁吧：

类的构建与输出的应用与练习-CSDN博客