C++类和对象（下）

#include<iostream>
using namespace std;
#include<stdlib.h>

//初始化成员列表
//初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，
//每个"成员变量"后面跟一个放在括 号中的初始值或表达式

//在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值

//虽然构造函数调用之后，对象中已经有了一个初始值，
//但是不能将其称作为类对象成员的初始化，
//构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。
//因为初始化只能初始化一次，而构造函数体内可以多次赋值

#if 0
class Date
{
public:
	Date(int year, int mouth, int day)
		:_year(year)
		,_mouth(mouth)
		,_day(day)  //初始化成员列表
	{}

private:
	int _year;
	int _mouth;
	int _day;
};

int main()
{
	Date d(2019,4,23);

	return 0;
}
#endif

//1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次) 
//2. 类中包含以下成员，必须放在初始化列表位置进行初始化： 
//		引用成员变量 
//		const成员变量 
//		类类型成员(该类没有默认构造函数)

#if 0
class A
{
public:
	A(int a)
		:_a(a)
	{}

private:
	int _a;
};

class B
{
public:
	B(A a, int ref)
		:_aobj(a)
		,_ref(ref)
		,_n(10)
	{}

private:
	A _aobj;       //没有默认构造函数的类成员变量
	int& _ref;     //引用变量
	const int _n;  //const 修饰的从成员变量
};

int main()
{
	B b();

	return 0;
}
#endif

#if 0
//尽量使用初始化列表初始化，因为不管你是否使用初始化列表，
//对于自定义类型成员变量，一定会先使 用初始化列表初始化
class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()初始化列表" << endl;
	}
	
private:
	int _hour;
};

class Date
{
public:
	Date(int day)
	{
		cout << "Date()" << endl;
	}

private:
	int _day;
	Time _t;
};

//成员变量在类中声明次序就是其在初始化列表中的初始化顺序，
//与其在初始化列表中的先后次序无关
class Array
{
public:
	Array(int size)
		:_size(size)
		,_array((int*) malloc(sizeof(int) * _size))
	{
		cout << "Array()" << endl;
	}

private:
	int* _array;
	int _size;
};

int main()
{
	Array arr(5);

	return 0;
}
#endif

#if 0
//explicit关键字   单个参数的构造函数
//构造函数不仅可以构造与初始化对象，
//对于单个参数的构造函数，还具有类型转换的作用

class Date
{
public:
	//Date(int year)
	//	:_year(year)
	//{}

	explicit Date(int year)
		:_year(year)
	{}

private:
	int _year;
};


int main()
{
	Date d1(2018); 

	//用一个整形变量给日期类型的对象赋值
	//实际编译器背后会用2019构造一个匿名对象，最好用匿名对象给d1对象进行赋值

	//d1 = 2019;  //构造函数前加上explicit 关键字后就报错，不允许不同类型赋值

	return 0;
}
#endif

#if 0
//static成员
//声明为static的类成员称为类的静态成员，
//用static修饰的成员变量，称之为静态成员变量；
//用static修饰的 成员函数，称之为静态成员函数。
//静态的成员变量一定要在类外进行初始化

//实现一个类，计算中程序中创建出了多少个类对象
class A
{
public:
	A()
	{
		++_count;
	}

	A(const A& a)
	{
		++_count;
	}

	void Display()
	{
		cout << "Display()" << endl;
		GetACount();  //非静态成员函数可以调用静态成员函数
	}



	static int GetACount()
	{
		return _count;
		//Display();  //静态成员函数不能调用非静态成员函数
	}

private:
	static int _count;
};

//静态的成员变量一定要在类外进行初始化
int A::_count = 0;

int main()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;

	return 0;
}

//1. 静态成员为所有类对象所共享，不属于某个具体的实例
//2. 静态成员变量必须在类外定义，定义时不添加static关键字 
//3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问 
//4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员 
//5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，
//	 也可以具有返回值， const修饰符等参数

//静态成员函数不能调用非静态成员函数 (因为静态成员函数没有隐藏的 this 指针)
//非静态成员函数可以调用静态成员函数
#endif

#if 0
//C++11的成员初始化新玩法

//C++11支持非静态成员变量在声明时，直接初始化

class B
{
public:
	B(int b = 0)
		:_b(b)
	{}


	int _b;
};

class A
{
public:
	void Print()
	{
		cout << _a << endl;
		cout << b._b << endl;
		cout << p << endl;

		cout << _n << endl;
	}

private:
	//非静态成员变量可以在声明时直接初始化
	//相当于给构造函数一个缺省参数
	int _a = 10;
	B b = 20;
	int* p = (int*)malloc(4);
	//
	static int _n;
};

//静态成员函数必须在类外初始化
int A::_n = 30;

int main()
{
	A a;
	a.Print();

	return 0;
}
#endif

//友元

//友元分为：友元函数和友元类
//友元提供了一种突破封装的方式，有时提供了便利。
//但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

//友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，
//不属于任何类，但需要在类的内部声明，
//声明时需要加friend关键字

#if 0
//输入输出运算符的重载
class Date
{
public:
	Date(int year, int mouth, int day)
		:_year(year)
		,_mouth(mouth)
		,_day(day)
	{}

	void operator<<(ostream& _cout) //无返回值时
	//ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << this->_mouth << "-" << _day << endl;

		//return _cout;
	}

	void operator>>(istream& _cin)  //无返回值时
	//istream& operator>>(istream& _cin)
	{
		_cin >> _year;
		_cin >> _mouth;
		_cin >> this->_day;

		//return _cin;
	}

private:
	int _year;
	int _mouth;
	int _day;
};

//这样的用法和平时的用法相反

//问题：现在我们尝试去重载operator << ，
//然后发现我们没办法将operator << 重载成成员函数。
//因为cout的 输出流对象和隐含的this指针在抢占第一个参数的位置。
//this指针默认是第一个参数也就是左操作数了。
//但是 实际使用中cout需要是第一个形参对象，才能正常使用。
//所以我们要将operator << 重载成全局函数。
//但是这 样的话，又会导致类外没办法访问成员，
//那么这里就需要友元来解决。operator >> 同理
int main()
{
	Date d1(2019, 4, 23);
	Date d2(2020, 4, 23);
	d1 << cout; //无返回值时不能连续输出
	d2 << cout;
	d2 >> cin;
	d2 << cout;

	return 0;
}
#endif

#if 0
//利用友元将输入输出重载函数定义成全局的

//友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，
//不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class Date
{
	//friend void operator<<(ostream& _cout, const Date& d); //无返回值的
	//friend void operator>>(istream& _cin, const Date& d); //无返回值的

	friend ostream& operator<<(ostream& _cout, const Date& d); //有返回值的

	//friend istream& operator>>(istream& _cin, const Date& d); //有返回值的, 第二个参数是const 的话会有问题
	friend istream& operator>>(istream& _cin, Date& d); //有返回值的

public:
	//Date(int year = 1900, int mouth =1, int day =1) //全缺省的（默认的构造函数）
	Date(int year, int mouth, int day)
		:_year(year)
		,_mouth(mouth)
		,_day(day)
	{}
	
private:
	int _year;
	int _mouth;
	int _day;
};

//void operator<<(ostream& _cout, const Date& d)  //无返回值时
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._mouth << "-" << d._day << endl;

	return _cout;
}

//void operator>>(istream& _cin, const Date& d)  //无返回值时
//istream& operator>>(istream& _cin, const Date& d)  //第二个参数为const 会有问题
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._mouth;
	_cin >> d._day;

	return _cin;
}


int main()
{
	
	//Date d1;  //调用默认的构造函数（编译器生成的，无参数的，参数全缺省的）

	//Date d1();  //此处调用会发生链接错误(不是缺省的构造函数，没有给参数，因此无法链接)

	Date d1(2018, 3, 5);
	Date d2(2019, 4, 23);

	cout << d1;
	cout << d2;

	cout << d1 << d2 << endl;  //无返回值时 这里不能连续输出
							     //有返回值 则可以连续输出
	

	//Date d5();  cin >> d5;  //报错

	Date d3(2018, 3, 5);
	Date d4(2018, 3, 5);
	
	cin >> d3 >>d4;
	cout << d3 << d4 << endl;
	
	return 0;
}

//1.友元函数可访问类的私有成员，但不是类的成员函数 
//2.友元函数不能用const修饰 
//3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制 
//4.一个函数可以是多个类的友元函数 
//5.友元函数的调用与普通函数的调用和原理相同

#endif

//友元类 

#if 0
//友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
//友元关系是单向的，不具有交换性：
//	比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time 
//	类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。 
//友元关系不能传递 如果B是A的友元，C是B的友元，则不能说明C时A的友元。

class Date; //前置声明

class Time
{
	friend class Date;  //声明日期类为Time类友元类，则在日期类中就可以直接访问Time中的私有成员

public:
	//改构造函数是默认的构造函数
	Time(int hour = 0, int minute = 1, int second=1)
		:_hour(hour)
		,_minute(minute)
		,_second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year = 1900, int mouth = 1, int day = 1)
		:_year(year)
		,_mouth(mouth)
		,_day(day)
	{}

	void Display()
	{
		cout << _year << "-" << _mouth << "-" << _day << "-";

		//Date类是Time类的友元类，因此Date类可以直接访问Time类的私有成员
		cout << _t._hour << "-" << _t._minute << "-" << _t._second << endl;
	}

private:
	int _year;
	int _mouth;
	int _day;
	Time _t;  //它会自动调用自己的默认构造函数初始化（因此得保证该类有默认构造函数）
};


int main()
{
	Date d;
	d.Display();

	return 0;
}

//友元一定程度上破坏了C++的封装，友元不宜多用，在恰当的地方使用友元。
#endif

//内部类

//概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。
//注意此时这个内部类是一个独立的 类，它不属于外部类，
//更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
//注意：内部类就是外部类的友元类。
//注意 友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。
//但是外部类不是内部类的友元

//1. 内部类可以定义在外部类的public、protected、private都是可以的。 
//2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象 / 类名。 
//3. sizeof(外部类) = 外部类，和内部类没有任何关系

#if 0
class A
{
public:
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << _k << endl; //内部类直接访问外部类的静态成员
			cout << a._a << endl; //内部类通过外部类的对象参数访问外部类私有成员
		}
	};

private:
	static int _k;
	int _a = 10;  //声明是初始化，C++11的特性
};

int A::_k = 20;

int main()
{
	A a;
	A::B b;
	b.foo(A());  //利用A()产生了一个A类的匿名对象
	b.foo(a); 

	return 0;
}
#endif

//构造函数，拷贝构造函数，赋值运算符函数的N种调用情况

class Date
{
public:
	Date()
	{
		cout << "Date(),构造函数" << endl;
	}

	Date(const Date& d)  //拷贝构造是构造的一种重载
	{
		cout << "Date(const Date& d), 拷贝构造函数" << endl;
	}

	Date& operator=(const  Date& d)
	{
		cout << "Date& operator=(const Date& d), 赋值运算符重载函数" << endl;
		return *this;
	}

	~Date()
	{
		cout << "~Date()，析构函数" << endl;
	}
};

//1. Date 对象做参数，传值 or 传引用
void fun1(Date& d)
//void fun1(Date d)
{}

//2. Date 对象做返回值，值返回 or 引用返回
Date& fun2()
//Date fun2()
{
	Date d;
	return d;
}

//3. Date 对象做临时返回值， 值返回 or 引用返回 （编译器优化问题）
const Date& fun3() //返回值前要加一个const，因为临时变量具有常属性
//Date fun3()
//Date& fun3()  //报错，
{
	return Date(); 
}


int main()
{
	//场景 1
#if 0
	Date d1;
	fun1(d1);  //传值时：调用了构造函数，拷贝构造函数，析构函数，析构函数。
			   // 传引用时：调用了构造函数，析构函数。
#endif

	//场景 2
#if 0
	Date d2 = fun2(); //传值时：调用了构造函数，拷贝构造函数，析构函数，析构函数。
					//（本该两次拷贝构造(fun2函数返回时一次，main中本该就是拷贝构造)，
					//编译器在此将两个紧连着的拷贝构造优化成一次）。

					  //传引用时：调用了构造函数，析构函数，拷贝构造函数，析构函数。
						//此处报了一个警告 返回了一个临时变量的地址（引用）。
#endif

	//场景 3
#if 1
	Date d3;
	d3 = fun3(); //传值时：调用了构造函数，构造函数，赋值运算符重载，析构函数，析构函数
					//main函数中构造一次，在fun3函数中retutn Date()这句代码先进行一次构造，
					//因为要做返回值所以在进行一次拷贝构造，但是是一条语句，编译器会将优化成一次构造。
					//然后在main函数中进行一次赋值运算符重载。

				//传引用时：调用了构造函数，构造函数，析构函数，赋值运算符重载函数，析构函数
				//在main函数中进行一次构造，在fun3函数中进行一次构造，因为返回的是引用，所以不需要拷贝构造，
				//然后在main函数中进行一次赋值运算符重载。
#endif
	return 0;
}