C++--类与对象（三）

1. 构造函数（扩充）

（1）构造函数体赋值

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

class Date
{
public:
	Date(int year, int month, int day)
	{
		//赋初值
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

（2）初始化列表

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

class Date
{
public:
	//初始化列表
	Date(int year, int month, int day)
		:_year(year) 
		,_month(month)
		,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

• 初始化只能初始化一次，而构造函数体内可以多次赋值。
• 类中包含引用成员变量、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:
	int _aobj; //自定义成员变量，没有默认构造函数
	int& _ref; //引用
	const int _n; //const
};

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

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)  //先初始化_a2(_a1为随机值)，再初始化_a1（a为1）
	{}
	void display()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	//初始化以此为顺序
	//成员变量声明的地方
	int _a2;
	int _a1;
};
void test()
{
	A aa(1);
	aa.display();
}
//输出1和随机值

（3）explicit关键字

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

class Date {
public:
	Date(int year)
		:_year(year)
	{}
	explicit Date(int year)
		:_year(year)
	{}
private:
	int _year;
	int _month;
	int _day;
};
void test()
{
	Date d1(2021);
	//d1 = 2021; //用explicit修饰构造函数，将会禁止单参构造函数的隐式转换
	//若无explicit修饰的构造函数，则可以用一个整型变量给日期类型对象赋值
	//实际编译器背后会用2021构造一个无名对象，最后用无名对象给d1对象进行赋值
}

2. static

• 声明为static的类成员称为静态成员，用static修饰的成员变量称为静态成员变量，用static修饰的成员函数称为静态成员函数。
• 静态的成员变量一定要在类外进行初始化。
  特性
• 静态成员为所有类对象共享，不属于某个具体的实例；
• 静态成员必须在类外定义，定义时不添加static关键字；
• 类静态成员可以用 类名::静态成员或者对象.静态成员来访问；
• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
• 静态成员和类的普通成员一样，也有三种访问级别：public、private、protected。也可以具有返回值。

class A {
public:
	A()
	{
		++_count;
	}
	A(const A&())
	{
		++_count;
	}
	//static成员函数不包含this指针
	static int getcount()
	{
		//fun();//静态成员函数不可以调用非静态成员函数，缺少this指针
		return _count;
	}
	//普通成员函数包含this指针
	void fun()
	{
		this->getcount();//非静态成员函数可以调用类的静态成员函数
		cout << "fun" << endl;
	}
//private:
	//static成员是所有对象共享
	//static成员变量，必须在类外初始化
	static int _count;
};
int A::_count = 0;
A funA(A a)
{
	return a;
}
void test()
{
	cout << A::_count << endl;
	cout << A::getcount() << endl;
	A a1;
	A a2;
	A a3 = funA(a1);
	cout << a1.getcount() << endl;
	cout << a2.getcount() << endl;
	cout << a3.getcount() << endl;
	cout << A::getcount() << endl;
	//static成员的访问形式
	//1.对象.static成员
	cout << a1._count << endl;
	//2.类型+::+static成员
	cout << A::_count << endl;
}

• 静态成员函数不可以调用非静态成员函数；
• 非静态成员函数可以调用类的静态成员函数。
  

3.友元

• 提供了一种突破封装的方式，但会增加耦合度，破坏了封装，不宜多用。

友元函数

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

class Date
{
	//友元函数的声明：此函数可以访问当前类的私有成员
	//此函数是一个普通函数，不是类的成员函数
	//友元的声明可以放在类的任何地方，不影响使用
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin,  Date& d);
public:
	Date(int year,int month,int day):_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 >> d._month >> d._day;
	return _cin;
}
void test()
{
	Date d(2021, 3, 8);
	//简写形式
	cout << d;
	//完整形式
	operator<<(cout, d);
	//连续输出
	cout << d << endl;
	operator<<(cout, d) << endl;

	Date d1(2021, 3, 8);
	//输入
	cin >> d1 >> d1 >> d1;
}

友元类

• 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有函数。
• 友元关系是单向的，不具有交换性；
• 友元关系不能传递

//time.h
class Time
{
	friend class Date;//声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 1, int minute = 1, int second = 1);
	void fun(Date& d);
private:
	int _hour;
	int _minute;
	int _second;
};
//test.h
#include"time.h"
class Date
{
	friend class Time;
public:
	Date(int year = 1900, int month = 1, int day = 1); 
	void SetTimeOfDate(int hour, int minute, int second);
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
//test.c
#include"test.h"
//友元关系是单向的
class Date;
	Time::Time(int hour, int minute, int second) :_hour(hour), _minute(minute), _second(second)
	{
	}
	void Time::fun(Date& d)
	{
		cout << d._year << d._month << d._day;
	}
class Time;
	Date::Date(int year, int month, int day) :_year(year), _month(month), _day(day) {}
	void Date::SetTimeOfDate(int hour, int minute, int second)
	{
		//直接访问时间类私有成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
void test()
{
	Date d;
	d.SetTimeOfDate(1, 1, 1);
	Time t;
	t.fun(d);
}

4. 内部类

• 如果一个类定义在另一个类的内部，就叫做内部类，这个内部类是个独立类，不属于外部类，也不能通过外部类的对象去调用内部类。
• 内部类是外部类的友元类，外部类对内部类没有任何优越的访问权限。
• 内部类定义在外部类的public、private、protected都是可以的；
• 内部类可以直接访问外部类的static、枚举成员，不需要外部类的对象/类名；
• sizeof（外部类）=外部类，与内部类无关。

class A
{
	//友元类声明
	friend class C;
	//内部类，作用类似于友元类
	//相比友元类，在内部类中可以直接访问外部类的static成员
	class B
	{
	public:
		void setA(A& a)
		{
			a._a = _b;
			_sa = 100;
		}
	private:
		int _b = 2;
	};
private:
	int _a = 1;
	static int _sa;
};
int A::_sa = 10;

class C {
public:
	void setA(A& a)
	{
		a._a = _c;
		a._sa = 20;
		A::_sa = 30; 
	}
private:
	int _c = 3;
};