C++类和对象总结(三)

文章目录

1、初始化列表
- 1.1、初始化列表概念
- 1.2、初始化列表特性
2、explicit关键字
3、static成员
- 3.1、static概念
- 3.2、static特性
4、友元
- 4.1、友元函数
- 4.2、友元类
5、内部类
- 5.1、内部类概念
- 5.2、内部类特性

1、初始化列表 1.1、初始化列表概念

初始化列表就是在构造函数后面以冒号为开始，用逗号做分隔成员变量进行初始化的方法，具体操作如下：

#define _CRT_SECURE_NO_WARNINGS   1
#include
class Date
{
public:
	Date(int year, int month, int day)
		:_year(year),
		_month(month),
		_day(day)
	{}
	void Display()
	{
		std::cout << _year << ":" << _month << ":" << _day << std::endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 6, 7);
	d1.Display();
	return 0;
}

1.2、初始化列表特性

（1）每个成员变量在初始化列表中只出现一次。
（2）引用成员变量，const成员变量，自定义类型的成员变量都必须放到初始化列表进行初始化。具体实例如下：

class Date
{
public:
	// 可以理解成，一个对象的单个成员变量在初始化列表是
	// 这个其实算是初始化列表初始化和函数体内初始化不同的地方，也是他的价值体现
	Date(int year = 0, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)

		, _n(10)           //const成员变量
		, _ref(year)       //引用成员变量
		, _a(1)           // 显示去调用
	{}

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

	// 他们必须在定义的时候初始化
	const int _n;
	int& _ref;
	A _a;
};

2、explicit关键字

explicit关键字用于防止隐式类型转换，具体可见如下代码：

#include
using namespace std;
class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	void Display()
	{
		std::cout << _year << std::endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2018);
	d1.Display();
	d1 = 2019;
	return 0;
}

上述代码中d1=2019这行代码，编译器首先会用2019这int类型数字，自动构造出一个Date类型的对象，然后对d1进行赋值，这就是隐式类型转换，如果我们不想让它隐式类型转换就可以通过在构造函数前面加入explicit关键字就可以阻止隐式类型转换，具有操作见如下代码：

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

3、static成员 3.1、static概念

static修饰的静态成员，必须在类外面初始化，具体可见如下代码：

class Test
{
public:
    static void print();
private:
	static int _n;  //静态成员的声明
	int a;
};
int Test::_n=10;
void Test::print()
{
    cout << _n << endl;
}

而我们在调用静态成员是，如果是公有成员可以直接通过类名或匿名对象直接访问，而私有成员还是只能通过公有成员函数访问，具体可见下面代码：

	Test().print;//匿名对象
	Test::print();//类型加作用域直接访问
	//通过上面公有成员函数我们可以访问到私有成员变量

3.2、static特性

（1）必须在类外定义。
（2）静态成员函数没有this指针，不能访问非静态成员。
（3）非静态成员函数可以访问静态成员，因为都在类内，不受访问限定符限制。

4、友元 4.1、友元函数

通过关键字friend将函数在类里面进行声名，而函数就可以访问类的任何成员变量，具体可见下面代码：

class Test
{
public:
	friend void print(const Test& d);
private:
	int _n;  //静态成员的声明
	int a;
};
void print(const Test& d)
{
	cout << d._n << endl;
}

友元函数的特性：
（1）友元函数可访问类的私有和保护成员。
（2）友元函数不能用const修饰。
（3）友元函数可以在类的任意地方声名。
（4）一个函数可以是多个类的友元函数。
（5）友元函数的调用域普通函数的调用和原理相同。

4.2、友元类

友元类的具体使用方法可见下方代码：

class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour, int minute, int second)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
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;
};
int main()
{
	Date d;
	d.SetTimeOfDate(2021,6,8);
	return 0;
}

上述代码中Date类是Time类的友元，Date类可以访问Time类的任意成员。友元类的总体特性为：
（1）友元类的是由成员函数都是另一个类的友元函数，都可以改完另一个类的任意成员。
（2）友元关系是单向的，就如你认为我是你的最好的朋友，但是我只觉得你是普通朋友。
（3）A是B的友元类，A可以访问B的所有成员，但是B不可以访问A的成员。
（4）友元关系不能传递，A是B的友元，虽然B是C的友元，但A不是C的友元。

5、内部类 5.1、内部类概念

内部类就是把类写在另一个类的体内，而内部类是一个独立的类，不属于外部类，不能用外部类的对象取调用内部类。具体写法见下方代码：

#define _CRT_SECURE_NO_WARNINGS   1
#include 
using namespace std;
class A
{
private:
	static int k;
	int h=5;
public:
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};
int A::k = 10;
int main()
{
	A::B b;
	b.foo(A());
	return 0;
}

5.2、内部类特性

（1）内部类写在外部类的public，protected，private都可以。
（2）内部类是外部类的友元类，可以访问外部类的任意成员，但是外部类不是内部类的友元。
（3）sizeof(外部类)=外部类大小，域内部类大小无关。
（4）友元关系不能传递，A是B的友元，虽然B是C的友元，但A不是C的友元。

C++类和对象总结(三)

C/C++/C#相关栏目本月热门文章