C++第十六天 类

/*
类：
	1.在类内部定义的函数默认为inline，即内联函数。
	2.在定义类函数时，加上const成员，表明不能改变其所操作的对象的数据成员，也就是只读，不能修改成员变量。const必须同时出现在声明和定义中。
	3.在类定义中，结束类定义需要加分号(;)
	4.C++类定义中，C++类定义的风格：成员函数声明定义放在成员变量的前面。
	5.C++支持在类定义外部定义成员函数，但是必须在类定义中声明了在类定义外部定义的函数。
	6.为什么类的定义以分号结束：因为类定义之后可以接一个对象定义列表，所以定义必须以分号结束，例如：
		class Test{};
		class Test{} test1,test2;

类蕴涵的基本思想是数据抽象和封装：
	数据抽象是一种依赖于接口和实现分离的编程技术。
	封装是一项将低层次的元素组合起来形成新的、高层次实体的技术。
	数据抽象和封装的优点：
		1.避免类内部出现无意的、可能破坏对象状态的用户级错误。
		2.随时间推移可以根据需求改变或缺陷报告来完善类实现，而无需改变用户级代码。

C++的访问标号，也即访问控制修饰符，包括public、private、protected等

	使用类型别名来简化类：
		例如：
			class Screen{
				public:
					typedef std::string::size_type index;
				private:
					index cursor;
					index height,width;
			};


  类的声明与类定义：
	可以声明一个类而不定义它，例如；
		class Screen;
		这个声明，有时称为向前声明，在程序中引用了类类型的Screen。
		在声明之后、在定义之前，类Screen是一个不完全类型。
		（注：不完全类型只能以有限方式使用。不能定义该类型的对象，不完全类型只能用于定义指向该类型的指针及引用，或者用于声明使用该类型作为形参类型或返回类型的函数）
	

  何时使用this指针：
	当需要将一个对象作为整体引用而不是引用对象的一个成员时，最常见的情况是：该函数返回对调用该函数的对象的引用。
	#include<string>
	class Screen{
	public:
		typedef std::string::size_type index;
		//返回类型是Screen&，知名该成员函数返回对其自身类类型的对象的引用，即每个函数都返回调用自己的那个对象，例如：
		Screen& set(char c){
			//.....
			return *this;
		}
		Screen& move(index r,index c){
			//...
			return *this;
		} 
	private:
		index cursor;
		index height,width;
	};

  从const成员函数返回*this:
	在普通的非const成员函数汇总，this的类型是一个指向类类型的const指针，const指针表明可以改变this所指向的值，但不能改变this所保存的地址
	在const成员函数中，this的类型也是一个指向const类类型对象的const对象。既不能改变this所指向的对象，也不能改变this所保存的地址。
	(注：不能从const成员函数返回指向类对象的普通引用。const成员函数只能返回*this作为一个const引用。)
	const对象不能调用普通的成员函数，也就是说const对象只能使用const成员，非const对象可以使用任一成员，但非const版本是一个更好的匹配。


  mutable可变数据成员：
	可变数据成员永远都不能为const，甚至当它是const对象的成员时也是如此
	使用mutable声明的成员变量，任意的成员函数，包括const函数，都可以改变mutable声明的成员变量。

  使用类的成员：
	一些成员只能通过对象或指针分别使用成员访问操作符.或 -> 来访问。这些操作符左边的操作数分别是一个类对象或指向类对象的指针。
	一些直接通过类使用作用域操作符(::)来访问，如std::string。
	

  在类定义外定义类的成员函数：
	跟在类定义中定义成员函数是一样的，不同的就是要使用完全限定名，如：Screen& Screen::get(index r,index c) const{ //.... }
	如果返回类型使用由类定义的类型，则必须使用完全限定名，例如：
		//get_cursor()函数必须在类定义中声明
		inline Screen::index Screen::get_cursor() const{
			return cursor;
		}

  在全局作用域中声明了一个全局对象，如果该对象被屏蔽了，但是可以通过全局作用域确定操作符(::)类限定名字，仍然可以使用它，例如：
	//test全局定义的
	double test;
 
	void dummy_fcn(double height){
		cursor=width*::test;				
	}
 
  定义类的构造函数：
	构造函数名字必须与类名相同，构造函数可以重载，没有返回值。
	构造函数的初始化列表：
		初始化列表以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员后面跟一个放在圆括号中的初始化式。例如：
			Screen::Screen(const Screen::index cs):cursor(cs),height(0),width(0){}
	没有默认构造函数的类类型的成员，以及const或引用类型的成员，不管是那种类型，都必须在构造函数初始化列表中进行初始化。例如：
		class ConstRef{
		public:
	 
			ConstRef(int ii){
			i=ii;
			//给const对象赋值，编译出错
	 		ci=ii;
	 		ri=ii;
			}
	
			//可以初始化const对象或引用类型的对象，但不能对他们赋值。在开始执行构造函数的函数体之前，要完成初始化。初始化const或引用类型数据成员的唯一机会是在构造函数初始化列表中。
			//正确的是：
			ConstRef(int ii):i(ii),ci(ii),ri(ii){}
		private:
			int i;
			const int ci;
			int &ri;
		};
	构造函数的初始化的次序与初始化执行的次序无关。成员初始化的次序就是定义成员的次序。
	
	默认实参与高燥函数：为构造函数提供默认实参，例如；
		class Test{
			public:
				//使用默认实参
				Test(const std::string &names=""):name(names),age(0){}
				//默认的构造函数
				//Test():age(0){}
			private:
				std::string name;
				int age;
		};
		对于下面任一定义，将指向为其string形参接受默认实参的那个构造函数：
			Test test;
			Test test2("name");
		在test的情况下，使用默认实参，而test2提供了一个显示实参。

  默认构造函数：
	1.合成默认构造函数：使用与变量初始化相同的规则来初始化。
	2.如果类包含内置或符合类型的成员，则该类不应该一览于合成的默认构造函数。它应该定义自己的构造函数来初始化这些成员。
	3.如果定义了其他构造函数，则提供一个默认构造函数。通常，在默认构造函数中给成员提供的初始值应该指出该对象是"空"的。
	4.使用默认构造函数：
		//错误的使用方法,假设Test是一个拥有默认构造函数的类。
		Test  test();          //test的定义将被编译器解释为一个函数的生命，该函数不接受参数，并返回一个Test类型的对象。
		
		//正确的使用方式应该是：
		Test test;     //去掉括号
		//或者这样也行
		Test test=Test();

  抑制由构造函数定义的函数转换：
	通过将构造函数声明为explicit，来防止在需要隐式转换的上下文中使用构造函数。
	explicit关键字只能用于类内部的构造函数声明上。在类的定义体外部所作的定义上不在重复它。
	为转换而显示地使用构造函数，显示使用构造函数只是中止了隐式地使用构造函数，任何构造函数都可以用来显示地创建临时对象。
  (注：除非有明显的理由想要定义隐式转换，否则，单形参构造函数应该为explicit。将构造函数设置为explicit可以避免错误，并且当转换有用时，用户可以显示地构造对象。)


  类成员的显示初始化：
	对于没有定义构造函数并且其全体数据成员均为public的类，可以曹勇与初始化数组元素相同的方式初始化其成员，例如：
	struct Data{
		int ival;
		char *ptr;
	};
	Data val1={0,0};
	Data val2={1024,"aaaaa"};
	//根据数据成员的声明次序来使用初始化式。
	这种形式的初始化从C继承而来，支持与C程序兼容。显示初始化类类型对象的成员有三个重大缺点：
		1.要求类的全体数据成员都是public
		2.将初始化每个对象的每个成员的负担放在程序员身上。这样的初始化时乏味且易于出错的，因为容易遗忘初始化式或提供不适当的初始化式。
		3.如果增加或删除一个成员，必须找到所有的初始化并正确更新。
	
	

  友元(friend)机制：允许一个类将对其非公有成员的访问权授予指定的函数或类。
	友元的生命以关键字friend开始，它只能出现在类定义的内部，友元声明可以出现在类中的任何地方。
	友元不是授予友元关系的那个类的成员，所以他们不受其声明出现部分的访问控制影响。
	通常，将友元声明成组地放在类定义的开始或结尾是个好逐一。
	例如：
		class Screen{
			//建立友元关系，赋予Window_Mgr类具有访问Screen私有成员变量的权限。
			friend class Window_Mgr;
		};
		class Window_Mgr{
			public:
				Window_Mgr& relocate(Screen::index r,Screen::index c, Screen& s){
					//访问Screen 类的私有成员变量
					s.height+=r;
					s.width+=c;
					return *this
				  
				}
		};
	必须先定义包含成员函数的类，才能将成员函数设为友元。一方面，不必预先声明类和非成员函数来将它们设为友元。例如：
		class X{
			friend class Y;
			friend void f(){}
		};
		class Z{
			Y *ymem;
			void g(){return ::f();}
		};

	友元(friend)与重载函数的关系：类必须将重载函数集中每一个希望设为友元的函数都声明为友元。

	C++类静态成员(与Java的静态对象非常相似)：
		1.使用static成员的优点：
			(1) static成员的名字是在类的作用域中，因此可以避免与其他类的成员或全局对象名字冲突。
			(2) 可以实施封装。
			(3) 可通过阅读程序容易看出static成员是与特定类关联的。
		2.使用类的static成员(和java的static成员调用非常相似)：
			通过作用域操作符(::) (Java用的是点(.)操作符)从类直接调用static成员，或者通过对象、引用或指向该类类型对象的指针间接调用。
		3.static成员函数
			static函数没有this指针：static成员是类的组成部分担不是任何对象的组成部分，所以static成员函数没有this指针。
			因为static成员不是任何对象的组成部分，所以static成员函数不能被声明为const。
	static数据成员：
		static数据成员必须在类定义体的外部定义，static成员不是通过类构造函数进行初始化，而是应该在定义时进行初始化。
		保证对象正好定义一次的最好办法，就是将static数据成员的定义放在包含类的非内联成员函数定义文件中。
		在类定义体外部引用类的static成员时，必须指定成员是在哪个类中定义的。然而，static关键字只能用于类定义体内部的声明中，定义不能标为static。
		特殊的const static成员：
			const static数据成员在类的定义体中初始化时，该数据成员仍必须在类的定义体之外进行定义，由于已经在类定义内部指定初始值，所以外部定义成员不必再指定初始值。

*/
#include<iostream>
#include<string>
using namespace std;
class ConstRef{
public:
	/*
	ConstRef(int ii){
		i=ii;
		//给const对象赋值，编译出错
	 	ci=ii;
	 	ri=ii;
	}
	*/
	//可以初始化const对象或引用类型的对象，但不能对他们赋值。在开始执行构造函数的函数体之前，要完成初始化。初始化const或引用类型数据成员的唯一机会是在构造函数初始化列表中。
	//正确的是：
	ConstRef(int ii):i(ii),ci(ii),ri(ii){}
private:
	int i;
	const int ci;
	int &ri;
	
};


struct X{
	//如果一个成员是根据其他成员而初始化，则成员初始化的次序是至关重要的。
	//成员被初始化的次序就是定义成员的次序。
	//所以这个高燥函数的初始化应该是先初始化rem，然后才是base
	//但是由于先初始化rem时，需要调用base的值，而此时base尚未初始化，则应该提示警告或者错误。
	//VC++可一个通过编译，并没有警告提示，而且还能正常运行，这是为什么呢？
	X(int i,int j):base(i),rem(base % j){}
	int rem,base;	
};


 
class Screen{
public: 
	//友元
	//赋予Window_Mgr整个类访问私有成员的权限
	friend class Window_Mgr;
	//赋予Window_Mgr的成员函数访问私有成员的权限,在赋予函数访问权限时，该类必须已经被定义,
	//friend Window_Mgr& Window_Mgr::relocate(Screen::index,Screen::index, Screen&);

	typedef std::string::size_type index;
	//返回类型是Screen&，知名该成员函数返回对其自身类类型的对象的引用，即每个函数都返回调用自己的那个对象，例如：
	Screen& set(char c){
		//.....
		return *this;
	}
	Screen& move(index r,index c){
		index row=r*width;
		cursor=row+c;
		return *this;
	}
	//基于const的重载。
	Screen& display(std::ostream &os){
		//...
		return *this;
	}
	const Screen& display(std::ostream &os) const {
		//..
		return *this;
	}

private:
	index cursor;
	index height,width;
};
//友元关系

class Window_Mgr{
public:
	Window_Mgr& relocate(Screen::index r,Screen::index c, Screen& s){
		//访问Screen 类的私有成员变量
		s.height+=r;
		s.width+=c;
		return *this;		
	}
};



/*
//声明一个类Y
class Y;
class X{
	//指向类型Y的指针
	Y *y;
};

class Y{
	//指向X类型的指针。
	X *x;
};
*/


class Test{
public:
	//使用默认实参
	Test(const std::string &names="asdf"):name(names),age(0){}
	//默认的构造函数
	//Test():age(0){} 
	std::string name;
	int age;
};
int main(){ 
	Test t;
	Test t2("liangguojun");
	cout<<t.name<<endl;
	cout<<t2.name<<endl;
	return 0;
}