前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >【C++】类和对象终篇

【C++】类和对象终篇

作者头像
zxctscl
发布2024-03-08 08:53:25
890
发布2024-03-08 08:53:25
举报
文章被收录于专栏:zxctscl个人专栏zxctscl个人专栏

个人主页zxctscl 文章封面来自:艺术家–贤海林 如有转载请先通知

1. 前言

在上一篇博客中提到了类和对象中的构造函数与static成员 【C++】类和对象之初始化列表与static成员,接下来一起看看类和对象中的友元。

2. 友元

友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。 友元分为:友元函数友元类

2.1 友元函数

问题:现在尝试去重载operator<<,然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员,此时就需要友元来解决。operator>>同理。

代码语言:javascript
复制
class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
	// 因为成员函数第一个参数一定是隐藏的this,所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

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

代码语言:javascript
复制
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;
}

说明:

  1. 友元函数可访问类的私有和保护成员,但不是类的成员函数
  2. 友元函数不能用const修饰
  3. 友元函数可以在类定义的任何地方声明,不受类访问限定符限制
  4. 一个函数可以是多个类的友元函数
  5. 友元函数的调用与普通函数的调用原理相同

2.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

  1. 友元关系是单向的,不具有交换性。 比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
  2. 友元关系不能传递 如果C是B的友元, B是A的友元,则不能说明C时A的友元。
  3. 友元关系不能继承,在继承位置再给大家详细介绍。

举个例子:声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量。

代码语言:javascript
复制
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)
	{
		_t._minute++;
	}

	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;
};

在Date里面要访问Time,Date是Time的友元,但是Time是不能访问Date的。但是Time是想要访问Date的,可以在Date里面声明Time,让Date和Time互为友元。

是类似像在Time中有含Date类的函数,但是在这里是不能用的,因为在还没有声明Date和Time互为友元,就在Time里面用了Date。 这里事先定义和声明分离。

一般情况下,类的友元关系是单向的,不需要互为友元。

3. 内部类

概念:**如果一个类定义在另一个类的内部,这个内部类就叫做内部类。**内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。 特性:

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

举个例子:像下面这样的代码中A有多大?

代码语言:javascript
复制
class A
{
public:
	class B
	{
	private:
		int _b1;
	};
private:
	int _a1;
	int _a2;
};



int main()
{
	cout << sizeof(A) << endl;

	return 0;
}

为什么大小是8? 从内存的角度类不占用空间,类只是一个声明。类被编译器编译之后,只会看到类的对象和类的函数,类是不占用空间的。 这样定义只会是B这个类受A类的类域的限制。所以它里面就是它自己的成员,没有B的成员。

如果在定义一个B类对象,定义变不了,不仅仅受到类域的限制,还受到访问界定符的限制。

改为这样就行。

如果定义为私有的。

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

但外部类不能访问内部类。

总之: 1、内部类受到类域的限制 2、内部类天生就是外部类的友元类

4. 匿名对象

代码语言:javascript
复制
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

class Solution {
public:
	int func(int n) {
		cout << "int func(int n)" << endl;

		return n;
	}
};

int main()
{
	// 有名对象
	A aa1;
	A aa2(10);
	

	// 匿名对象
	A();
	A(10);

	return 0;
}

这里就创建了4个对象:

C++中下面这样的被称为有名对象。

像下面这样的就叫做匿名对象。

匿名对象的特点是:生命周期只在当前一行。 与之前定义的对象不同,之前定义的对象生命周期是在当前作用域。

但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数。 即用即销毁

那么它有什么用呢? 举个例子:在OJ里面会有:

代码语言:javascript
复制
class Solution {
public:
	int func(int n) {
		cout << "int func(int n)" << endl;
		//...
		return n;
	}
};

要调用这个函数,一般得先取个名字,再调用:

可以考虑用匿名对象,那么就是这样。 像有点地方就传个参,定义一个匿名对象会比较好。 匿名对象就是为了让一些地方更方便。

5. 拷贝对象时的一些编译器优化

这个部分了解一下就可以。

在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,这个在一些场景下还是非常有用的。

编译器对于构造的一些优化: 一个是: 构造+拷贝 还有一个是:拷贝构造+拷贝构造 优化的结果就是合二为一。

来看看下面的代码:

代码语言:javascript
复制
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

void f1(A aa)
{}

void f2(const A& aa)
{}

int main()
{
	A aa1 = 2;  // 构造 + 拷贝构造 -》 直接构造
	const A& aa2 = 2;

	f1(aa1);

	f1(A(2));   // 构造 + 拷贝构造 -》 直接构造

	f2(aa1);

	return 0;
}

但是const A& aa2 = 2;就没有办法优化。 这里有类型转换,会产生临时变量,这里引用是临时变量。

------------------------------------------------------------------------ 这里要拷贝构造:

如果定义一个匿名对象来传: 构造一个再拷贝构造,直接优化为直接构造

如果不想让这里的拷贝构造发生,那么就传引用:

在这里插入图片描述
在这里插入图片描述

在之前老编译器上可能不会优化,所以并不是每个编译器都会优化,没有优化也是正常的。

代码语言:javascript
复制
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

void f1(A aa)
{}

void f2(const A& aa)
{}


A f3()
{
	A aa;
	return aa;	
}

int main()
{
	f3();	
	A ret = f3();
	return 0;
}

正常情况下f3()是一个构造一个拷贝构造。 这里是传值返回,不会把aa作为值返回,它会拷贝构造一个再返回。

在不优化时:

如果优化的话,是和f3()是一样的。

aa直接构造ret,那么它是怎么构造的呢? 在函数f3()结束之前,用aa直接构造ret。 在函数栈帧里面,在main函数,在f3()结束之前,用aa拷贝构造,不要临时对象了,直接用aa直接构造ret,然后函数再结束。

代码语言:javascript
复制
A f3()
{
	A aa;
	return aa;	
}
A f4()
{
	return A();
}

int main()
{
	A ret = f4();

	return 0;
}

这里是一个构造加一个拷贝构造加一个拷贝构造。这里合三为一。 在f4没有结束之前直接去构造ret。

而这个是两个构造加赋值,没有拷贝构造

6. 再次理解类和对象

现实生活中的实体计算机并不认识,计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体,用户必须通过某种面向对象的语言,对实体进行描述,然后通过编写程序,创建对象后计算机才可以认识。比如想要让计算机认识洗衣机,就需要:

  1. 用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识,洗衣机有什么属性,有那些功能,即对洗衣机进行抽象认知的一个过程
  2. 经过1之后,在人的头脑中已经对洗衣机有了一个清醒的认识,只不过此时计算机还不清楚,想要让计算机识别人想象中的洗衣机,就需要人通过某种面相对象的语言(比如:C++、Java、Python等)将洗衣机用类来进行描述,并输入到计算机中
  3. 经过2之后,在计算机中就有了一个洗衣机类,但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的,通过洗衣机类,可以实例化出一个个具体的洗衣机对象,此时计算机才能洗衣机是什么东西。
  4. 用户就可以借助计算机中洗衣机对象,来模拟现实中的洗衣机实体了。

在类和对象阶段,大家一定要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有那些属性,那些方法,描述完成后就形成了一种新的自定义类型,才用该自定义类型就可以实例化具体的对象

有问题请指出,大家一起进步!!!

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2024-03-08,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 1. 前言
  • 2. 友元
    • 2.1 友元函数
      • 2.2 友元类
      • 3. 内部类
      • 4. 匿名对象
      • 5. 拷贝对象时的一些编译器优化
      • 6. 再次理解类和对象
      领券
      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档