《C++初阶之路》类和对象（下）

一、本章重点

1. 初始化列表与函数体内初始化
2. explicit关键字
3. static成员
4. 友元
5. 内部类

二、初始化列表与函数体内初始化

我们都知道，C语言是这样的 

 问：C++中的类中成员变量真正定义的地方在哪吗？

答：初始化列表

初始化列表

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

号中的初始值或表达式。

这是一个日期类

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 2022, int month = 5, int day = 5)
		:_year(year),_month(month),_day(day)//初始化列表
	{
		;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

 初始化列表相当于

 函数体内初始化并不是真正的初始化，初始化只能有一次，函数体内初始化严格来说应该叫函数体内赋值。

函数体内赋值相当于；

初始化列表的优势：

有些时候不能这样写

 

 

以上这两种都必须是在定义的地方初始化，对于这样的成员变量就必须用初始化列表初始化。

还有一种情况也要使用初始化列表初始化，没有默认构造函数的成员对象。这种情况我们要自己去调用构造函数。

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 2022, int month = 5, int day = 5)
		:_year(year), _month(month)
	{
		_day = day;
	}
private:
	const int _year;
	int& _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

c++11中的一些知识

C++11允许给类的成员变量一个初始化的缺省值，这个缺省值是传给初始化列表的，即成员变量定义的地方。

#include<iostream>
using namespace std;
class Date
{
public:
	Date()
	{
		;
	}
private:
	int _year = 2022;
	int _month = 5;
	int _day = 5;
};
int main()
{
	Date d1;
	return 0;
}

相当于

#include<iostream>
using namespace std;
class Date
{
public:
	Date()
		:_year(2022),_month(5),_day(5)
	{
		;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

c++11给的是一个缺省值，如果你在初始化列表给了值给成员变量，那么它就不会使用缺省值。

 

建议尽量使用初始化列表对成员函数初始化。

三、explicit关键字

explicit关键字一般用来修饰成员函数，目的是防止单参数隐式类型转换的发生。

还是以日期类做例子

class Date
{
public:
	Date(int day)
		:_year(2022),_month(5)
	{
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

 这两种实例化对象有什么区别吗？

我们发现似乎没什么区别，但事实是d1是直接调用了构造函数的，而d2的实例化是用2去调用有参构造生成一个临时对象，再用临时对象去拷贝构造d2.

但现在的编译器通常不会生成这个临时对象，会有优化，直接用2去调用有参构造生成d2。

就如同下面这种情况：

 当a赋值给b时，会发生隐式类型转换，即用a去生成一个double类型的临时变量，再用这个临时变量去赋值给b。

为什么要生成这个临时变量？

考虑一下，难不成直接将a转化为double类型，那么a的值不就改变了吗？

我们都知道隐式类型转化并不会改变a本身的值，而是用临时的变量去赋值。

就像赋值操作符右边的值赋给左边的值，赋着赋着自己的值改变了？

int main()
{
	Date d1 = 2;
	return 0;
}

一个int类型的值赋给一个对象，这样看起来是比较奇怪的。

为了使代码的可读性更好，C++引入了explicit关键字，禁止发生单参数构造函数的隐式类型转化。

#include<iostream>
using namespace std;
class Date
{
public:
	explicit Date(int day)
	:_year(2022),_month(5)
	{
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1 = 2;
	return 0;
}

四、static成员

static既可修饰成员变量，也可修饰成员函数。

被修饰的成员会放在静态区。

静态成员变量必须再类内声明，类外初始化。

因为静态成员变量不属于任何一个对象上。

需要注意的是类内要使用static修饰，类外初始化时不能加static。

 访问静态成员变量的两种方式

第一种：通过对象访问

第二种：通过类名访问

 访问静态成员函数也是如此。

class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
	static int n;
};
int A::n = 1;

int main()
{
	A a;
	cout << a.n << endl;
	cout << A::n << endl;
	return 0;
}

 

class A
{
public:
	static void Print()
	{
		cout << "Print()" << endl;
	}
	static int n;
};
int A::n = 1;

int main()
{
	A a;
	a.Print();
	A::Print();
	return 0;
}

 同时要注意的是访问静态成员不能突破访问限定符的限制。

 

 

问1：静态成员函数能访问非静态成员变量吗？

答：不能，静态成员函数没有this指针，访问不了非静态成员变量，只能访问静态成员变量。

 

 

问2：静态成员函数能调用非静态的成员函数吗？

答：不能，同样的，静态成员函数没有this指针，调用不了非静态的成员函数。

 

 

五、友元

全局函数作友元：

class Date
{
public:
	friend ostream& operator<<(ostream& out, const Date& d1);
	Date(int year = 2022, int month = 5, int day = 5)
		:_year(year),_month(month),_day(day)
	{
		;
	}
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d1)
{
	out << d1._year << " " << d1._month << " " << d1._day << endl;
	return out;
}

int main()
{
	Date d1;
	cout << d1 << endl;
	return 0;
}

友元在类中声明的位置可以任意。

友元是破坏封装的一种行为，不到万不得已不建议使用。

友元类：

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
private:
	int b = 0;
};

class Date
{
public:
	Date(int year = 2022, int month = 5, int day = 5)
		:_year(year), _month(month), _day(day)
	{
		;
	}
	void Print()
	{
		cout << _year << " " << _month << " " << _day << " " << endl;
		cout << a.b << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	A a;
};


int main()
{
	Date d1;
	d1.Print();
	return 0;
}

 修改后：

 需要注意的是：

友元具有单向性，B是A的朋友，B可以访问A的私有成员，但A不能访问B的私有成员。

友元不具有传递性，B是A的朋友，A是C的朋友，B不上C的朋友，即B不能访问C的私有成员。

六、内部类

内部类，就是一个类中定义另外一个类。

class B
{
public:
	B(int a = 10, int b = 20)
		:_a(a),_b(b)
	{
		;
	}

	class A
	{
	public:
		A(int m = 5, int n = 50)
			:_m(m), _n(n)
		{
			;
		}
	private:
		int _m;
		int _n;
	};

private:
	int _a;
	int _b;
};

用A实例化一个对象

要注意类A定义在B中访问限定符的位置。

class B
{
public:
	B(int a = 10, int b = 20)
		:_a(a),_b(b)
	{
		;
	}


private:
	int _a;
	int _b;

	class A
	{
	public:
		A(int m = 5, int n = 50)
			:_m(m), _n(n)
		{
			;
		}
	private:
		int _m;
		int _n;
	};

};

 类A天生是类B的友元，可以访问类B的私有成员，可以将类A看做独立存在的，它不属于类B，计算类B的大小时，不用考虑类A，类B实例化的对象是无法访问类A的成员的。

其实可以这样看，类A和类B是分离定义的，类A是类B的友元，可以访问类B的私有成员。

特殊的是，类A在类B中定义，使用时需要考虑类域和访问限定符。