[C++]类与对象（下） -- 初始化列表 -- static成员 -- 友元 -- 内部类，一篇带你深度了解。

目录

1、再谈构造函数

1.1 构造函数体赋值

1.2 初始化列表

1.2.1 初始化列表的意义

1.3 explicit关键字

2、static成员

2.1 问题引入

2.2 特性

3、友元

3.1 友元函数

3.2 友元类

4、内部类

---

1、再谈构造函数

1.1 构造函数体赋值

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

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

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

我们构造函数尽量给全缺省，这样就算想要实例化一个无参的对象这一个函数就兼顾了。

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

1.2 初始化列表

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

我们继续以Date类来展开看：

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.1 初始化列表的意义

初始化列表是对象的成员变量定义的地方。

有些变量只能在定义的地方初始化：

a. const修饰的变量； b. 引用变量； c. 自定义类型（没有默认构造函数）。

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

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

private:
	// 成员变量的声明
	int _year;
	int _month;
	int _day;

	// 定义时必须初始化
	const int _x;
	int& _refi;
	A _a;
};

成员变量给缺省值就是给初始化列表的；初始化列表如果没有显示定义内置类型编译器会给默认定义并给随机值；给缺省并初始化给值使用初始化给的值。

对于定义时必须初始化的成员变量我们看看放在函数体里赋初值的情况：

这里就会出错，因此初始化列表对于这样的情况是很适用的。

注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
a. 引用成员变量
b. const成员变量
c. 自定义类型成员(且该类没有默认构造函数时)
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

初始化后在构造函数体里面还可以再给赋值。

1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

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

private:
	int _year;
};
int main()
{
	Date d1(2023);

	// 隐式类型转换
	Date d2 = 2023;// 2023调用构造函数生成临时对象，再用临时对象去拷贝构造d2	

	return 0;
}

2023是int类型，但是将它赋值给Date类型的d2没有报错，这就是因为2023发生了隐式类型转换。如果我们不想让发生隐士类型转换，给构造函数前加一个explicit修饰。

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

引申：

在C++11中，允许多参数的隐式类型转换。

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

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 隐式类型转换
	Date d = { 2023, 8, 7 };// 多参数隐式类型转换要用{}将多个参数括起来	
	const Date& d1 = { 2023, 1, 1 };// 转换时生成的临时变量具有常性，因此需要const修饰
    
	return 0;
}

多参数隐式类型转换要用 {} 将多个参数括起来。

2、static成员

2.1 问题引入

我们来统计一下A类创建了多少个，正在使用的多少个？

// 创建了多少个对象
int n = 0;
// 正在使用的有多少个对象
int m = 0;
class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}
};
A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << n << " " << m << endl;

	A();// 匿名对象，在本行创建并在本行销毁
	cout << n << " " << m << endl;

	func(a1);
	cout << n << " " << m << endl;

	return 0;
}

运行结果：

我们能看到全局变量是可以实现的，但是全局变量是不安全的（全局变量在全局都可以进行修改），并且是不利于封装的，因此我们不用这样的方法。

我们改一下方法来实现：

我们将计数器放在类里面，定义为私有的，但只是这样还是不满足，我们每创建一个对象就会有一个n与m，我们的目的是对象公用，因此我们使用static修饰，这样就解决了这两个问题。

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

//private:
	// 创建了多少个对象
	static int n;
	// 正在使用的有多少个对象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	cout << "sizeof(A):" << sizeof(A) << endl;

	A a1;
	A a2;
	cout << A::n << " " << A::m << endl;

	A();// 匿名对象，在本行创建并在本行销毁
	cout << a1.n << " " << a2.m << endl;

	func(a1);
	cout << a1.n << " " << a2.m << endl;

	return 0;
}

这里static修饰之后n与m是静态成员变量就不是某一个对象的了，而是所有对象的，因此不是存在于对象中，而是存在于静态区的（sizeof算出来为1，是一个空类）。

其次，类里只是成员变量的声明，静态成员变量必须在类外定义，定义时就不需要再加static。
如果静态成员我们定义成私有的，需要提供Get接口来访问n，m

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

	int GetN()
	{
		return n;
	}
	int GetM()
	{
		return m;
	}

private:
	// 创建了多少个对象
	static int n;
	// 正在使用的有多少个对象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << a1.GetN() << " " << a1.GetM() << endl;

	A();// 匿名对象，在本行创建并在本行销毁
	cout << a1.GetN() << " " << a1.GetM() << endl;

	func(a1);
	cout << a1.GetN() << " " << a1.GetM() << endl;


	return 0;
}

假如我们只创建了两个匿名对象，想要看n、m，没有对象是调用不了的，要是创建一个对象去调用，这就影响了n、m，因此我们将函数也改为静态的，这时只需要加上类域就可以访问了。

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

	// 静态成员函数的特点：没有this指针
	static int GetN()
	{
		return n;
	}
	static int GetM()
	{
		return m;
	}

private:
	// 静态成员变量属于所有A对象，属于整个类
	// 创建了多少个对象
	static int n;
	// 正在使用的有多少个对象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << A::GetN() << " " << A::GetM() << endl;

	A();// 匿名对象，在本行创建并在本行销毁
	cout << A::GetN() << " " << A::GetM() << endl;

	func(a1);
	cout << A::GetN() << " " << A::GetM() << endl;

	return 0;
}

注意：静态成员函数里不能访问非静态成员函数，因为没有this指针。一般static修饰的成员变量于static修饰的成员函数是配套使用的。

2.2 特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

3、友元

友元分为友元函数与友元类。

友元提供了一种突破封装的方式，有时提供了便利。但是友元破坏了封装，所以友元不宜多用。

3.1 友元函数

问题：上一篇中我们实现了Date类的所有需要重载的运算符，如果我们需要使用cout来打印自定义类型对象，我们需要对流插入符号进行重载。

打印的格式为cout << " " << endl;

那么重载流插入符号就不可以在类里面，在类里第一个参数是隐含的this指针，会与cout抢第一个参数位置，因此我们只能定义在类外面。
放在外面我们就无法访问类成员变量了，这里就该我们的友元上场了。

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

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

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

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

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

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

运行结果：

说明：

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

3.2 友元类

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

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

public:
    Time(int hour = 0, int minute = 0, int second = 0)
    : _hour(hour)
    , _minute(minute)
    , _second(second)
    {}

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

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

public:
    Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
    {}

    void SetTimeOfDate(int hour, int minute, int second)
    {
    // 直接访问时间类私有的成员变量
    _t._hour = hour;
    _t._minute = minute;
    _t._second = second;
    }

private:
    int _year;
    int _month;
    int _day;
	Time _t;

};
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

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

4、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。就是在一个类里面再定义一个类，内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

class A
{
public:
	class B
	{

	private:
		int _b;
	};
	int _a;
};
int main()
{
	cout << sizeof(A) << endl;
}

这里打印出来是4，因此我们可以知道，sizeof(外部类) = 外部类的大小，虽然里面嵌套了内部类，但内部类是不算在外部类大小里面的。

其次，内部类默认是外部类的友元类。

class A
{
public:
	class B
	{
	public:
		void func()
		{
			A a;
			a._a = 1;
			cout << a._a << endl;
		}

	private:
		int _b;
	};

private:
	int _a;
};
int main()
{
	A::B b;
	b.func();

	return 0;
}

我们在B类中定义了一个函数，函数里面访问A类的成员变量_a，并且给其赋值了，来看是否可以正常运行。

我们这里可以看到，在B类中可以访问到A类的成员变量，并且为其赋值了。这就可以看出来B类是A类的友元。

但是，A类不是B类的友元，友元是单向的。

特性：

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