类和对象的下篇-CSDN博客

本文链接：https://blog.csdn.net/x_do_myself/article/details/137182683

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

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

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

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

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

一：构造函数的补充

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

三：友元

四：内部类

五：匿名对象

六：拷贝对象的一些优化

七：深度理解封装

WeChat_20240806081335

思维导图:

1：构造函数的补充

1.1初始化列表

当类的成员里面有const 修饰的时候，我们在定义构造函数的时候，若不对当前const 修饰的

变量进行初始化，是有问题的。

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

C++针对此问题引入了初始化列表：初始化列表是类的每一个成员进行定义的地方，并且只

调用初始化例表一次

对于自定义类型的成员，引用类型的成员并且对应的类没有默认构造函数的，也需要借助

初始化列表来进行完成

对于引用和自定义类型成员进行初始化：

类的成员声明和定义

1.2 注意：

1：每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)ex

2：类中包含一些特殊的成员（3种情况），必须放在初始化列表位置进行初始化

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

是类的成员进行初始化

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

跟一个放在括号中的初始值或表达式。

5：当定义的对象给出了初始化的值，在调用初始化列表的时候就会以给出的参数进行初始化，若

是没有给出参数，就看看是否有缺省值，有的话使用缺省值，若是2个都没有编译器就会使用随机

值

栗子见下：

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

进行初始化的

栗子见下：

关于初始化列表具体使用场景：与函数体混着用

所以建议：最后自己写初始胡列表，自己不写，编译器也会默认调用初始化列表，来进行成员的定义

1.3 explicit关键字

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

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

explicit

类型转换涉及的权限问题：

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

2.1概念

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

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

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

2.2应用

当类里面涉及到静态成员的时候，出于惯性思维，会在初始化列表里面对静态成员进行定义；但是

此时编译不过：

这是因为：静态成员变量并不是属于某一个指定对象所拥有的，而是属于所有对象使用的；对这

个问题的理解就像是成员函数的存放一样。

康康下面这个例子，就可以知道了

对静态成员定义：类外 + 变量名字前指明类域 + 没有static 修饰

类外如何使用访问静态成员？？？

类外访问静态成员有3种方式：

第一种：指明静态成员所在的类域（默认是全局找的）

第二种：借助对象访问

第三种：借助指针访问

静态成员受到访问限定符限制：

静态成员函数：

2.3 static 的特性

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

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

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

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

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

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

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

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

3：友元

3.1概念

友元其实是打破了对类的封装：当我们对类的成员属性设置为private或者protected的时候，在类

是不能直接进行访问的，这个时候借助友元函数或者友元类进行访问就

3.2友元类

以Time 这个类作为例子吧：有时我们是无法直接访问私有成员的，此时可以借助友元类；声明

Date 是Time 这个类的友元类；注意Time 类是不能访问Date 类的私有成员的

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

代码:

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的友元，

同样要看类中是否有声明。