C++类和对象（3）（构造函数、static成员、内部类、友元函数等）

1 构造函数

接着C++类和对象（2）博客中介绍的构造函数继续说一下构造函数还可以怎么玩？
玩法一：构造函数体赋值

class Date
{
public:
	//全缺省 构造函数 函数体内赋值
	Date(int year = 2020, int month = 1, int day = 1)
	{
         _year = year;
         _month = month;
         _day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

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

玩法二：初始化列表
初始化列表是以一个冒号开始，接着后面在需要的情况下使用逗号分隔数据成员列表，每个“成员变量”后跟一个放在花括号{}中的初始值或者表达式。

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

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

1. 引用成员变量
2. const成员变量
3. 自定义类型成员（该类型没有默认构造函数）
   （默认构造函数：（不用传参就可以调用的 如：全缺省构造函数，无参数构造函数，编译器自动生成的构造函数））
   
   一些建议：

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

玩法三：混合初始化列表和函数体内赋值

class Date
{
public:
	//混着用
	Date(int year = 2020, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
	{
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

1.1 关键字explicit

首先看一下这段程序：

class A
{
public:
	//没加关键字，转换能发生， A a2 = 2;
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}
	
private:
	int _a;
};

int main()
{
	A a1(1);//调用构造函数

	//含义： 中间产生临时对象 A temp(2) 转换成 A a2(temp)
	//编译器优化成，直接调用构造函数
	A a2 = 2;//单参数的构造函数，支持类型转化
	
	return 0;
}

运行结果：

再来分析下面代码及图解：

class A
{
public:
	//加了关键字，转换不能发生， A a2 = 2;
	explicit A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

private:
	int _a;
};

int main()
{
	A a1(1);//调用构造函数

	//含义： 中间产生临时对象 A temp(2) 转换成 A a2(temp)
	//编译器优化成，直接调用构造函数
	A a2 = 2;//单参数的构造函数，支持类型转化

	return 0;
}

发现总结：用explicit修饰的构造函数，将禁止单参构造函数的隐式转换
。

2 static成员

用static修饰的成员变量叫做静态成员变量；
用static修饰的成员函数叫做静态成员函数；
注意：静态成员变量一定要在类外进行初始化 。
特性：

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

class A
{
public:
	//构造
	A()
	{
		++_n;
	}

	//拷贝构造
	A(const A& a)
	{
		++_n;
	}
	
	//静态成员函数
	static int GetN()
	{
		return _n;
	}

private:
	//静态成员变量
	//n是存在静态区，属于整个类，也属于类的所有对象
	static int _n;//只是声明，不在构造函数初始化，类外全局位置初始化
};

//静态成员变量的初始化
//不受访问限定符限定，
int A::_n = 0;
int main()
{
	cout << A().GetN() << endl;
	return 0;
}

测试截图：


注：
静态成员函数不可调用非静态成员函数。（静态成员函数无this指针）
非静态成员函数突破类的限制就可以调用类的静态成员函数。

3 C++11的成员初始化

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

对于上图中绿色框中三种情况，int _a 和 int * _p 属于声明，对应蓝色框中的两个数字，对应的是声明的成员变量缺省值，不是初始化，初始化在别处写。对应紫色框，是自定义类型，在紫色框处初始化。

4 友元

友元分为友元函数和友元类。
友元提供一种突破封装的方式，虽然会带来访问便利，但是也会增加耦合度，破坏封装。

4.1 友元函数

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

class Date
{
	// 友元函数的声明
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
	
public:
	//默认构造函数 ，全缺省
	Date(int year = 2020, int month = 5, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

// cout << d;
ostream& operator<<(ostream& out, const Date& d) 
{
	//友元函数使用
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;//返回值保证可以连续输出
}

// cin >> d
//输入的值需要修改，不要再加想out一样的const
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

int main()
{
	Date d1, d2(2022, 10, 29);
	cin >> d1 >> d2;
	cout << d1 << d2;
	return 0;
}

还可以这样玩，小点解释：还可以使用类内的成员函数返回值的方式返回成员变量的值。下面展示一下：

class Date
{
	// 友元函数的声明
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

public:
	//默认构造函数 ，全缺省
	Date(int year = 2020, int month = 5, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//传值返回，不能修改，保证封装有意义
	int GetYear() const
	{
		return _year;
	}
	int GetMonth() const
	{
		return _month;
	}

private:
	int _year;
	int _month;
	int _day;
};

// cout << d;
ostream& operator<<(ostream& out, const Date& d) 
{
	//使用类内GetYear();GetMonth()
	out << d.GetYear()<<" ";//类内函数必须是const的
	out << d.GetMonth();//类内函数必须是const的

	return out;//返回值保证可以连续输出
}

// cin >> d
//输入的值需要修改，不要再加想out一样的const
istream& operator>>(istream& in, Date& d)
{
	in >> d._year>>d._month;
	return in;
}

int main()
{
	Date d1;
	cin >> d1;
	cout << d1;

	return 0;
}

总结：

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

4.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员；

class Date; //前置声明
class Time
{
	// Date类是Time类的友元类
	friend class Date; 
public:
	Time(int hour=2020, int minute=2, int second=3)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}

private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 2020, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)

	{}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 访问Time类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

总结：

1. 友元类不能传递
2. 友元类不具有交换性

5 内部类

一个定义在另一个类的内部，这个在内部的类叫做内部类。
注意：
内部类，是一个独立的类，不属于外部类。
外部类对内部类没有访问权限。
特性：

1. 内部类是外部类的友元；
2. 内部类可以定义在外部类的任何位置；
3. 内部类可以直接访问外部类的static、枚举成员，不需要外部类的对象或类名；
4. sizeof测大小，和内部类没关系，即sizeof（外部类）= 外部类；

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

int A::k = 1;

int main()
{
	A aa;
	A::B b;//访问方式总结
	b.foo(A());
	b.foo(aa);

	return 0;
}