C++奇迹之旅：赋值运算符重载与隐式类型转换

文章目录

• 📝赋值运算符重载
• 🌠 运算符重载
• • 🌉特性
  • 🌠 赋值运算符重载
  • 🌠传值返回：
  • 🌠传引用赋值：
  • • 🌉两种返回选择
    • 🌉赋值运算符只能重载成类的成员函数不能重载成全局函数
    • 🚩总结

      ---

      📝赋值运算符重载

      🌠 运算符重载

      运算符重载是C++中的一个重要特性，他允许我们为自定义的类型定义自己的运算符行为。通过运算符重载，我们可以使用与内置数据类型相同的语法来操作自定义类型，从而提高代码的可读性和可维护性。

      还是我们熟悉的日期函数：

      class Date
      {
      public:
      	Date(int year, int month, int day)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	void Print()
      	{
      		cout 
      	Date d1(2024, 2, 17);
      	Date d2(2024, 6, 27);
      	
      	return 0;
      }
      
      public:
      	Date(int year, int month, int day)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	bool isSame(const Date& d)
      	{
      		return _year == d._year
      			&& _month == d._month
      			&& _day == d._day;
      	}
      private:
      	int _year;
      	int _month;
      	int _day;
      };
      int main()
      {
      	Date d1(2024, 2, 17);
      	Date d2(2024, 6, 27);
      	
      	if (d1.isSame(d2))
      	{
      		cout 
      		cout 
      public:
      	Date(int year, int month, int day)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	bool isSame(const Date& d)
      	{
      		return _year == d._year
      			&& _month == d._month
      			&& _day == d._day;
      	}
      //private:
      	int _year;
      	int _month;
      	int _day;
      };
      // 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
      // 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
      bool operator==(const Date& d1,const Date& d2)
      {
      	return d1._year == d2._year
      		&& d1._month == d2._month
      		&& d1._day == d2._day;
      }
      int main()
      {
      	Date d1(2024, 2, 17);
      	Date d2(2024, 6, 27);
      	
      	//d1.isSame(d2)
      	if (d1 == d2)
      	{
      		cout 
      		cout 
      	Date d1(2024, 2, 17);
      	Date d2(2024, 6, 27);
      	// 显式调用
      	operator==(d1, d2);
      	
      	// 直接写，装换调用，编译会转换成operator==(d1, d2);
      	d1 == d2;
      	return 0;
      }
      
      public:
          Date(int year = 1900, int month = 1, int day = 1)
          {
              _year = year;
              _month = month;
              _day = day;
          }
          int GetYear() { return _year; }
          int GetMonth() { return _month; }
          int GetDay() { return _day; }
          void SetYear(int year) { _year = year; }
          void SetMonth(int month) { _month = month; }
          void SetDay(int day) { _day = day; }
          bool operator==(const Date& d) const
          {
              return _year == d._year && _month == d._month && _day == d._day;
          }
      private:
          int _year;
          int _month;
          int _day;
      };
      
          friend bool operator==(const Date& d1, const Date& d2);
      public:
          Date(int year = 1900, int month = 1, int day = 1)
          {
              _year = year;
              _month = month;
              _day = day;
          }
      private:
          int _year;
          int _month;
          int _day;
      };
      bool operator==(const Date& d1, const Date& d2)
      {
          return d1._year == d2._year 
         		&& d1._month == d2._month 
          	&& d1._day == d2._day;
      }
      
      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& d) 
          {
              return _year == d._year 
              	&& _month == d._month 
              	&& _day == d._day;
          }
      private:
          int _year;
          int _month;
          int _day;
      };
      
      	Date d1(2024, 2, 17);
      	Date d2(2024, 6, 27);
      	
      	//显示调用
      	d1.operator==(d2);
      	//转换调用，等价与d1.operator==(d2);
      	d1 == d2;
      	
      	cout 
      public:
      	void func()
      	{
      		cout 
      	//函数指针
      	//void(*ptr)();
      	//成员函数要加&才能取到函数指针
      	ptrFunc fp = &OB::func;//定义函数指针fp指向func
      	OB temp;//定义OB类对象temp
      	(temp.*fp)();
      	return 0;
      }
      
      		_year = d._year;
      		_month = d._month;
      		_day = d._day;
      		return *this;
      	}
      
      public:
      	Date(int year = 1900, int month = 1, int day = 1)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	Date(const Date& d)
      	{
      		cout 
      		_year = d._year;
      		_month = d._month;
      		_day = d._day;
      		return *this;
      	}
      private:
      	int _year;
      	int _month;
      	int _day;
      };
      int main()
      {
      	Date d1(2024, 4, 14);
      	// 拷贝构造
      	// 一个已经存在的对象，拷贝给另一个要创建初始化的对象
      	Date d2(d1);
      	Date d3 = d1;
      	Date d4(2024, 5, 1);
      	// 赋值拷贝/赋值重载
      	// 一个已经存在的对象，拷贝赋值给另一个已经存在的对象
      	d1 = d4;
      	d1 = d2 = d4;
      	return 0;
      }
      
      		_year = d._year;
      		_month = d._month;
      		_day = d._day;
      		return *this;
      	}
      
      	if (this != &d)//使用的是地址判断
      	{
      		_year = d._year;
      		_month = d._month;
      		_day = d._day;
      	}
      	return *this;
      }
      
      	Date d(2024, 4, 14);
      	return d;
      }
      int main()
      {
      	const Date& ref = func();
      	return 0;
      }
      
      public:
      	Date(int year = 1900, int month = 1, int day = 1)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	Date(const Date& d)
      	{
      		cout 
      		if (this != &d)
      		{
      			_year = d._year;
      			_month = d._month;
      			_day = d._day;
      		}
      		return *this;
      	}
      	void Print()
      	{
      		cout 
      		cout 
      	Date d(2024, 4, 14);
      	return d;
      }
      int main()
      {
      	const Date ref = func();
      	return 0;
      }
      
      	Date d(2024, 4, 14);
      	return d;
      }
      int main()
      {
      	const Date& ref = func();
      	return 0;
      }
      
      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;
      }
      
      public:
      	Time()
      	{
      		_hour = 1;
      		_minute = 1;
      		_second = 1;
      	}
      	Time& operator=(const Time& t)
      	{
      		if (this != &t)
      		{
      			_hour = t._hour;
      			_minute = t._minute;
      			_second = t._second;
      		}
      		return *this;
      	}
      private:
      	int _hour;
      	int _minute;
      	int _second;
      };
      class Date
      {
      private:
      	// 基本类型(内置类型)
      	int _year = 1970;
      	int _month = 1;
      	int _day = 1;
      	// 自定义类型
      	Time _t;
      };
      int main()
      {
      	Date d1;
      	Date d2;
      	d1 = d2;
      	return 0;
      }
      
      public:
      	Stack(size_t capacity = 10)
      	{
      		_array = (DataType*)malloc(capacity * sizeof(DataType));
      		if (nullptr == _array)
      		{
      			perror("malloc申请空间失败");
      			return;
      		}
      		_size = 0;
      		_capacity = capacity;
      	}
      	void Push(const DataType& data)
      	{
      		// CheckCapacity();
      		_array[_size] = data;
      		_size++;
      	}
      	~Stack()
      	{
      		if (_array)
      		{
      			free(_array);
      			_array = nullptr;
      			_capacity = 0;
      			_size = 0;
      		}
      	}
      private:
      	DataType* _array;
      	size_t _size;
      	size_t _capacity;
      };
      int main()
      {
      	Stack s1;
      	s1.Push(1);
      	s1.Push(2);
      	s1.Push(3);
      	s1.Push(4);
      	Stack s2;
      	s2 = s1;
      	return 0;
      }