深入篇【C++】类与对象：运算符重载详解 -(下)+日期类的实现

已于 2023-05-10 12:10:05 修改
阅读量819 收藏 16
点赞数 15
分类专栏： C++(初阶学习) 文章标签： c++ java 开发语言
于 2023-05-09 21:07:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Extreme_wei/article/details/130577742
版权

深入篇【C++】类与对象：运算符重载详解-(下）+日期类的实现💯干货满满！


在这里插入图片描述

⏰一.运算符重载

内置类型(int /double…… )是可以之间进行运算符之间的比较的，因为编译器知道它们之间的比较规则，可以之间转化为指令。
那如果自定义类型能否之间进行运算符之间的比较呢？当然不能了，因为编译器是不知道这个自定义类型的规则是什么，不知道如何进行比较。
1.内置类型是可以之间比较的。
2.自定义类型是无法之间进行比较的。
那如何使自定义类型也能进行比较呢？这时C++给出了办法，让这个运算符重载成一个函数，当自定义类型进行比较时，其本质就是在调用重载函数。

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

比如我们想对下面这个自定义类型进行运算符的使用，该如何使用呢？


class Data
{
	
public:
	Data(int year = 1, int month = 1, int day = 1)//构造函数要写，拷贝构造函数不用写，赋值重载不用写
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	
	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
    Data d1(2023,5,1);
    Data d2(2023,10,15);
}

我们知道并不是所有的运算符都能重载的，主要是那些对类有意义的运算符才可以重载。

🕓①.<=运算符重载

两个日期进行比较大小，是有意义的，所以和<=运算符是可以重载的。而我在运算符重载详解 -(上)中已经将部分运算符介绍，接下来继续介绍运算符重载。在这里插入图片描述

那<=运算符重载该如何写呢？

是不是直接可以在 <运算符重载的基础上直接改动即可呀。

下面是<运算符重载函数

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

直接在原函数上将<改成<=即可：

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

不过这里有一个更好的方法喔！！！
那就是函数【复用】，这个在很多场景下都很有用的。
怎么复用呢？我们是不是已经将<运算符重载 和==运算符重载写完了？
那我们就可以直接复用这两个运算符重载来写其他的比较运算符
1.<= 是不是就是 小于或者等于呀，或者大于的逆命题。
2.>=是不是就是 大于或者等于呀或者就是小于的逆命题。
3.!=是不是就是 等于的逆命题呀。

bool Data::operator<=(const Data& d)//直接复用<运算符重载和==运算符重载
{
	return *this < d || *this == d;
}

🕒②.>=运算符重载

.>=运算符重载可以复用 >运算符和等于==运算符重载
或者是<运算符重载的逆命题：

bool Data::operator>=(const Data& d)
{
	return !(*this < d);//复用<运算符重载 ，<的逆命题就是>=
}

🕑③. !=运算符重载

= =的逆命题就是!=所以可以直接复用= =运算符重载

bool Data::operator!=(const Data& d)
{
	return !(*this == d);//直接复用==运算符重载的  -- 逆命题
}

总结：所以我们在写这些比较运算符，习惯先将<运算符重载和==运算符重载先写出来，然后其他比较运算符直接复用这两个运算符重载即可。

🕐④.+=运算符重载

我们知道日期加上一个日期是没有什么意义的，但是一个日期加上一个天数，这就有意义了，可以知道该天数后是什么日期。所以日期类是允许+=运算符重载的。
那+=运算符如何重载呢？

我们首先要知道如何进行日期的计算，当天数大于当前月的最大天数时，天数就要减去当前月份的最大天数，然后月份就要进一。
注意点：
1.当天数很大时，月份不断进一，但要注意月份不能超过12，当月份再进一应该是1，而不是13.
2.要注意每个月份的天数是不同的，要考虑闰年的2月和其他年的2月天数也是不同的。

所以我们首先手搓一个获得不同月份的天数的函数，要考虑闰年和不同年的2月不同。

int Data::GetMonDay(int year, int month)
{
    int monday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)&&month==2)
	{
		return 29;
	}
	else
	return monday[month];
}

有一个点提一下，这里可以改进。
这里我们要的是每个月的天数，但每次调这个函数我们都要进行一次闰年的判断，判断然后再看是不是2月，这样很麻烦，这里的if条件句的目的是为了获得2月的天数，如果不是2月那就不要再去判断闰年了，所以我们可以将判断是否是2月放在前面先判断就可以避免每次都要判断是否是闰年了。
然后还有我们要频繁的调用这个函数，也就是这个月份日期数组每次调用都会开辟，太浪费效率了，所以我们可以让它变成静态区的，开辟一次就可以啦。不用每次调用都开辟一次。所以改进后的代码如下：

int Data::GetMonDay(int year, int month)
{
	static int monday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	//频繁调用
	if (month == 2&&(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) )//先判断是否是2月，如果不是直接走开。
	{
		return 29;
	}
	else
	return monday[month];
}

接下来我们就要进行这个对+=运算符的重载了

//这里可以用引用返回喔，因为返回的是对象本身，对象本身并不在该重载函数里面，所以函数结束，对象还存在。
Data& Data::operator+=(int day)
{
	//第一步将天数全部加起来
	_day += day;
	while (_day > GetMonDay(_year, _month))//当天数大于当月最大天数时，就要进行循环
	{
		_day -= GetMonDay(_year, _month);//要减去当月的最大天数
		++_month;//然后月份++
		if (_month == 13)//要考虑月份不能超过12，当月份变成13时这是，正确的是1月，并且年也要加1
		{
			++_year;
			_month = 1;
		}
	}
	return *this;//最后将日期对象返回
}

🕦⑤.+运算符重载

+运算符和+=运算符的区别是什么呢？

int b=2;
b+=1;
b+1;

+=将变量本身改变了，而+并没有将变量改变。
所以同理，对于自定义类型，+=也将自定义变量本身发生改变，而+并不会改变自定义变量本身。

+运算符重载函数和+=运算符重载函数的区别就在于它们的返回值不同。
虽然最后结果相同，但是+运算符重载返回值是一个临时拷贝的对象，并不是真正改变的对象。
+=运算符重载函数的返回值是真正改变的对象。

//这里不可以使用引用返回，因为返回的是拷贝对象，函数结束，拷贝对象就销毁了
Data Data::operator+(int day)
{
	Data tmp(*this);//拷贝一份，让tmp返回，*this没有改变
	tmp._day += day;
	while (tmp._day > GetMonDay(tmp._year, tmp._month))
	{
		tmp._day -= GetMonDay(tmp._year, tmp._month);
		++tmp._month;
		if (tmp._month == 13)
		{
			++_year;
			tmp._month = 1;
		}
	}
	return tmp;
}

我们注意到，+运算符重载函数里是让拷贝对象去实现+=运算符函数的相关操作，最后返回是拷贝对象
，真正的对象并没有修改。
这里我们也可以使用函数复用，+运算符重载直接复用+=运算符重载函数。

Data Data::operator+(int day)  //+运算符重载 复用+=运算符重载
{
	Data tmp(*this);//拷贝一份，让tmp返回，*this没有改变
	tmp += day;//复用+=重载函数
这里其实就是tmp去调用+=运算符重载函数，tmp作为左参数。 
	return tmp;
}

其实+=运算符重载函数也可以直接复用+运算符重载

Data& Data::operator+=(int day)//用+=复用+
{
	*this=*this + day;
	//注意的是+是不修改本身的，所以对象变量+day还要再赋给对象变量
	这里的+就是+运算符重载函数，*this对象去调用这个对象
	return *this;
}

但是最好先实现+=运算符重载 再复用实现 +运算符重载，而不推荐用+=运算符重载来复用实现+运算符重载，为什么呢？

因为+运算符是不改变对象变量本身，所以必须要拷贝对象，也就是会调用拷贝构造函数，让拷贝对象去操作。并且最后返回的是拷贝对象，当函数结束时，该拷贝对象就销毁了，不能用引用做返回值。所以返回时又会调用一次拷贝构造构造。所以如果用+运算符重载来复用实现+=运算符重载，每调用一次+运算符重载该函数就要再调用两次拷贝构造。
在这里插入图片描述

而如果使用+=运算符重载来复用+运算符重载，就不需要调用拷贝构造了，因为+=运算符重载函数是会对对象本身修改，所以不需要拷贝对象，并且最后返回的是对象本身，可以用引用做返回，提高了效率哎，这不美滋滋？在这里插入图片描述

所以呢，我们在写这类运算符时，最好先写+=运算符重载，然后再用+=运算符重载复用实现+运算符重载。

🕚⑥.-=运算符重载

有了日期加天数，那肯定也要有日期减天数呀。而且根据上面的介绍，我们是不是应该先从-=运算符重载写起，然后-运算符重载再复用-=运算符重载实现呀。

我们首先要分析，日期如何减一个天数

1.当日期的天数减去给定的天数结果小于等于0时，我们就需要对月改动，如果大于0那就不需要改动
2.当天数小于0时，我们需要借上个月的天数来还(注意是上个月，不是本月)
3.借着借着，要注意月份不能小于1了，当月份借到为0时，正确的应该是12月，并且年份要减一。

//跟+=运算符重载一样，这里-=运算符重载也可以使用引用做返回，因为最后返回的是对象本身，而不是对象的拷贝什么的。
Data& Data::operator-=(int day)
{
   //首先将天数全部减去
	_day -= day;
	while (_day <= 0)//当天数小于等于0时，就要进循环来借上月份中的天数
	{
		--_month;//首先需要将月份减一，因为我们借的是上个月的天数，而不是本月的，本月没有天数辣，都用来减去天数变成负数了都，哪里的剩余天数。
		if (_month == 0)//要注意月份不能小于1，当月份为0时
		{
			--_year;//年份要减一
			_month = 12;//要将月份改成12
		}
		_day += GetMonDay(_year, _month);//借上个月份的天数来还。
	}
	return *this;
}

其实这个函数还有一点点问题，那就是下面这样：

int main()
{
	Data d1(2023, 4, 26);
	d1-=-10;
	//日期减去一个天数，但这个天数却是负数，那结果是对的吗？
	
}

在这里插入图片描述
可以明显看出肯定错误了，因为天数怎么能超过31呢。
正确的场景是，如果天数为负数，那么-=天数应该变成了+=天数。
而+=天数就应该变成-=天数。
所以我们在-=运算符重载函数里再完善一点。

Data& Data::operator-=(int day)
{
	if (day < 0)//如果天数小于0，那么-=天数就应该变成+=天数
	{
		return *this += -day;//这里的day还是负数所以加上负号让它变成正号。
	}
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonDay(_year, _month);
	}
	return *this;
}

同理+=运算符重载函数里也应该这样写。

Data& Data::operator+=(int day)
{
	if (day < 0)//如果天数小于0，那么+=天数就应该变成-=天数
	{
		return *this -= -day;//这里的day还是负数所以加上负号让它变成正号。
	}
	_day += day;
	while (_day > GetMonDay(_year, _month))
	{
		_day -= GetMonDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

🕗⑦.-运算符重载(1)

有了-=运算符重载，我们还怕-运算符重载无法完成？笑话!
在这里插入图片描述
我们直接复用-=运算符重载即可，但要注意的是-运算符重载函数，需要拷贝对象，因为-运算符不修改对象本身喔。

Data Data::operator-(int day)
{
	Data tmp(*this);//需要拷贝构造一个对象，让这个对象去操作
	tmp -= day;//复用-=运算符重载
	return tmp;
}

🕖⑧.-运算符重载(2)

日期-天数是有意义，可以知道天数之前是什么日期。
那日期-日期有没有意义呢？肯定有呀，这可以知道你小子从出生到现在活了多久。 在这里插入图片描述
这个就是对-运算符进行再重载。参数由天数(int类型)变成了，日期(日期类)。
因为函数名相同，但参数不同所以就可以构成重载。

那日期-日期如何计算呢？

data1 - data2 看起来很麻烦，涉及天数和月份甚至年份一起要改变。
不过我们可以不直接相减，换一种方法来求它们之间的天数。
1.只要让日期小的不断的加加到大的日期，每加一次就计数一次
2.当两个日期相同时，计数器所显示的就是它们之间的天数
3.不过要注意的是，一开始我们可不知道哪个日期大，哪个日期小，需要讨论。

int Data::operator-(Data& d)//这是日期-日期 -运算符重载函数
{
	Data max = *this;//默认*this日期对象大
	Data min = d;//d对象小
	int flag = 1;

	if (*this < d)//如果错了
	{
		max = d;
		min = *this;
		flag = -1;//那就将flag置为-1
	}
	int n = 0;//计数器
	while (min != max)//让小的日期不断的加加到大的日期
	{
		++min;//每加一次
		++n;//计数器计数一次
	}
	return n*flag;//最后计数器n就是它们之间的天数，而flag决定是正的还是负的。
}

🕕⑨.前置++运算符重载

C语言中++这个运算符分为前置++和后置++，前置++是先++再使用，而后置++是先使用后++。
在C++中如果要对自定义类型进行前置或者后置++，需要将它们重载成运算符函数。

C++规定前置++就正常按照运算符重载函数写，而后置++重载是要多增加一个int类型的参数，但是调用函数时该参数不用传递，编译器会自动传递。

//这里可以用引用做返回值，因为最后返回的是对象本身
Data& Data::operator++()//前置++运算符重载
{
	*this += 1;//这里的+=其实就是+=运算符重载
	return *this;
}

🕔⑩.后置++运算符重载

//这里不可以用引用左返回，因为返回的是拷贝对象，不是对象本身，函数结束，就销毁了
Data Data::operator++(int)//后置++运算符重载---比前置++多一个参数，为什么呢？因为这样才可以和前置++构成承载，因为函数名相同，参数不同才可以构成承载，因为不需要使用参数，所以可以只写类型
{
	Data tmp(*this);//后置++，返回的是使用前的状态，因为后置++是先使用后++
	*this += 1;//对象先使用，再++，也就是要将没++之前的对象返回过去。
	return tmp;
}

⏰二.日期类的实现

TEST.h文件
#pragma once
#include <iostream>
using namespace std;

class Data
{
	//析构也不用写
public:
	Data(int year = 1, int month = 1, int day = 1)//构造函数要写，拷贝构造函数不用写，赋值重载不用写
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	Data(const Data& d)
	{
	
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	bool operator<(const Data& d);
	bool operator==(const Data& d);
	bool operator<=(const Data& d);
	bool operator>(const Data& d);
	bool operator>=(const Data& d);
	bool operator!=(const Data& d);
	Data operator++();//前置++
	Data operator++(int);//后置++
	int GetMonDay(int year, int month);
	Data& operator+=(int day);
	Data operator+(int day);
	Data& operator-=(int day);
	Data operator-(int day);
	int operator-(Data& d);
private:
	int _year;
	int _month;
	int _day;
};

```c



TEST.c文件

```c

bool Data:: operator<(const Data& d)
{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}
		return false;
	
}
bool Data::operator==(const Data& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}
bool Data::operator<=(const Data& d)//直接复用上面的
{
	return *this < d || *this == d;
}
bool Data::operator>(const Data& d)
{
	return !(*this <= d);
}

bool Data::operator>=(const Data& d)
{
	return !(*this < d);
}
bool Data::operator!=(const Data& d)
{
	return !(*this == d);
}

int Data::GetMonDay(int year, int month)
{
	static int monday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//频繁调用
	/*if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)&&month==2)*/
	if (month == 2&&(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) )
	{
		return 29;
	}
	else
	return monday[month];
}
//Data& Data::operator+=(int day)//用+复用+=-最好先实现+= 再复用实现 +
//{
//	*this=*this + day;
//	
//	return *this;
//}
Data& Data::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}
	_day += day;
	while (_day > GetMonDay(_year, _month))
	{
		_day -= GetMonDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}
Data Data::operator+(int day)
{
	Data tmp(*this);//拷贝一份，让tmp返回，*this没有改变
	tmp._day += day;
	while (tmp._day > GetMonDay(tmp._year, tmp._month))
	{
		tmp._day -= GetMonDay(tmp._year, tmp._month);
		++tmp._month;
		if (tmp._month == 13)
		{
			++_year;
			tmp._month = 1;
		}
	}
	return tmp;
}
//Data Data::operator+(int day)  //+ 复用+=
//{
//	Data tmp(*this);//拷贝一份，让tmp返回，*this没有改变
//	tmp += day;//复用+=重载函数 
//	return tmp;
//}
Data Data::operator++()//前置++运算符重载
{
	*this += 1;
	return *this;
}
Data Data::operator++(int)//后置++运算符重载
{
	Data tmp(*this);
	*this += 1;
	return tmp;
}
Data& Data::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonDay(_year, _month);
	}
	return *this;
}
Data Data::operator-(int day)
{
	Data tmp(*this);
	tmp -= day;
	return tmp;
}
//d1 - d2
int Data::operator-(Data& d)
{
	Data max = *this;
	Data min = d;
	int flag = 1;

	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n*flag;
}
小陶来咯
关注
  • 15
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
C++重载运算符的规则详解
12-31
（1）C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。例如，有人觉得BASIC中用“* *”作为幂运算符很方便，也想在C++中将“* *”定义为幂运算符，用“3* *5”表示35，这是不行的。 （2）C++允许...
详解C++编程中的单目运算符重载与双目运算符重载
01-20
C++单目运算符重载 单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和–i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数...
C++运算符重载规则详解
12-31
C++允许重载的运算符和不允许...C++运算符重载的规则 C++对运算符重载定义了如下几条规则。 1) C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。 例如，有人觉得BASIC中用“**“作为幂运算符很方便
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
C语言——函数指针与指针函数
qq_67319052的博客
05-19 620
函数指针与指针函数有什么区别？
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 712
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
复现的博客
05-23 281
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
C/C++免杀--原生态(GG)
金灰的博客
05-20 335
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
c语言操作注意事项
dropLin的博客
05-20 192
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
【C++】多态
malloc不出对象的博客
05-23 389
本篇文章讲解的C++中的多态，它是面向对象语言中最重要的特性之一，它能对同一行为表现出不同的形态！！
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 311
C语言指针
C++质数的那些事（判断指数、区间筛质数、互质等等）
最新发布
A1063348628的博客
05-23 142
质数的定义：若一个正整数除了1和它自身之外不能被任何自然数整除，则该数称为质数，也叫素数。否则为合数。质数的性质：质数的分布较为稀疏，对于一个足够大的数S，不超过S的质数大约有个，也就是说每InN个数约有一个质数，代码： 二、筛出给定区间的质数 代码（欧拉筛（线性筛））： 三、判断两个整数是否互质 代码： 代码会随个人学习进行持续更新，谢谢您的观看！
操作系统 c语言模仿 动态分区存储管理方式的主存分配回收
zhangshuangrui的博客
05-19 1543
操作系统个作业执行完后，将该分区变成空闲区，并将其与相邻的空闲区合并，主要操作也在空闲区。由于是实验，没有真正的主存要分配，所以在实验中，首先应建立一张空闲区表，初始状态只有一个空闲登记项（假定的主存空闲区）和一张所有状态都为“空”的已分配区表，假定主存空间110KB，操作系统占用10KB,其余为空闲区；然后，可以选择进行主存分配或主存回收，如果是分配，要求输入作业名和所需主存空间大小，如果是回收，输入回收作业的作业名，循环进行主存分配和回收后，如果需要，则显示两张表的内容，以检查主存的分配和回收是否正确。
C++中的复合数据类型及高级特性概览
a_Loki的博客
05-23 201
C++作为一种面向对象的编程语言，提供了丰富的复合数据类型和高级特性，以增强代码的表达能力和效率。本文将概述结构体、联合体、枚举类型的基本概念，探讨函数重载的原则，解释重载解析的优先级，并简要介绍内联函数的作用及其优缺点。
文件操作（C语言）
2303_76654613的博客
05-19 673
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 627
一篇文章带你学会结构体的内存对齐！！超多精美配图！
Codeforces Round 821 (Div. 2) C. Parity Shuffle Sorting （构造之全变成一样的）
2302_79440616的博客
05-23 533
并且注意读题，奇偶数是操作相反而不是不能操作，本人读题的时候就读了半句话发现题做不出来。需要注意的是，你并不需要尽量减少运算次数。，那么就可以取一个特殊情况让所有数都相等，这样就是简单的构造方法。每个测试用例的第一行包含一个整数。，如果中间的任何数和a[n]相加等于偶数，就意味着要让。以相加为偶数为例，之后，如果中间的任何数和。对于每个测试用例，在第一行打印一个整数。相等，如果两者相加是偶数，那么就是让。，所以之后的目标就是让所有数都等于。如果有多个解，请打印任意一个。，相加等于奇数时同理。
c语言，java语言，python语言之间有什么区别
2301_78349092的博客
05-17 613
c语言是一般计算机类学生上大一的时候学的第一门编程语言，一般来说相对于另外的俩种语言，大学生对于c语言的认识应该是最深刻的。相比较之下来说三者都是被广泛使用的编程语言，它们之间存在显著的区别。总的来说，C语言的优势在于性能和底层能力，Java的优势在于跨平台和安全性，而Python的优势在于易用性和快速开发。根据项目的具体需求和开发团队的技能基础，选择最合适的编程语言至关重要。在对比C语言、Java和Python的优缺点时，我们可以看到它们各自的特点适用于不同的编程需求和应用场景。
【C++】＜知识点＞ 类的大小计算
致力于Linux的博客
05-18 141
C++中使用sizeof计算类大小的内在说明。
c++ 运算符重载详解
08-15
运算符重载是 C++ 中面向对象编程的一种强大功能。它允许您重新定义运算符以执行特定操作。例如，您可以重载“+”运算符以执行类对象的加法操作。运算符重载使您能够编写更直观和易于使用的代码。 友元函数是类的非...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小陶来咯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值