第七章 类与对象

导入

1. 程序中的对象是现实中对象的模拟，具有属性和功能/行为；
2. 抽象出同一类对象的共同属性和行为，形成类，对象是类的实例；
3. 类将数据和处理数据的函数封装在一起，隐藏内部细节，提供对外访问接口；
4. 定义对象时，可以通过构造函数进行初始化；
5. 删除对象时，可以通过析构函数释放资源；
6. 一个类的对象可以有其他类的对象组合而成，即类的成员可以是其他类的对象；

类与对象

1. 对象是现实中的对象在程序中的模拟。
2. 类是同一类对象的抽象，对象时类的某一特定实体。
3. 定义类的对象，才可以通过对象使用类中定义的功能。

设计类就是设计类型：

1. 此类型的“合法值”是什么？
2. 此类型应该有什么样的函数和操作符？
3. 新类型的对象该如何被创建和销毁？
4. 如何进行对象的初始化和赋值？
5. 对象作为函数的参数如何以值传递？
6. 谁将使用此类型的对象成员？

类定义的语法形式

class 类名称
{public:公有成员（外部接口）private:私有成员protected:保护型成员
};

类内初始值：

1. 可以为数据成员提供一个类内初始值
2. 在创建对象时，类内初始值用于初始化数据成员
3. 没有初始值的成员将被默认初始化。

类内初始值举例：

class Clock {public:void setTime(int newH, int newM, int newS);void showTime();private:int hour = 0, minute = 0, second = 0;
};

类成员的访问控制

1. 公有类型成员：
   在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。

2. 私有类型成员：
   在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。
   如果紧跟在类名称的后面声明私有成员，则关键字private可以省略。

3. 保护类型成员：
   与private类似，其差别表现在继承与派生时对派生类的影响不同。

类成员的访问权限

1. 类中成员互相访问
2. 直接使用成员名访问
3. 类外访问：使用“对象名.成员名”方式访问 public 属性的成员

类的成员函数

在类中说明函数原型；
可以在类外给出函数体实现，并在函数名前使用类名加以限定；
也可以直接在类中给出函数体，形成内联成员函数；
允许声明重载函数和带默认参数值的函数。

内联成员函数

1. 为了提高运行时的效率，对于较简单的函数可以声明为内联形式。
2. 内联函数体中不要有复杂结构（如循环语句和switch语句）。
3. 在类中声明内联成员函数的方式：
4. 将函数体放在类的声明中。
5. 使用inline关键字。

类与对象程序应用举例

钟表类：类的定义：
#include <iostream>
using namespace std;
class Clock{
public:void setTime(int newH = 0, int newM = 0, int newS = 0;void showTime();
private:int hour, minute, second;
}成员函数的实现：
void Clock::setTime(int newH, int newM, int newS) {hour = newH;minute = newM;second = newS;
}
void Clock::showTime() {cout << hour << ":" << minute << ":" << second;
}对象的使用：
int main() {Clock myClock;myClock.setTime(8, 30, 30);myClock.showTime();return 0;
}

构造函数

构造函数的作用

在对象被创建时使用特定的值构造对象，将对象初始化为一个特定的初始态。

构造函数的形式

1. 函数名与类名相同；
2. 不能定义返回值类型，也不能有return语句；
3. 可以有形式参数，也可以没有形式参数；
4. 可以是内联函数；
5. 可以重载；
6. 可以带默认参数。

构造函数的调用时机

在对象创建时被自动调用。

默认构造函数

调用时可以不需要实参的构造函数：

1. 参数表为空的构造函数；
2. 全部参数都有默认值的构造函数。

隐含生成的构造函数如果程序中为定义构造函数，编译器将在自动生成。

一个默认构造函数：

1. 参数列表为空，不为数据成员设置初始值；
2. 如果类内定义了成员的初始值，则使用内类定义的初始值；
3. 如果没有定义类内的初始值，则以默认方式初始化；
4. 基本类型的数据默认初始化的值是不确定的。

“=default”：
如果程序中已定义构造函数，默认情况下编译器就不再隐含生成默认构造函数。如果此时依然希望编译器隐含生成默认
构造函数，可以使用：“= default”。

例：

class Clock {public:Clock() = default; //指示编译器提供默认构造函数；Clock(int newH, int newM, int newS); //构造函数；private:int hour, minute, second;
);

构造函数实例

//类定义class Clock {
public:Clock(int newH,int newM,int newS);//构造函数void setTime(int newH, int newM, int newS);void showTime();private:int hour, minute, second;
};//构造函数的实现：
Clock::Clock(int newH,int newM,int newS): hour(newH),minute(newM),  second(newS) {}int main() {Clock c(0,0,0); //自动调用构造函数c.showTime();return 0;
}默认构造函数例1：
class Clock {
public:Clock(int newH, int newM, int newS); //构造函数Clock(); //默认构造函数void setTime(int newH, int newM, int newS);void showTime();
private:int hour, minute, second;
};Clock::Clock(): hour(0),minute(0),second(0) { }//默认构造函数//其它函数实现同前int main() {Clock c1(0, 0, 0);       //调用有参数的构造函数Clock c2;         //调用无参数的构造函数……
}

委托构造函数

委托构造函数使用类的其他构造函数执行初始化过程。
例如：

Clock (int newH, int newM, int newS):
hour(newH), minute(newM), second(newS) {
}
Clock() : Clock(0, 0, 0) {}

复制构造函数

复制构造函数是一种特殊的构造函数，其形参为本类的对象引用。
作用是用一个已存在的对象去初始化同类型的新对象。

class类名 {
public :类名（形参）；//构造函数类名（const 类名 &对象名）；//复制构造函数//      ...
}；
类名::类（const  类名&对象名）//复制构造函数的实现
{   函数体   }

隐含的复制构造函数：

如果程序员没有为类声明拷贝初始化构造函数，则编译器自己生成一个隐含的复制构造函数。
这个构造函数执行的功能是：用作为初始值的对象的每个数据成员的值，初始化将要建立的对象的对应数据成员。
“=delete”：
如果不希望对象被复制构造：

1. C++98做法：将复制构造函数声明为private，并且不提供函数的实现。
2. C++11做法：用“=delete”指示编译器不生成默认复制构造函数。

例：

class Point {   //Point 类的定义
public:Point(int xx=0, int yy=0) { x = xx; y = yy; }    //构造函数，内联Point(const Point& p) =delete;  //指示编译器不生成默认复制构造函数
private:int x, y; //私有数据
};

复制构造函数被调用的三种情况:

1. 定义一个对象时，以本类另一个对象作为初始值，发生复制构造；
2. 如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生复制构造；
3. 如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化一个临时无名对象，传递给主调函数，此时发生复制构造。
   （这种情况也可以通过移动构造避免不必要的复制。）

析构函数

1. 完成对象被删除前的一些清理工作；
2. 在对象的生存期结束的时刻系统会自动调用它，然后再释放此对象所属的空间；
3. 如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数，其函数体为空；
4. 构造函数与析构函数举例：

#include <iostream>
using namespace std;
class Point {     
public:Point(int xx,int yy);~Point();//...其他函数原型
private:int x, y;
};

类的组合

组合的概念： 类中的成员是另一个类的对象。可以在已有抽象的基础上实现更复杂的抽象。

类组合的构造函数设计：
原则：不仅要负责对本类中的基本类型成员数据进行初始化，也要对对象成员初始化。
声明形式：

类名::类名(对象成员所需的形参，本类成员形参）
：对象1（参数），对象2（参数），……
{//函数体其他语句
}

构造组合类对象时的初始化次序：

1. 首先对构造函数初始化列表中列出的成员（包括基本类型成员和对象成员）进行初始化，
   初始化次序是成员在类体中定义的次序。
2. 成员对象构造函数调用顺序：按对象成员的声明顺序，先声明者先构造。
3. 初始化列表中未出现的成员对象，调用默认构造函数（即无形参的）初始化。
4. 处理完初始化列表之后，在再执行2构造函数的函数体。

类组合程序举例：

//线段（LIne）类
#include <iostream>
#include <cmath>
using namespace std;class Point { //Point类的定义
public :
Point (int xx = 0, int yy = 0) {x = xx;y = yy;
}Point(Point &p);
int getX() {return x;}
int getY() {return y;}private: int x, int y;
}Point::Point (Point &p) { //复制构造函数的实现x = p.x;y = p.y;cout << "Calling the copy constructor of Point" << endl;
}//类的组合
class Line { //Line类的定义
pubilc: //外部接口
Line (Point xp1, Point xp2);
Line(Line &l);
double getLen() {return len;}
private; ///私有数据成员
Point p1, p2; //Point类的对象p1，p2
double len;
}//组合类的构造函数
Line::Line(Point xp1, Point xp2) : p1(xp1), p2(xp2) {
cout << "Calling constructor of Line" << endl;
double x = static_cast<double>(p1.getX() - p2.getX());
double y = static_cast<double>(p1.getY() - p2.getY());
len = sqrt(x * x + y * y);
}Line::Line (Line &l): p1(l.p1), p2(l.p2) { //组合类的复制构造函数
cout << "Calling the copy constructor of Line" << endl;
len = l.len;
}//主函数int main() {
Point myp1(1, 1), myp2(4, 5); //建立Point类的对象
Line line(myp1, myp2); //建立Line类的对象
Line line2(line); //利用复制构造函数建立一个新对象
cout << "The length of the line is: ";
cout << line.getLen() << endl;
cout << "The length of the line2 is: ";
cout << line2.getLen() << endl;
return 0;
}

前向引用声明

1. 类应该先声明，后使用；
2. 如果需要在某个类的声明之前，引用该类，则应进行前向引用声明；
3. 前向引用声明只为程序引入一个标识符，但具体声明在其他地方。
   例：

class B; //前向引用声明
class A {
public :void f(B, b);
};
class B {
public:void f(A, a);
};

注意事项：

1. 使用前向引用声明虽然可以解决一些问题，但它并不是万能的。
2. 在提供一个完整的类声明之前，不能声明该类的对象，也不能在内联成员函数中使用该类的对象。
3. 当使用前向引用声明时，只能使用被声明的符号，而不能涉及类的任何细节。
   例：

class Fred; //前向引用声明
class Barney {Fred x; //错误：类Fred的声明尚不完善
};class Fred {Barney y;
};

UML简介

三个基本的部分：1. 事物（Things）2. 关系（Relationships）3. 图（Diagrams）
在UML中，虚线箭头表示：依赖；实线空心三角形表示：继承；实线空心菱形表示：共享聚集；实线实心菱形表示：组成聚集。

结构体

1. 结构体是一种特殊形态的类；
2. 与类的唯一区别：类的缺省访问权限是private，结构体的缺省访问权限是public；
3. 结构体存在的主要原因：与C语言保持兼容。
   什么时候用结构体而不用类：
   1、 定义主要用来保存数据，而没有什么操作的类型；
4. 人们习惯将结构体的数据成员设为共有，因此这时用结构体更方便、

结构体的定义：

struct 结构体名称 {公有成员
protected:保护型成员
private:私有成员
};

结构体的初始化：
如果一个结构体的全部数据成员都是公共成员，并且没有用户定义的构造函数，没有基类和虚函数，
这个结构体的变量可以用下面的语法形式赋初值。

类型名 变量名 = { 成员数据1初值, 成员数据2初值, …… };

例：用结构体表示学生的基本信息

#include <iostream>
using namespace std;struct Student {	//学生信息结构体int num;		//学号string name;	//姓名，字符串对象，将在第6章详细介绍char sex;		//性别int age;		//年龄
};int main() {Student stu = { 97001, "Lin Lin", 'F', 19 };cout << "Num:  " << stu.num << endl;cout << "Name: " << stu.name << endl;cout << "Sex:  " << stu.sex << endl;cout << "Age:  " << stu.age << endl;return 0;
}

运行结果：

Num:  97001
Name: Lin Lin
Sex:  F
Age:  19

联合体

声明形式：

union 联合体名称 {公有成员
protected:保护型成员
private:私有成员
};

特点：

1. 成员共用同一组内存单元；
2. 任何两个成员不会同时有效。

联合体的内存分配：
例：

union Mark {	//表示成绩的联合体char grade;	//等级制的成绩bool pass;	//只记是否通过课程的成绩int percent;	//百分制的成绩
};
[object Object]

无名联合：
例：

union {int i;float f;
}

在程序中可以这样使用

i = 10;
f = 2.2;

联合体的应用举例：使用联合体保存成绩信息，并且输出

#include <iostream>
using namespace std;
class ExamInfo {
private:string name;	//课程名称enum { GRADE, PASS, PERCENTAGE } mode;//计分方式union {char grade;	//等级制的成绩bool pass;	//只记是否通过课程的成绩int percent;	//百分制的成绩};
public://三种构造函数，分别用等级、是否通过和百分初始化ExamInfo(string name, char grade): name(name), mode(GRADE), grade(grade) { }ExamInfo(string name, bool pass): name(name), mode(PASS), pass(pass) { }ExamInfo(string name, int percent): name(name), mode(PERCENTAGE), percent(percent) { }void show();
}void ExamInfo::show() {cout << name << ": ";switch (mode) {case GRADE: cout << grade;  break;case PASS: cout << (pass ? "PASS" : "FAIL"); break;case PERCENTAGE: cout << percent; break;}cout << endl;
}int main() {ExamInfo course1("English", 'B');ExamInfo course2("Calculus", true);ExamInfo course3("C++ Programming", 85);course1.show();course2.show();course3.show();return 0;
}

运行结果：

English: B
Calculus: PASS
C++ Programming: 85