C++ 赋值运算重载，const成员，取地址及const取地址操作符重载

初阳7852023-11-02 17:58

C++ 赋值运算重载，const成员，取地址及const取地址操作符重载

  • [1. 赋值运算符重载](#1. 赋值运算符重载)
    • [1.1 运算符重载](#1.1 运算符重载)
    • [1.2 赋值运算符重载](#1.2 赋值运算符重载)
    • [1.3 前置++/--和后置++/--重载](#1.3 前置++/--和后置++/--重载)
  • [2. const成员](#2. const成员)
  • [3. 取地址及const取地址操作符重载](#3. 取地址及const取地址操作符重载)

所属专栏：C"嘎嘎" 系统学习❤️

🚀 >博主首页：初阳785❤️

🚀 >代码托管：chuyang785❤️

🚀 >感谢大家的支持，您的点赞和关注是对我最大的支持！！！❤️

🚀 >博主也会更加的努力，创作出更优质的博文！！❤️

🚀 >关注我，关注我，关注我，重要的事情说三遍！！！！！！！！❤️

1. 赋值运算符重载

1.1 运算符重载

  • 我们知道，两个内置类型之间是可以进行适合的运算的，比如两个整形是可以进行加减乘除的，也可以进行比较两个数的大小关系，以此相对应char，double类型的也是可以进行类似的操作的。但是这些都是仅仅有限于内置类型，如果变成了自定义类型呢？自定义类型也可以做到像自定义类型一样的操作吗?所以C++中为了解决这个方法，有了运算符重载的概念。

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其

返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

  • 注意：
    1.不能通过连接其他符号来创建新的操作符：比如operator@
    2.重载操作符必须有一个类类型参数
    3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
    4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
    4..* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出
    现

    class Date
    {
    public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    // bool operator==(Date* this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d2) //操作数opertor
    {
    return _year == d2._year
    && _month == d2._month
    && _day == d2._day;
    }
    private:
    int _year;
    int _month;
    int _day;
    };

    int main()
    {
    Date d1;
    Date d2;

      bool ret = d1 == d2; // ------> 本质是d1.operato==(d2);(operato==整体看作是一个函数名），但是做了优化之后就可以直接使用
  if (ret)
  {
  	cout << "d1 == d2" << endl;
  }
  else
  {
  	cout << "d1 != d2" << endl;
  }
  return 0;

    }

1.2 赋值运算符重载

1.赋值运算符重载格式

  • 参数类型：const T&，传递引用可以提高传参效率

  • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

  • 检测是否自己给自己赋值

  • 返回*this ：要复合连续赋值的含义

    class Date
    {
    public:
    Date(int year = 1, int month = 1, int day = 1)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    Date(const Date& d)
    {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    }
    Date& operator=(const Date& d)
    {
    if (this != &d)
    {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    }
    return *this;
    }
    private:
    int _year;
    int _month;
    int _day;
    };

    int main()
    {
    Date d1;
    Date d2(2023, 10, 28);
    d1 = d2;//本质上是------> d1.operator=(d2)

      return 0;

    }

  1. 赋值运算符只能重载成类的成员函数不能重载成全局函数

    class Date
    {
    public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    int _year;
    int _month;
    int _day;
    };
    // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
    Date& operator=(Date& left, const Date& right)
    {
    if (&left != &right)
    {
    left._year = right._year;
    left._month = right._month;
    left._day = right._day;
    }
    return left;
    }

    int main()
    {
    Date d1;
    Date d2(2023, 10, 28);
    d1 = d2;//本质上是------> d1.operator=(d2)

     return 0;

    }

我们在看一段代码：

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

int main()
{
	Date d1;
	Date d2(2023, 10, 28);
	d1 = d2;//这里没有进行重载，但是也是可以的

	return 0;
}
  • 原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现
    一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
    运算符重载只能是类的成员函数

3.用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注

意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符

重载完成赋值。这一点和前面的拷贝构造是一样的道理。

  • 那么有小伙伴就会问了，既然我们不写显示实现运算符重载编译器会帮我们实现重载的效果，那我们为什么还要自己再写一个呢？这个时候我们可以回顾一下我们之前的拷贝构造，在我们没有涉及到资源管理的时候，拷贝构造是正常的，但是一旦我们malloc一块空间的时候就出问题了，而这里也是一样的，起始赋值运算是一种特殊的拷贝构造。

1.3 前置++/--和后置++/--重载

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 前置++：返回+1之后的结果
	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
  • 上面是前置++ 的运算符重载操作。
    现在小伙伴们想一想后置++怎么办呢？
    首先就是他的重载格式是什么样的？
    返回类型是什么？
    因为我们的后置++ 的规则是先使用后++的，也就是说只有在一条语句结束后才会++。
    那么我们因该怎么实现呢？

在C++中为了区分前置和后置，C++中用占位参数来区分前置和后置，没有占位参数的是前置，又占位参数的是后置，并规定占位参数的类型是int。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
		Date operator++(int)
	{
		Date temp(*this);//先保存原先的值
		_day += 1;//再进行加加
		return temp;//最后返回保存的值
	}
private:
	int _year;
	int _month;
	int _day;
};

2. const成员

将const修饰的"成员函数"称之为const成员函数，const修饰类成员函数，实际修饰该成员函数

隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

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

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 11, 1);
	d1.Print();
	return 0;
}

我们看这串代码是没什么问题的，但是如果我用const修饰一下d1呢？

const Date d1(2023, 11, 1);
d1.Print();

这个时候还能通过吗？

这个时候就会报错啦，因为存在权限放大：

原本是:

  • 但是我们对d1用const修饰的时候，我们传过去的类型是const d1是不可修改的，但是我们函数接受的参数类型却不是const不可修改的类型，所以这里就有权限放大的问题。
    解决这个问题的办法也很简单，就是把我我们的形参也改成const修饰的参数：即const Date* const this
    但是问题是const加在那里，C++规定成员函数用const修饰加在形参列表之后：

我们在看一下这段代码：

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

	void Print() const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	const Date d1(2023, 11, 1);
	d1.Print();

	Date d2(2023, 11, 1);
	d2.Print();
	return 0;
}
  • 这里的d2会不会出错呢？
    分析一下，我们的成员函数是用const修饰的，而d2却没有使用const修饰的。
    但是这里是不会报错的，因为这里是属于权限的缩小。
    C++规定，权限允许权限的平移和缩小的。
    所以既然权限允许缩小的话，这里建议小伙伴们在写成员函数的时候，成员对象不可修改尽量用const修饰，这样跟更能保证代码的容错率，因为即使成员对象没有用const修饰，有权限缩小这特性还是可以通过的。

3. 取地址及const取地址操作符重载

  • 这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

    class Date
    {
    public:
    Date* operator&()
    {
    return this;
    }
    const Date* operator&()const
    {
    return this;
    }
    private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
    };

    int main()
    {
    Date d1;
    Date d2;

      cout << &d1 << endl;
  cout << &d2 << endl;
  return 0;

    }

相关推荐
奋斗的小花生11 分钟前
c++ 多态性
开发语言·c++
魔道不误砍柴功14 分钟前
Java 中如何巧妙应用 Function 让方法复用性更强
java·开发语言·python
闲晨17 分钟前
C++ 继承：代码传承的魔法棒，开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
老猿讲编程44 分钟前
一个例子来说明Ada语言的实时性支持
开发语言·ada
UestcXiye2 小时前
《TCP/IP网络编程》学习笔记 | Chapter 3：地址族与数据序列
c++·计算机网络·ip·tcp
Chrikk2 小时前
Go-性能调优实战案例
开发语言·后端·golang
幼儿园老大*2 小时前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
canyuemanyue2 小时前
go语言连续监控事件并回调处理
开发语言·后端·golang
杜杜的man2 小时前
【go从零单排】go语言中的指针
开发语言·后端·golang
霁月风3 小时前
设计模式——适配器模式
c++·适配器模式
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04Macbook pro M1 安装Ubuntu教程05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07文件或文件夹名称中有空格如何批量去除08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解