类和对象（下）

类和对象（下）

1.再谈构造函数

• 构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内
  可以多次赋值。
• 真正的初始化,初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

代码:

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化:

• 引用成员变量
• const成员变量
• 自定义类型成员

class A{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B{
public:
	B(int a, int ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj;     //没有默认的构造函数
	int& _ref;   //引用
	const int _n;//const

};

3.对于自定义类型成员变量，一定会先使用初始化列表初始化。
4.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

class A {
public: A(int a)
		:_a1(a)
		, _a2(_a1)
{}
		void Print() {
			cout << _a1 << " " << _a2 << endl;
		}
private:
	int _a2;
	int _a1;
};
int main() {
	A aa(1);
	aa.Print();
}

初始化后：

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。用explicit修饰构造函数，将会禁止单参构造函数的隐式转换

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

2.static成员

概念：

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

特性：

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

一道经典面试题：
实现一个类,计算中程序中创建出了多少个类对象。

1.如果给一个全局变量：可以，但如果全局变量在内部被改，就不安全了

int t_count = 0;
class Test
{
public:
	Test()
	{
		t_count++;
	}
	Test(Test& a)
	{
		t_count++;
	}
	~Test()
	{
		t_count--;
	}
private:
	int _a;
};
int main()
{
	Test t1, t2;
	return 0;
}

2.所以，我们可以在类中定义一个共享的成员变量，它是所有类对象共享的，不属于某个具体的实例，这就需要用到static了，先看代码了解下

class Test{
public:
	Test()
		:_a(0)
	{
		t_count++;
	}

	Test(Test& a){
		t_count++;
	}

	~Test(){
		t_count--;
	}

	static int GetCount(){
		return t_count;//静态成员函数
	}
private:
	int _a;
	static int t_count;//静态成员变量
};

int Test::t_count = 0;//静态成员变量在类外初始化

void testCount(){
	Test t1, t2;
	cout << Test::GetCount() << endl;
}//二次测试

int main(){
	Test::GetCount;
	Test t1, t2;
	cout << Test::GetCount() << endl;//2

	testCount();
	cout << Test::GetCount() << endl;//4
	return 0;
}

3.友元

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

问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。为什么？

因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是
实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。

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

class Date{
	friend ostream& operator<<(ostream& _cout,const Date& d);
	friend istream& operator>>(istream& _cin,Date& d);
public:
	Date(int year=2000,int month=1, int day=1)
		: _year(year)
		, _month(month)
		, _day(day)
	{ }
	
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout,const Date& d){
	_cout << d._year << "- "<<d._month <<"-"<< d._day;
	return _cout;
}

istream& operator>>(istream& _cin,Date& d){
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}

int main(){
	Date d;
	cin >> d;
	cout << d << endl;
	getchar();
	return 0;
}

注意：

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

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

4.内部类

概念：如果哦一个类定义在另一个类的内部，就成这个类为内部类
特性：
1.内部类可以定义在外部类的public，private,protected中都是可以的
2.注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名
3.sizeof=外部类，和内部类没有关系。

class A{
public:
	class B{
	public:
		void foo(const A& a){
			cout << k << endl;
			cout << a.h << endl;
		}

	};
private:
	static int k;
	int h;
};
int A::k = 1;
int main(){
	A::B b;
	b.foo(A());
	getchar();
	return 0;
}

5.再次理解封装

C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。
C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的
所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内
部的一些实现细节，外部用户不需要知道，知道了有些情况下也没用，反而增加了使用或者维护的难度，让
整个事情复杂化。

下面举个例子来让大家更好的理解封装性带来的好处：比如乘火车出行

我们来看下火车站：
售票系统：负责售票----用户凭票进入，对号入座
工作人员：售票、咨询、安检、保全、卫生等
火车：带用户到目的地

火车站中所有工作人员配合起来，才能让大家坐车有条不紊的进行，不需要知道火车的构造，票务系统是如
何操作的，只要能正常方便的应用即可。

可以看出面向对象其实是在模拟抽象映射现实世界