『C++初阶』第二章-对象与类（中）(2)

已于 2024-04-30 20:55:56 修改
阅读量1k 收藏 8
点赞数 23
分类专栏： C++初阶知识 文章标签： c++ 开发语言
于 2024-04-30 20:54:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54443558/article/details/138356619
版权

5. 赋值运算符重载

5.1 运算符重载

         C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

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

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

注意：

  • 不能通过连接其他符号来创建新的操作符： 比如 operator @
  • 重载操作符必须有一个类类型参数
  • 用于内置类型的运算符，其含义不能改变，例如： 内置的整型+， 不能改变其含义
  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
  •  .* 、: : 、 sizeof、 ?: 、 .  注意以上5 个运算符不能重载。这个经常在笔试选择题中出现。
// 全局的operato==
class Date
{
public:
	Date(int year=1900, 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;
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date()" << this << endl;
	}
//private:
	int _year;
	int _month;
	int _day;
};

// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆直接重载成成员函数。

bool operator==(const Date& d1, const Date& d2)
{
	return d1._day == d2._day
		&& d1._month == d2._month
		&& d1._year == d2._year;
}


Date Test(Date d)  // 创建形参调用一次
{
	Date temp(d);
	return temp;  //返回值调用一次
}
int main()
{
	Date d1(2024, 4, 21);
	Date d2 = d1;
	cout << (d1 == d2 )<< endl;

	return 0;

}

写成成员函数的方式：

class Date
{
public:
	Date(int year = 1900, 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;
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date()" << this << endl;
	}
	// bool operator== (Date* this, const Date& d2)
	// 这里需要注意的是，左操作数是this，指向调用函数的对象
	bool operator==(const Date& d)
	{
		return _day == d._day
			&& _month == d._month
			&& _year == d._year;
	}

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

5.2赋值运算符重载

        1. 赋值运算符重载格式

  •  参数类型： const T&, 传递引用可以提高传参效率
  • 返回值类型 T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回*this： 要复合连续赋值的含义
	Date& operator=(const Date& d)  //引用提高传参效率
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;  // 复合连续赋值
	}

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

// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& d1,const Date& d2)  
{
	if (&d1 != &d2)
	{
		d1._year = d2._year;
		d1._month = d2._month;
		d1._day = d2._day;
	}
	return d1; 
}

运行结果： 

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

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

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

class Time
{
public :
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}

	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	void Print()
	{
		cout << _year << " " << _month << " " << _day << " "
			<< _t._hour << ":" << _t._minute <<":" << _t._second << endl;
	}
	 Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	 Date()
	 {
		 _year = 1970;
		 _month = 1;
		 _day = 1;
		 _t._hour = 2;
		 _t._second = 2;
		 _t._minute = 2;
	 }
private:
	int _year = 1970;
	int _month = 1;
	int _day = 1;

	Time _t;

};
int main()
{
	Date d1(2024,1,1);
	Date d2;
	d1.Print();
	d2.Print();
	d1 = d2;  
	d1.Print();  

	return 0;
}

        运行结果：

                                 

   既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现赋值运算符重载吗？ 当然像日期类这样的类是没必要的。那么下面的类呢？ 验证一下试试

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (_array == nullptr)
		{
			perror("malloc error");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void StackBuy()
	{
		size_t n = _capacity * 2;
		DataType* New = (DataType*)realloc(_array,sizeof(DataType) * n);
		if (New == nullptr)
		{
			perror("realloc error");
			return;
		}
		_array = New;
		_capacity = n;
	}


	void push(const DataType& a)
	{
		if (_size >= _capacity)   this->StackBuy();
			_array[_size++] = a;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_size = 0;
			_capacity = 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);
	s1.push(5);

	Stack s2;
	s2 = s1;

	return 0;
}

注意： 如果类中未涉及到资源管理，赋值运算符是否实现都可以； 一旦涉及到资源管理则必须要实现。

 5.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;
	}
	//后置++:
	// 前置++ 和后置++ 都是一元运算符，为了让前置++与后置++能正确重载
	// c++ 规定： 后置++ 重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	//注意： 后置++ 是先使用后+1，因此需要返回+1之后的旧值，故需在实现时需要先将this保存一份，然后给this+1
	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
	Date operator++(int)
	{
		Date temp = *this;
		_day += 1;
		return temp;
	}
	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Date d;
	Date d1(2020, 1, 13);
	d = d1++;
	d.Print();
	d1.Print();
	d = ++d1;
	d.Print();
	d1.Print();

	return 0;
}

6. 日期类的实现

class Date
{
public:
	int GetMonthDay(int year, int month)
	{
		static int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		int Day = days[month];
		if (month == 2 && (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)))
			Day += 1;
		return Day;

	}
	Date(int year = 1900, 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()
	 {
		 _year = 0;
		 _month = 0;
		 _day = 0;
	 }
	 //赋值运算符重载
	 Date& operator=(const Date& d)
	 {
		 if(this!=&d)
		 {	
			 _year = d._year;
			 _month = d._month;
			 _day = d._day;
		 }
		 return *this;
	 }
	 //日期-天数
	 Date operator-(int day)
	 {
		 Date tmp = *this;
		 tmp._day -= day;
		 while (tmp._day <= 0)
		 {
			 if (tmp._month > 1)
			 {
				 tmp._month--;
			 }
			 else
			 {
				 tmp._year--;
				 tmp._month = 12;
			 }
			 tmp._day += GetMonthDay(tmp._year, tmp._month);
		 }
		 return tmp;
	 }
	 //日期-=天数
	 Date& operator-=(int day)
	 {
		 *this=*this - day;
		 return *this;
	 }
	//日期+天数
	Date operator +(int day)
	{
		Date tmp = *this;
		tmp._day += day;

		while (tmp._day > GetMonthDay(tmp._year, tmp._month))
		{
			tmp._day -= GetMonthDay(tmp._year, tmp._month);
			if (tmp._month == 12)
			{
				tmp._month = 1;
				tmp._year++;
			}
			else tmp._month++;
		}
		return tmp;
	}
	//日期+=天数
	Date& operator +=(int day)
	{
		*this = *this + day;
		return *this;
	}
	//++日期
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	//日期++
	Date operator++(int)
	{
		Date temp = *this;
		_day += 1;
		return temp;
	}
	//--日期
	Date& operator--()
	{
		_day -= 1;
		return *this;
	}
	//日期--
	Date& operator--(int)
	{
		Date tmp = *this;
		_day -= 1;

	}
	bool operator>(const Date& d)
	{
		if (_year > d._year) return true;
		else if (_year < d._year) return false;
		if (_month > d._month) return true;
		else if (_month < d._month) return false;
		if (_day > d._day) return true;
		else return false;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year && _month == d._month
			&& _day == d._day;
	}

	bool operator>=(const Date& d)
	{
		return *this > d || *this == d;
	}
	bool operator <(const Date& d)
	{
		if (_year < d._year) return true;
		else if (_year > d._year) return false;
		if (_month < d._month) return true;
		else if (_month > d._month) return false;
		if (_day < d._day) return true;
		else return false;
	}
	bool operator <=(const Date& d)
	{
		return *this < d || *this == d;
	}
	bool operator !=(const Date& d)
	{
		return !(*this == d);
	}
	int operator-(const Date& d)
	{
		int flag = 1;
		Date min = d;
		Date max = *this;
		if (min > max)
		{
			min = *this;
			max = d;
			flag = -1;
		}
		int a = 0;
		while (min+a != max)
		{
			a++;
		}
		return a * flag;
	}
	bool CheckDate()
	{
		if (_year < 1 && _year>9999) return false;
		if (_month < 1 && _month>12) return false;
		if (_day<1 && _day>GetMonthDay(_year, _month)) return false;
		return true;
	}
	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
	void  operator >>(istream& in)
	{
		in >> _year >> _month >> _day;
		if (!this->CheckDate())  cout << "输入错误日期";
	}
	void operator << (ostream& out)
	{
		cout << _year << "-" << _month << "-" << _day;
	}

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

int main()
{
	Date d1(2024, 4, 22);
	Date d2(2024, 5, 2);
	cout << d2 - d1 << endl;
	d2 - 10 << cout;
	cout << endl;
	d1 + 10 << cout;
	cout << endl;

	d1 << cout;
	cout << endl;
	d2 >> cin;
	d2 << cout; 

	//cout << d2 << endl;

	return 0;
}

7.const 成员

        将const 修饰的“成员函数” 称之为const 成员函数，const 修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

 具体代码如下：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//void print(Date* this)
	void print()
	{
		cout << "Print()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
	// void print(const Date* this)
	void print()const  
	{
		cout << "Print()const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
	

private:
	int _year;	   //年
	int _month;    // 月
	int _day;	   // 日
};
int main()
{
	Date d1(2024, 4, 22);
	d1.print();

	const Date d2(2024, 5, 2);
	d2.print();

	return 0;
}

注：  

  1. const 对象不能调用非const成员函数
  2. 非const对象可以调用const 成员函数
  3. const 成员函数内不能调用其他的非const成员函数
  4. 非const成员函数可以调用其他的const成员函数

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

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

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

        这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

Dklau-c
关注
  • 23
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值