类和对象的下篇

𝙉𝙞𝙘𝙚!!👏🏻‧✧̣̥̇‧✦👏🏻‧✧̣̥̇‧✦ 👏🏻‧✧̣̥̇:Solitary_walk

      ⸝⋆   ━━━┓
     - 个性标签 - ：来于“云”的“羽球人”。 Talk is cheap. Show me the code
┗━━━━━━━  ➴ ⷯ

本人座右铭 ：   欲达高峰,必忍其痛;欲戴王冠,必承其重。

👑💎💎👑💎💎👑 
💎💎💎自💎💎💎
💎💎💎信💎💎💎
👑💎💎　💎💎👑    希望在看完我的此篇博客后可以对你有帮助哟

👑👑💎💎💎👑👑   此外，希望各位大佬们在看完后，可以互相支持，蟹蟹！
👑👑👑💎👑👑👑 

 目录：

一：构造函数的补充

二：static修饰的变量以及函数

三：友元

四：内部类

五：匿名对象

六：拷贝对象的一些优化

七：深度理解封装

1：构造函数的补充

1.1初始化列表

当类的成员里面有const 修饰的时候，我们在定义构造函数的时候，是有问题的，若不对当前const 修饰的变量进行初始化

const 修饰的变量必须在进行声明的时候就进行初始化

为解决这一问题，引出了初始化列表这个概念

对于自定义类型的成员，引用类型的成员并且对应的改类没有默认构造函数的，也需要借助 初始化列表来进行完成

1.2 注意：

     1：每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
     2： 类中包含一些特殊的成员，必须放在初始化列表位置进行初始化

     3：不管是否显示在初始化列表中进行初始化，编译器都会默认在初始化列表中对所有是类的变量进行初始化

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

   5：当定义的对象给出了初始化的值，在调用初始化列表的时候就会以给出的参数进行初始化，若是没有给出参数，就看看是否有缺省值，有的话使用缺省值，若是2个都没有编译器就会使用随机值

栗子见下：

 6：关于在初始化列表里面对类的成员进行初始化的先后顺序问题：是以类的成员定义的先后顺序进行初始化的

栗子见下：

 1.3 explicit关键字

对于自定义类型与内内置类型之间的转换的理解：

当我们不想让自定义类型与内置类型之间进行转换 的时候可以使用关键字 explicit

2：static修饰的变量以及函数

2.1概念

类的成员在生命的时候使用关键字static进行修饰，称之为类的静态成员

static修饰的函数称之为静态成员函数

注意对静态成员变量一定要在类的外面进行初始化

 2.2应用

 2.3 static 的特性

1.静态成员为所有的类对象共享，不属于某一个对象，是放在静态区的

2.静态成员变量必须在类外进行定义，定义时不能加关键字 static

3. 类的静态成员的访问：类名 ：： 静态成员变量名字 或者对象.静态成员变量

4.静态成员函数是没有隐藏的this指针

5.静态成员也是类的成员，也受到访问限定符的限制

6. 静态成员函数可以调用静态成员变量

7.静态成员函数可以调用静态成员函数

8.非静态成员函数可以调用静态成员函数

3：友元

3.1概念

友元其实是打破了对类的封装：当我们对类的成员属性设置为private或者protected的时候，在类是不能直接进行访问的，这个时候借助友元函数或者友元类进OK

3.2友元类

友元类是单向的，不能双向互相访问

代码:

class Time
{
private:
	int _hour;
	int _min;
	int _sec;
public:
	friend class Date;//声明日期为时间的友元类（也就是Date里面可以访问Timel里面的私有成员）
	Time(int hour = 0,int min = 0,int sec = 0)
		:_hour(hour)
		,_min(min)
		,_sec(sec)
	{}
};
class Date
{
public:
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
		cout << _t._hour << ':' << _t._min<< ':' << _t._sec << endl;
	}
	Date(int year = 2024, int month = 4, int day = 2)//初始化列表
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date()" << endl;
	}
	void SetTimeOfDate(int hour, int min, int sec)
	{
		_t._hour = hour;
		_t._min = min;
		_t._sec = sec;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;//自定义类型
};
int main()
{
	Date d(2024, 4, 3);
	d.SetTimeOfDate(21, 31, 42);
	d.Print();
	return 0;
}

运行结果：

3.3友元函数

lass Date
{
public:
	//friend ostream& operator << (ostream& _cout, Date& d);//err
	friend ostream& operator<< (ostream& _cout,const  Date& d);
	friend istream& operator>> (istream& _cin,  Date& d);


	Date(int year, int month, int day)//初始化列表
		:_year(year)
		, _month(month)
		,_day(day)
	{}
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	/*ostream& operator << (ostream& _cout)
	{
		_cout << _year << '/' << _month << '/' << _day << endl;
		return _cout;
	}*/
private:
	int _year;
	int _month;
	int _day;

};
ostream& operator<< (ostream& _cout,const Date& d)
{
	_cout << d._year << '/' << d._month << '/' << d._day << endl;
	return _cout;
}
istream& operator>> (istream& _cin, Date& d)//注意第二个参数不能用const 修饰
{
	//一开始是不能对类外私有成员进行访问的，可以借助友元函数进行操作
	_cin >> d._year >>d._month>>d._day;
	return _cin;
}
int main()
{
	Date d1(2024, 4, 2);
	//cout << d1 << endl;//err 此时this 指针和_cout这个参数都进行抢占第一个参数的位置
	cin >> d1;
	cout << d1 << endl;
	return 0;
}

注意：

  1.友元函数不是类的成员，不属于任何类
  2.友元函数不属于该类的成员函数,它是定义在类外的普通函数，只是类中声明该函数可以直接访问类中的private或者protected成员  

  3.友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有声明。
  4.友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有声明。

4：内部类

内部类的特点：

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

     4. 内部类在空间上是与外部类相互独立的但是受到外部类的类域的限制

5：匿名对象

书写形式：类名 （）

6：拷贝对象的一些优化

栗子见下:

7：深度理解封装

结语：

以上就是今日的share，对于类和对象下期的理解还是比较好容易的（当然是建立在前期：对类和对象上，中期的理解），希望各位老铁们可以有所收获！