【C++】---类和对象（下）初始化列表、explicit、匿名对象、友元

一、再谈构造函数

注意：构造函数体内是赋值，不是初始化！！！

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

1.为什么要出现这个初始化列表的概念？

为什么要出现这个初始化列表的概念？（答案：为避免构造函数内部出现多次初始化成员变量！！！）
对于构造函数体内的对象只能说是赋值，不能说是初始化，因为：初始化的意义就是只能初始化一次，也就是第1次的时候。构造函数里体内的语句意思：是可以多次赋值的。一个是赋初值，一个是初始化，两者完全不同！

#include <iostream>
using namespace std;

class Date
{
private:
	int _year;
	int _month;
	int _day;
	//const int _n;
public:
	Date(int year=2024,int month=1,int day=1)
	{
		//_n = 1;
		_year = year;
		_month = month;
		_day = day;
		_year = 1; // 那这种情况也是错的第二次赋值并不是初始化！！！，但是编译不会报错！
		//我们对初始化的概念：是只在第1次的时候进行赋初值，那这里就算是重定义了吗
		//所以说这种构造函数内部的代码程序并不好，所以说我们要创建一个新的概念，也就是初始化列表。
	}
};

int main()
{
	return 0;
}

二、用初始化列表初始化对象

1.初始化列表的用法

1.语法：以一个冒号（:）开头，接着是以多个逗号（,）为间隔的数据成员列表，每个成员变量后面跟一个括号，里面是（将要初始化的值）或（将要初始化的表达式）

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

	}
};

2.初始化列表的特性

（1）初始化列表能只能初始化一次，多次初始化会报错：

class Date
{
public:
	//构造函数
	Date(int year = 2024, int month = 2, int day = 18)
		:_year(year) 
		,_month(month)
		,_day(day)
        ,_month(month) //初始化列表多次初始化
	{}
 
private:
	int _year;
	int _month;
	int _day;
};

编译器也允许构造函数赋初值和初始化列表初始化混用：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		:_year(year)  //两者混用
		,_month(month)
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

混用时初始化列表初始化和构造函数赋初值不冲突：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) //两者不冲突
		, _month(month)
	{
		_day = day;
        _year = 2023;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

但混用时初始化列表初始化还是要遵循只能初始化一次成员变量的原则：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) //初始化列表初始化
		, _month(month)
		, _year(2023)  //_year在初始化列表里被初始化了两次，不允许
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

（2）哪些成员变量特殊的必须要走初始化列表？

1. const的修饰成员变量
   “因为const修饰的成员变量必须在其定义时候只能初始化一次，而且不再被修改了。”

2. 传引用返回 的 成员变量
   

3. 没有默认构造函数 的 自定义类型成员
   A是一个自定义类型的类： 无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。
   
   

注意：所以说下这三种情况，在普通的构造函数体内解决不了问题只能走初始化列表：

（3）初始化列表的顺序是：成员变量的声明顺序！

答案选D（因为初始化顺序是按类中成员变量的声明顺序来的，所以先构造a2，因为a1没有初始化，所以a1是随机值，把随机值赋给了a2，所以a2是随机值。而对于a1来说：是a的值赋给了a1，a1=1）

三、explicit关键字

1.内置类型的隐式转换

1.单参数构造函数支持隐式类型转换

class C
{
public:
	C(int x = 0)
		:_x(x)
	{

	}
	void Print()
	{
		cout << _x << endl;
	}
private:
	int _x;
};

int main()
{
	C cc1(1);
	C cc2 = 2;// 也可以这样写，因为单参数的构造函数支持隐式类型转换！

	cc1.Print();
	cc2.Print();
}

2.如何避免 单参的构造函数初始化时发生隐式类型转换

如果不想让隐式类型转换发生，我们就会在单参数构造函前面加个explicit
比如：

#include<iostream>
using namespace std;
 
class A
{
public:
	A(int a)
		:_a(a)
	{}
 
private:
	int _a;
};
 
int main()
{
	A aa1(1);//构造aa1对象
	A aa2(aa1);//拷贝构造，程序没写拷贝构造，编译器会自动生成拷贝构造函数，对内置类型完成浅拷贝
 
	A aa3 = 'x';//先拿A构造一个临时对象temp，字符x作为参数传给这个临时对象temp，会发生隐式类型转换，再拿aa3(temp)去拷贝构造
 
	return 0;
}

a3作为A类的对象，构造时传参应该传int型，但却传了char型，由于发生隐式类型转换，因此编译也没毛病，但是它传参就是不伦不类。这时候可以给A的构造函数加上explicit声明不让该单参构造函数发生隐式类型转换，编译就会报错：

四、匿名对象

1.匿名对象的定义

没有名字的对象叫做匿名对象，A()和A(100)跟a1和a2相比少了个对象名，没有名字，a1和a2的生命周期在main函数内，A()和A（100）的生命周期只在当前行：

class A
{
public:
	A(int a = 0)
	{
		// 构造一次，打印一次
		cout << "A (int a)" << endl;
	}
	~A()
	{
		// 析构函数
		cout << " ~A()" << endl;
	}
};

int main()
{
	A a1(10);

	A();// 匿名函数 生命周期只在这一行！


	A a2;

	A(100);// 匿名函数 生命周期只在这一行！

	return 0;
}

2.匿名对象特点

（1）生命周期只在当前一行！！！

（2）匿名对象可以用来调用函数：

五、友元

1.为什么要使用友元

为了解决类外成员访问不了私有成员变量的问题：
如何能够访问到类的私有成员变量，1、突破类域 2、使用友元，友元提供了一种突破封装的方式。
友元分为友元函数和友元类

2.友元函数的概念及特点

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

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _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;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

2.特点：
（1）友元函数可访问类的私有和保护成员，但不是类的成员函数

（2）友元函数不能用const修饰（const修饰this指针指向的内容，友元函数作为全局函数没有this指针）

（3）友元函数可以在类定义的任何地方声明，不受类访问限定符限制，既可以声明为公有，也可以声明为私有

（4）一个函数可以是多个类的友元函数

（5）友元函数的调用与普通函数的调用和原理相同

3.友元类

1.友元类定义：
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。如下Date类是Time类的友元类，Date类要访问Time类，就要把Date类定义成Time类的友元：

class Date; // 前置声明
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
{
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()
{
	return 0;
}

（1）友元关系是单向的，不具有交换性。

在Time类中，声明Date 类是其友元类，可以在Date类中直接访问Time类的私有成员。但不能在Time中访问Date类中的私有成员。
（2）友元关系不能传递

A是B的友元，B是C的友元，但A不是C的友元。
一般情况下不需要互为友元

4.内部类：

1.定义：
一个类定义在另一个类的内部，这个内部类就叫做内部类。
内部类和外部类关系：

（1）内部类不属于外部类（两者是相互独立的），更不能通过外部类的对象调用内部类。外部类对内部类没有任何优越的访问权限。

（2）内部类天生是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类的所有成员，但外部类不是内部类的友元

其实A类和B类是两个独立的类，只不过这样写B类受A的类域限制：

内部类天生就是外部类的友元！

六、友元总结：

A无论是类还是全局函数，只要A被定义为B的友元，A就可以访问B的非公有成员。

---

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！