【Essential C++学习笔记】第四章 基于对象的编程风格

第四章 基于对象的编程风格

面向对象编程概念：
  面向对象编程概念的两项最主要特质是∶继承(inheritance)和多态(polymorphism)。前者使我们得以将一群相关的类组织起来，并让我们得以分享其间的共通数据和操作行为，后者让我们在这些类之上进行编程时，可以如同操控单一个体，而非相互独立的类，并赋予我们更多弹性来加入或移除任何特定类。

一般而言，class由两部分组成：一组公开的（public）操作函数和运算符以及一组私有的（private）实现细节。

• 这些操作函数和运算符称为class的成员函数（member function），代表这个class的公开接口，用户只能访问公开接口。
• class的private实现细节可有member function的定义以及与此class相关的任何数据组成。

4.1 如何实现一个class

class的声明以关键字class开始，其后接一个class名称

class Stack;
1

class 定义由两部分组成：class的声明和紧接其后的主体。主体内的两个关键字public和private，用来标示每个块的member访问权限。

• public member可以在程序的任何地方被访问，private member只能在member function或是class friend内被访问：

class Stack{
public:
	//任何操作函数如果执行成功，就返回true
	//pop和peek（查看）会将字符串内容置于elem内
	bool push( const string& );
	bool pop( string &elem );
	bool peek( string &elem );

	bool empty();
	bool full();

	//size()定义于class本身中，
	//其他member这里只是声明
	int size() {return _stack.size(); }

private:
	vector _stack;
	//习惯上在data member之前加下划线
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

所有member function都必须在class主体内进行声明。

如果要在class主体内定义，这个member function会自动被视为inline函数（比如上述的size()）。

1）主体内定义：见上 size()

2）主体外定义

• 在主体之外定义member function，必须使用特殊的语法（类名+类作用域解析运算符class scope resolution）告诉编译器该函数究竟属于哪一个class。

//两个冒号即类作用域解析运算符
bool Stack::empty()
{
	return _stack.empty();
}
1
2
3
4
5

4.2 构造函数和析构函数

C++何时调用构造函数，何时调用析构函数

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

1)构造函数

• 如果我们提供一个或多个特别的函数对data member进行初始化，编译器会在每次class object被定义出来时调用适当的函数加以处理。这些特别的初始化函数称为constructor（构造函数）。

1.函数构造法

• 第一种初始化语法 ：constructor的函数名称必须与class名称相同，不指定返回类型，亦不用返回任何值，可以被重载**：

  class Triangular {
  	public:
  		//一组重载的constructor
  		Triangular(); //default constructors
  		Triangular(int len){	// 类内定义构造函数
  			_length = len;
  			_beg_pos = 1;
  			_next = 0;
  		};
  		
  		Triangular(int len, int beg_pos): _length(len), _beg_pos(beg_pos) {
  			cout << "构造函数初始化列表" << endl;
  		};
  		void cout_elems()const {
  			cout << "_length：" << _length << "\n_beg_pos：" << _beg_pos << endl;
  		}
  	private:
  		int _next;
  		int _beg_pos;
  		int _length;
  }; 
  //默认的构造函数的定义方式1
  //类主体外定义构造函数
  Triangular::Triangular()
  {
  	_length=1;
  	_beg_pos=1;
  	_next=0;
  }
  
  int main() {
  	Triangular t1; // 默认调用无参数构造函数
  	Triangular t2(5);
  	Triangular t3(5, 3);
  	t1.cout_elems();
  	t2.cout_elems();
  	t3.cout_elems();
  	return 0;
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39

  Triangular t1;会对t1应用default constructor（无需任何参数的constructor）；
  Triangular t2(10, 3);会调用带有两个参数的构造函数，括号内的值被视为传给constructor的参数；

  Triangular t3 = 8;会调用带有单一参数的constructor，而不是赋值运算（ ? 我推测是因为会重载运算符）；
  Triangular t5();无法成功定义Triangular对象，而是将t5定义为一个函数，参数列表为空，返回Triangular对象——因为C++兼容C，对C而言，t5后带小括号会使其被视为函数。Triangular t5; // ok

2.成员初始化列表

• 成员初始化列表是构造函数的第二种初始化语法，主要用于将参数传给member class object的constructor,参数列表里保护传址符&

  class Triangular {
      public:
      // ...
      private:
      	int _next,_length,_beg_pos;
  }
  
  //紧接在参数列表最后的冒号后面，是个以逗号分隔的列表，
  Triangular::Triangular(const Triangular &rhs) // & 传址,
  	: _length(rhs._length),  // 欲赋值给member的数值被放在member名称后面的小括号中：
  	  _beg_pos(rhs._beg_pos),
  	  _next(rhs.beg_pos - 1)
  { } //对，这个大括号里是空的
  //rhs是类对象，这里引用了类对象且不会对类对象做任何修改
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

2)析构函数

• 析构函数是用户自定义的一个class member。在其类对象结束生命周期时，由析构函数处理善后这个类对象。**析构函数主要用来释放在**构造函数或类对象生命周期中分配的资源（构造函数初始化了数据成员（给了数据成员初值和内存）即为分配给数据成员资源！！）。

• 析构函数的名称有严格规定：class名称前加上~前缀。绝对不会有返回值，也没有任何参数，其参数列表是空的，因而也不能被重载：

  class Matrix {
  	public:
  		Matrix(int row, int col)
  			: _row(row), _col(col)
  		{
  			//构造函数进行资源的分配
  			_pmat = new double[row * col]; 
  		}
  		
  		~Matrix()
  		{
  			//析构函数进行资源的释放
  			delete [] _pmat; 
  		}
  		
  	private:
  		int _row, _col;
  		double* _pmat;
  };
  //通过Matrix本身的构造函数和析构函数，完成了内存的自动管理
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

C++何时需要自定义析构函数呢？

1）如果本类中一个成员变量是别的对象的指针，而且这个指针不是传进来的地址而是这个指针指向的对象，是在本类中(如果是栈里的定位分配，也不用考虑内存)在堆中开辟的空间创建的。并且该指针没有进行过delete操作，那么久需要在析构方法中进行delete操作，此时我们就必须自己写析构函数 。

#include 
using namespace std;

//日期类
class Date {
		int year, month, day;
	public:
		//构造函数
		Date(int y, int m, int d): year(y), month(m), day(d) {
			cout << "调用了日期类的构造方法" << endl;
		}
		//对象销毁时  如果我们自己没有写析构方法，编译器会帮我们写一个然后调用
		~Date() {
			cout << "日期对象销毁了 ~Date()" << endl;
		}
};

//员工类
class Employee {
		string name;
		Date *birthday;//声明一个指针  在构造方法里面让它指向一个对象
	public:
		//构造方法
		Employee (string name): name(name) {
			birthday = new Date(1989, 8, 8); //这里会调用日期的构造方法
			cout << "调用了员工类的构造方法" << endl;
		}
		//析构方法
		~Employee() {
			cout << "员工对象销毁了" << endl;
		}

};

int main() {
	Employee em("假如我是张三");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

从运行结果可以知道创建的日期对象并没有销毁，所以有内存泄漏！

为什么泄漏了？因为出了mian函数，员工对象销毁，两个成员变量name和日期指针birthday在员工销毁的时候弹栈了，但是birthday指针指向的堆内存并没有销毁。所以应该在指针销毁之前释放指针指向的内存空间。

那么应该在哪里释放？员工对象在销毁的时候一定调用析构函数，所以在析构方法里对指针birthday进行delete，先把堆里开辟的内存空间清除掉，然后这个员工对象再销毁，所有内存才没有问题。

重写员工的析构函数如下:

		~Employee() {
			delete birthday;//清除指针指向的内存空间
			cout << "员工对象销毁了" << endl;
		}
1
2
3
4

2）全局区的对象在程序一开始就创建，程序结束才会销毁。栈区的对象在调用函数(代码块，如for循环里面)的时候才会创建，出了函数就会销毁。 在堆中开辟空间创建的对象必须我们自己手动delete。

重写main函数如下: （仔细看打印）

int main() {

	Employee em("假如我是张三");

	cout << "===== 1 栈里的对象 ======" << endl;
	for (int i = 0; i < 3; i++) {
		Date d(2015, 1, 23);
	}

	cout << "===== 2 ======" << endl;
	{
		Date d2(2015, 1, 2);
		Date d3(2015, 1, 3);
		Date d4(2015, 1, 5);
		cout << "===== 3 ====" << endl;
	}

	cout << "=== 4 ====" << endl;

	{
		//这个代码块里会调用几次构造方法？？0次
		//因为这里只是创建指针并没有创建开辟空间对象
		Date *d5;
		Date *d6;
		Date *d7;
	}

	cout << "=== 5 ====" << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3）成员逐一初始化操作（复制对象）

Triangular tril1(8);
Triangular tril2 = tril2;
1
2

默认情形下，当我们以某个类对象作为另一个对象的初值时，class的成员对象会被依次复制。

注意：当有指针和地址类相关成员时，无法进行复制。如在Matrix类中，两个对象的_pmat会指向同一个数组。当该数组空间被释放时，会出现严重的错误。

如何解决 ？可以通过copy constructor改变这种 成员逐一初始化 的行为模式

Matrix::Matrix(const Matrix &rhs)
	: _row(rhs._row), _col(rhs._col)
{
	//对rhs._pmat所指的数组产生一份完全复本
	int elem_cnt = _row * _col;
	_pmat = new double[elem_cnt];
	
	for(int ix = 0;ix < elem_cnt;++ix)
		_pmat[ix] = rhs._pmat[ix]; 
}
1
2
3
4
5
6
7
8
9
10

4)标注const表明class object的内容不可变

class Triangular {
	public:
		//以下是const member function 
		int length() const {return _length;}
		int beg_pos() const {return _beg_pos;}
		int elem(int pos) const;
		//主体外定义时，
		//必须同时在声明和定义中指定const 
		
		//以下是non-const member function
		bool next(int &val);
		void next_reset() { _next = _beg_pos - 1; }
		
		//... 
	private:
		int _length; //元素个数 
		int _beg_pos; //起始位置 
		int _next; //下一个迭代目标 
		
		static vector _elems;
}; 

//主体外，定义也要包含const
int Triangular::elem(int pos) const
{
	return _elems[pos - 1];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4.3 mutabl(e可变)和const(不变)

1）const（不变的数据成员）

（2）为什么会有在函数参表后加一个const呢？
为了确保类对象的值（内容）不会被更改，必须要确保成员函数都不会更改他们的调用者——类对象的值（内容），所以类设计者要在成员函数的参表后加一个const来告诉编译器：这个成员函数不会更改类对象的内容

（2）const修饰符紧接在函数参表之后，在class主体以外定义的成员函数，如果是一个const成员函数，那么就必须同时在声明与定义中指定const，编译器会检查每个声明为const的成员函数（函数参表后加了个const)，检查他们是否真的更改了类对象的内容，如果更改了，编译器报错

• class主体内定义const函数

class Triangular{
public:
//以下是const成员函数
	int length() const{return _length;}//最好)和const中间加一个空格，不加也行。
	int beg_pos() const{return _beg_pos;}
	int elem(int pos) const;
//以下时非const成员函数
	bool next(int &val);
	void next_reaset()
	{
		_next=_beg_pos-1;
	}
	static vector_elems;//静态数据成员（以后说明）
1
2
3
4
5
6
7
8
9
10
11
12
13

• class主体外定义const函数。

int Triangular::elem(int pos)const//在这里指定const
{
	return _elems[pos-1];
}
1
2
3
4

（3）注意，提防着标注着const的成员函数返回一个非const引用，引用（“指向”）标注着const的成员函数的函数体内的对象
虽然没有修改标注着const的成员函数的函数体内的对象，但是这样做实际上是将标注着const的成员函数的函数体内的对象开放了出去（因为可以通过非const的引用来修改类对象的内容），允许程序在其他地方加以修改，如：

/*这里，虽然我val()成员函数（参表为空，返回值是BigClass的非const引用）的参表后标着const，意思是val()这个成员函数不会更改类对象的内容，但是我返回的是一个非const的引用“指向”着_val。这不就是把_val开放了出去（因为可以通过非const的引用来修改_val，也就是类对象的内容），允许程序在其他地方可以修改_val,也就是类对象的内容了！
*/
class val_class{
public:
	val_class(const BigClass &v)
		:_val(v){}
		//采用成员初始化列表的初始化语法（方式）
		//来定义val_class类的构造函数
	BigClass& val()const 
	{
		return _val；
	}
private:
	BigClass _val;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 如何解决呢？
  我们知道成员函数可以根据其参表后加没加const而决定是否重载本身（成员函数）。所以我们提供const版本的和非const版本的成员函数的定义。如下：

  class val_class{
  public:
  	const BigClass& val()const{return _val;}
  	BigClass& val(){return _val;}
  };
  1
  2
  3
  4
  5

• 非const的类对象会调用非const的成员函数val()，const的类对象调用参表后标注着const的成员函数val()。如下：

  void example(const BigClass *pbc,BigClass &rbc)
  {
  	//为了区分const版本和非const版本，让这两个版本的比较直观一些
  	//所以参表这么设计，
  	//注意果const位于*的左侧，则const就是用来修饰指针所指向的变量，
  	//即指针指向为常量（该指针为函数指针，指向的函数参表是空的
  	//且返回类型也会带个const什么什么。（毕竟函数指针的数据类型
  	//要和它指向的函数的返回类型是一致的！））
  	//第二个参数是一个引用，引用非const的成员函数
  	pbc->val();//调用const版本的成员函数val()
  	rbc.val();//调用非const版本的成员函数val()
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

2）mutable（可变的数据成员）

（1）关键字mutable可以让我们做出这样的声明：对数据成员所做的改变并不会破坏类对象的常量性。先看下面这个例子：

class Triangular{
public:
	bool next(int &val)const;
	void next_reset()const
	{
		_next=beg_pos-1;
	}
	//...
private:
	int _next;
	int _beg_pos;
	int _length;
};

int sum(const Triangular &trian)
{
	if(!trian.length())
	{
		return 0;
	}//类对象的长度这个数据成员是0的话，退出sum函数体
	int val,sum=0;
	trian.next_reset();
	while(trian.next(val))
	{
		sum+=val;
	}
	return sum;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• 注意_next这个数据成员（私有成员）。trian是个const类对象，而next_reset()函数和next()函数都会更改_next的值，这两个函数都不是const成员函数，但却被trian这个类对象调用。这是个语法错误
• 所以一开始我们会想到必须把next_reset()函数和next()函数改为const成员函数，但是这两个函数的函数体内确实改变了私有成员数据成员_next的值。

（2） 使用关键字mutable，

class Triangular{
public:
	bool next(int &val)const;
	void next_reset()const
	{
		_next=beg_pos-1;
	}
	//...
private:
	mutable int _next;
	int _beg_pos;
	int _length;
};
1
2
3
4
5
6
7
8
9
10
11
12
13

现在next_reset()函数和next()函数既可以修改_next的值，又可以被声明为const成员函数了,这里面关键字mutable起的作用就是告知编译器数据成员（这里为私有成员）_next的值可变，就是让这个数据成员变得“特殊”，改变“mutable 数据类型 对象名”的数据成员（这里为私有成员）不会破坏类对象的常量性！

4.4 this指针

• this指针，是一个能在成员函数里指向调用者（即类对象）的指针。我们需要一种可以指向整个类对象的指针，就是this指针。

• 欲以一个对象复制出另一个对象，先确定两个对象是否相同是一个好习惯(if(this != &rhs))，这必然运用this指针。

  Triangular& Triangular::copy(const Triangular &rhs)
  {
  	//检查两个类对象是不是私有成员公共接口什么的相同不相同，
  	//不相同复制个屁。
  	if(this!=&rhs)
  	{
  		_length=rhs._length;
  		_beg_pos=rhs._beg_pos;
  		_next=_rhs._beg_pos-1;
  	}
  	return *this;//不管能不能复制，都返回this指针指向的调用者（用copy成员函数的类对象）
  }
  tr1.copy(tr2);//返回的由this指针所指的类对象，
  //这句话就把tr2这个类对象作为了tr1这个类对象的初值
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

  ①我们可以在定义类成员函数的时候，用this指针去访问this指针指向的类对象的私有成员，利用这个特点从而去进行别的操作。

  ②我们可以在定义类成员函数的时候提领this指针来解决return谁的问题return *this;

代码实践：

#include 
#include 
using namespace std;

class Teacher {
	public:
		Teacher() {}

		Teacher(int age, string name, int tel_nember): _age(age), _name(name), _tel_number(tel_nember) {}

		Teacher ©(const Teacher &rhs) {
			if (this != &rhs)	{
				_age = rhs._age;
				_name = rhs._name;
				_tel_number = rhs._tel_number;
			}
		}

		void display_name() {
			cout << this->_name << endl;
		}
	private:
		int _age;
		string _name;
		int _tel_number;
};

int main() {
	Teacher A(18, "A", 1234);
	A.display_name();
	A.copy(A); //调用的对象与自己相同


	Teacher B;
	B.copy(A); //实际是这样 copy(&B, A);

	B.display_name();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

4.5 静态类成员

数据成员可以分静态变量、非静态变量两种

静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员…因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.静态成员在每个类中只有一个拷贝，是解决同一个类的不同对象之间数据和函数共享问题的。

非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问…非静态成员的生存期决定于该类的生存期…而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中。

一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数。

1）静态成员变量和静态成员函数

• 类中，static（静态） data member用来表示唯一的、可共享的member
• 静态成员变量可以在类的多个对象中访问，但是要在类外声明。不同对象访问的其实是同一个实体，它可以在同一类的所有对象中被访问。
• 普通成员和对象是绑定的，随对象的创建和释放而生死（不管在栈里还是堆里），类似于局部变量和malloc堆内存。静态成员变量在对象中不占用存储空间，其实是放在全局变量空间里的。
• 静态成员函数在类外实现时只需在类内声明时加static，类外实体无须加static关键字，否则是错误的（因为在类外实体前面加static会按照static修饰全局函数类理解）。

#include
#include
using namespace std;

class person
{
public:
	int age;			//普通成员变量
	static int nums;	//静态成员变量
	static void print(void); // 静态成员函数
};

int person::nums = 1;

//static void person::print(void) 错误写法
void person::print(void) //正确写法
{
	cout << "print()." << endl;
}

int main(){
	person p1, p2;
	cout << p1.nums << " " << p2.nums << endl;

	p1.nums = 10;
	cout << p1.nums << " " << p2.nums << endl;
    
	person::print(); 
	system("PAUSE");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

• 静态成员变量和方法也可以根本不产生对象而用类本身来调用，语法是类名::静态成员变量。

int person::nums = 1;

int main(){
	cout << person::nums << endl;

	person::nums = 10;
	cout << person::nums << endl;

	system("PAUSE");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

• 静态成员函数在类外实现时只需在类内声明时加static，类外实体无须加static关键字，否则是错误的（因为在类外实体前面加static会按照static修饰全局函数类理解）

2） 静态成员和普通成员的互相调用规则

• 普通成员函数中可以调用静态成员变量和方法，调用方法有3种：

• 1.直接访问
• 2.this指针访问
• 3.类名::func()方式访问

class person
{
public:
	int age;	//普通成员变量
	static int nums;	//静态成员变量
	static void print(void);
	void func(void)
	{
		//print(); 方法1
		//this->print();方法2
		person::print();//方法3
	}
};
void person::print(void)
{
	cout<<"static function print()."<

class person
{
public:
	int age;	//普通成员变量
	static int nums;	//静态成员变量
	static void print(void);
};
void person::print(void)
{
	this->age=10; // 报错
}

1
2
3
4
5
6
7
8
9
10
11
12

#include 
#include 
#include 
#include 
using namespace std;

class Myclass {
	public:
		Myclass() {
			m = 10;
		};
		static int getn(Myclass a);// 静态成员函数
		static int	z;	//　公共静态数据成员
	private:
		int m;			// 非静态数据成员
		static	int	n;	//　静态数据成员
};

int	Myclass::n = 100;	// 静态数据成员初始化
int	Myclass::z = 50;	// 公共静态数据成员初始化

int Myclass::getn(Myclass a) {
//	cout << m << endl; //对x的引用是错误的
	cout << a.m << endl; // 通过类间接使用  非静态数据成员,正确的

	cout << n << endl; // 正确的
	cout << a.n << endl; // 正确的
	return n;		// 直接使用  静态数据成员
}

int main() {
	Myclass app1;
	cout << app1.getn(app1) << endl;	// 利用对象引用静态函数成员
	cout << Myclass::getn(app1) << endl;	// 利用类名引用静态函数成员

	cout << Myclass::z << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

typedef 内置类型/复合类型/class类型 new_name;
//new_name是该类型的别名
1
2

#include 
using namespace std;

class Student {
	public:
		Student(char *name, int age, float score);
		friend void show(Student *p); //将show声明为友元函数
	private:
		char *m_name;
		int m_age;
		float m_score;
};

// 构造函数：成员逐一初始化操作
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score) {}

// 非成员函数
void show(Student *p) {
    //调用了private 成员，原则上不能通过对象访问，友元函数可以访问。将第7行注释掉，观察编译器的报错信息。
	cout << p->m_name << "的年龄是：" << p->m_age << "，成绩是：" << p->m_score << endl; 
}

int main() {
	Student stu("小明", 15, 90.6);
	show(&stu);  //调用友元函数
	Student *pstu = new Student("李磊", 16, 80.5);
	show(pstu);  //调用友元函数
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void show(){
    cout<