第三章 类和对象（Ⅰ）

（1）类的抽象和封装

抽象

1.过程抽象

“功能为中心”


将整个系统的功能划分为若干个部分，每部分由若干过程（函数）完成。

如：

x add(a,b)				//功能：完成a+b
x sub(a,b)				//功能：完成a-b

2.数据抽象

“数据为中心”


忽略事物与当前问题域无关的、不重要的部分和具体细节，抽取同类事物与当前所研究问题相关联的、公有的本特征和行为，形成关于该事物的抽象数据类型

封装

封装关注对象的内部实现，用来实现完成数据抽象设计的目标：用户只能通过接口访问抽象数据类型的功能，只需向接口函数传递正确的参数，就能够使用该接口的功能，不必知道这些功能的实现细节以及内部数据的状态。

（2）struct 和 class

1. C++对 struct 的扩展

C++中的 struct 不仅可以包含数据，还可以包含函数。

2. 类(class)

在C++中，class 具有与 struct 完全相同的功能，用法一致。
唯一的区别是，在没有指定成员的访问权限时，struct 中的成员具有 public 权限，而 class 中的成员具有 private 权限。

虽然 struct 和 class 具有同样的功能，但在实际工作中，常用 class 设计具有成员函数的类，struct 则保留C语言中的用法。

（3）数据成员

数据成员可以是任何数据类型，如整型、浮点型、字符型、数组、指针、引用等

也可以是另一个类的对象或指向对象的指针

还可以是指向自身类的指针或引用，但不能是自身类的对象

可以是 const常量，但不能是 constexpr常量

可以用 decltype推断定义，但不能用auto推断定义

此外，数据成员不能被指定为寄存器( register)和外部( extern)存储类型

C++11之前的规范中不允许在声明(或定义)类时为数据成员赋初值，但C++11标准规定，可以为数据成员提供一个类内初始值，用于创建类对象时初始化数据成员。
例如：

class A
{
	private:
		int a=0;			//C++11之前错误,C+11之后正确
		int y=10;			//C++11之前错误,C++11之后正确
		intb[3]= {1,2,3};	//C+11之前错误,C++11之后正确
		const int C=a;		//C+11之前错误,C++11之后正确
	public:
		//....
};

（4）成员函数

1. 成员函数定义方式和内联函数

1. 类内定义成员函数
   在声明类时，直接在类的内部就给出成员函数的定义，以这种方式定义的成员函数若符合内联函数的条件，就会被处理为内联( inline)函数。

例如，一个日期类的定义如下：

class Date
{
		int day, month, year;
	public:
		void init(int d, int m, int y)
		{
			day=d;
			month=m;
			year=yi;
		}
		int getDay()
		{
			return day;
		}
};

在类Date中，成员函数init()和 getDay()直接在类的内部进行了定义，都是内联函数

2. 类外定义成员函数
   在声明类时,若只声明了成员函数的原型,就需要在类的外部定义该成员函数,方法如下：
   r_type class_name::f_Name(T1v pl，T2 p2，…)；
   
   
   其中，r_type是成员函数的返回类型，class_name是类名，::是域限定符，用于说明函数f_Name()是class name的成员函数，f_Name是成员函数名，T1、T2是参数类型。
   pl、 p2 是形式参数,在类声明的函数原型中并无任何意义，可以省略。 但在定义成员函数时，形参是不可省略的。

例如,Date 类的成员函数init和getDay()也可用下面的方法定义。

class Date
{
		int day,month,year;
	public:
		void init(int,int,int);		//省略了形式参数
		int getDay();
		inline int getMonth(); 
};
int Date::getDay()
{
	return day;
}
int Date::getMonth()
{
	return month;
}
inline void Date::init(int d,int m,int y)
{
	day=d;
	month=m;
	year=y;
}

init()和 getMonth()是内联函数,而getDay()不是。在C++中,若在类外成员函数的声明或定义前加上关键字inline,该成员函数也能够被定义为内联函数。


说明:

1. 若在类外方式定义成员函数，则类声明时，成员函数原型中的形参名可以省略，只声明各形参的类型；
2. 在类外定义成员函数时，成员函数的返回类型、函数名称、参数表必须与成员函数原型的声明完全相同，而且必须指出每个形参的名字；
3. 在类外定义成员函数时，必须在成员函数名前面加上类名，并且在类名与成员函数之间用“::”间隔

2. 常量成员函数

当一个函数被限定为常量成员函数时（在函数原型的后面加上 const ），它就不能修改数据成员的值

如下：

class x
{
		......
		T f(T1,T1,...) const;		//函数f()不能改变数据成员的值
		......
};

敲黑板！！

1. 只有类的成员函数才能定义为常量函数,普通函数不能定义为常量函数。
   下面的函数定义是错误的:

int f(int x)const 		//错误,普通函数不能被指定为 const
{
	int b=x*x;
	return b;
}

2. 常量参数与常量成员函数是有区别的,函数中的常量参数的值是不能改变的,与数据成员是否被改变无关。

3. 成员函数重载和默认参数值

跟普通函数重载差不多，各个重载函数之间必须要有不同的参数表，（！！只有返回值不同是不可以的！！）。

如果其中的某个参数指定了默认值，那么它右边的所有参数都得指定默认值！

（5）对象

<感觉没啥好写的…>

（6）构造函数设计

1. 构造函数和类内初始值

class X{
	......
	X(...);			//构造函数 		 
	T m=a;			//类内初始值	C++11新增 
	......
}; 

构造函数的特点如下:

1. 构造函数与类同名,并且没有返回类型;
2. 构造函数可以被重载;
3. 构造函数由系统自动调且, 丕允许在程序中显式调用;
4. 构造函数不能被声明为 const 函数。

要注意的问题！！（部分内容与上述特点重合）

1. 构造函数不能有任何返回类型，即使 void也不行。
2. 构造函数由系统自动调用，不能在程序中显式调用构造函数。
3. 定义对象数组或用 new 创建动态对象时，也要调用构造函数，但定义数组对象时必须有不需要参数的构造函数(包括无参数构造函数和所有参数有默认值的构造函数)。
4. 构造函数通常应定义为公有成员，因为在程序中定义对象时，要涉及构造函数的调用，尽管是由编译系统进行的隐式调用，但也是在类外进行的成员函数访问。

1. 默认初始函数

① 无参构造函数

如果一个类没有定义构造函数，在需要的时候编译器会自动为它生成一个默认的构造函数，称为合成的默认构造函数。
如：

class X{
	X(){}
	.....
}

注意！！

如果创建的是全局对象或静态对象，则所有数据成员初始化为0； 如果创建的是局部对象，则不会对数据成员进行初始化。

• 1
  只有在没有定义任何构造函数时，编译器才会创建默认构造函数； 一旦定义了任何形式的构造函数， 就不会再创建默认构造函数。那么在这种情况下，若要定义无初始化的类的对象，必须显式定义无参构造函数。

  在C++11中，也可以用下面的方式要求编译器创建默认构造函数。

clss X{
	X()=default;
	X(...){}
	.....
}

（小声说：不如自己写一个好了…）

• 2
  在某些情况下合成的默认构造函数会执行错误操作。
  比如，类具有数组或指针成员时，用默认构造函数执行对象初始化，很有可能产生“指针悬挂”的问题。

• 3
  在某些情况下，编译器无法为类创建默认构造函数。
  比如，类A的一个数据成员是用类B创建的，但类B有其他构造函数，却没有默认构造函数，在这种情况下，类A必须定义构造函数，并负责为对象成员提供构造函数初值。

②默认参数构造函数

与含有默认参数的普通函数没有多大区别
关键！！

class X{
	public:
		X(){...}			//显式定义无参构造函数
		X(int a=0,int b=0){...}	//带参构造函数
}

如果显式定义无参构造函数，如：X()，又定义了全部参数都有默认值的构造函数，如：X(int ,int )，那么在定义对象的时候就会产生二义性，导致编译错误。

③重载构造函数

与普通构造函数一样，必须有不同的函数原型（即参数个数、参数类型或参数次序不能完全相同）

④构造函数与初始化列表

除了在函数体中通过赋值语句为数据成员赋初值外，构造函数还可以通过成员初始化列表的方式对数据成员进行初始化。而且在某些情况下，必须采用初始化列表的方式才能够完成成员的初始化。

成员初始化列表类似于下面的形式:
构造函数名（参数表）:成员1（初始值），成员2（初始值），…{
…
}
介于构造函数参数表后面的“:”与函数体{…}之间的内容就是成员初始化列表。其含义是
将“（）”中的初始值赋给其前面的成员。

❗ ❗
①
初始化列表中的成员初始化次序与类中的声明次序相同，与初始列表的次序无关

如下面3个构造函数是完全相同的

Tdate: :Tdate(int m,int d, int y):month(m) ,day(d),year(y){ }
Tdate::Tdate(int m,int d, int y):year(y), month(m),day(d){ }
Tdate::Tdate(int m,int d,int y):day(d) ,year(y),month(m){ }

②
构造函数初始化列表的执行时间。如果数据成员有类内初始值，则执行次序为:

类内初始值 → 构造函数初始化列表 → 构造函数体

在一个类中，下列类成员必须采用类内初始值或构造函数初始化列表进行初始化：

• 常量成员
• 引用成员
• 类对象成员
• 派生类构造函数对基类构造函数的调用

注意，这些成员在C++11标准之前只能够采用构造函数初始化列表的方式初始化，用类内初始值进行初始化是从C++ 11标准才允许使用的。

⑤委托构造函数

委托构造函数只能够在初始化列表中调用它要委托的构造函数，而且初始化列表中不允许有其他成员初始化列表，但是委托构造函数体中可以有程序代码。

代码?上！！

#include <iostream>
using namespace std;
class Date
{
	public:
		Tdate();
		Tdate(int d);
		Tdate(int m, int d);
		Tdate(int m, int d, int y);
		//...										//省略了设置和读取数据成员值的接口函数
		void display()
		{
			cout << month <<"/"<< day <<"/"<< year << endl;
		}
	private:
		int year = 2008, month=8, day =8;			//11C++
};
Date:: Date(): Date(8, 1, 2008)						//11委托构造函数
{
	cout<<" delegating constructor Tdate()"<<endl;
}

Tdate::Tdate(int d): Tdate(8,d, 2008), month(2) {}	// L2 错误 不能再有其他成员的初始化列表

Tdate::Tdate(int m, int d): Tdate(m, d, 2008) {}	//L3委托构造函数

Tdate::Tdate(int m, int d, int y)					//L4普通构造函数
{
	month=m;
	day=d;
	year=y;
	display();
}

int main
{
	Date oneday;
	Date bday(10);
	Date bday =10;
	Date cday(2, 12);
	Date day (1, 2, 1998);
}