C++第四次作业

最新推荐文章于 2022-06-21 19:30:00 发布

齐天

最新推荐文章于 2022-06-21 19:30:00 发布

阅读量627

点赞数

分类专栏： C++作业

本文链接：https://blog.youkuaiyun.com/weixin_43848306/article/details/89494367

版权

C++作业专栏收录该内容

2 篇文章

订阅专栏

Problem A: 时间类的拷贝和整体读写

Description

封装一个时间类Time，用于时间处理的相关功能，支持以下操作：

Time::Time()无参构造方法。
Time::Time(int,int,int)构造方法：传递时分秒的三个参数构造对象。
Time::Time(const T&)拷贝构造方法。拷贝构造函数调用时输出“There was a call to the copy constructor : h,m,s”，“h,m,s”为所构造对象的时分秒数值，无需补0。
对象整体读写方法：
Time::setTime(int,int,int)方法：传递时分秒三个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::setTime(const T&)方法：传递一个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::getTime()方法：返回对象自身的引用。其实，t.getTime()即t。
仅在Time类中的Time::getTime()方法实在是多余，在组合或者继承关系时才会有机会用到。
Time::showTime()方法：输出“hh:mm:ss”，不足两位的要前面补0。
注意：在用Time对象传递参数时应传对象的引用而不是直接传对象，返回对象时同样返回引用，以免产生多余的对象拷贝。
你设计一个时间类Time，使得main()函数能够正确运行。
函数调用格式见append.cc。
append.cc中已给出main()函数。main()函数内容稍微繁复，仅为测试对象的各种调用情况。

Input
输入的第一个整数n，表示有n组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在合法的时间范围内。

Output
开始部分为由main()函数产生的固定输出，用于测试对象的某些方法的调用情况。输出“Test data output :”之后为测试数据对应的输出：
每组测试数据对应一组输出“hh:mm:ss”，不足两位的输出需要前面补0，格式见sample。

Sample Input
5
0 0 1
0 59 59
1 1 1
23 0 0
23 59 59
Sample Output
Copy constructor test output :
There was a call to the copy constructor : 0,0,0
There was a call to the copy constructor : 1,2,3

Test data output :
00:00:01
00:59:59
01:01:01
23:00:00
23:59:59

#include<bits/stdc++.h>
using namespace std;
class Time
{
private:
	int hour, minute, second;
public:
	Time()
	{
		hour = 0;
		minute = 0;
		second = 0;
	}
	Time(int _hour, int _minute, int _second)
	{
		hour = _hour;
		minute = _minute;
		second = _second;
	}
	Time(const Time& T)
	{
		hour = T.hour;
		minute = T.minute;
		second = T.second;
		cout << "There was a call to the copy constructor : " << hour << "," << minute << "," << second << endl;
	}
	Time& setTime(int a, int b, int c)
	{
		hour = a;
		minute = b;
		second = c;
		return *this;
	}
	Time& setTime(const Time& T)
	{
		hour = T.hour;
		minute = T.minute;
		second = T.second;
		return *this;
	}
	Time& getTime()
	{
		return *this;
	}
	void showTime()
	{
		cout << setw(2) << setfill('0') << hour << ":" << setw(2) << setfill('0') << minute << ":" << setw(2) << setfill('0') << second << endl;
	}
};
int main()
{
	cout << "Copy constructor test output :" << endl;
	Time t;
	Time tt(t);
	Time ttt(1, 2, 3);
	Time tttt(ttt.getTime());
	cout << "\nTest data output :" << endl;

	int cases;
	cin >> cases;
	for (int i = 1; i <= cases; ++i)
	{
		if (i % 2 == 0)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.setTime(hour, minute, second).showTime();
		}
		if (i % 2 == 1)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			Time tt(hour, minute, second);
			t.setTime(tt).showTime();
		}
	}
}

Problem B: 时间类的错误数据处理

Description

封装一个时间类Time，用于时间处理的相关功能，支持以下操作：

Time::Time()无参构造方法。
Time::Time(int,int,int)构造方法：传递时分秒的三个参数构造对象。
Time::Time(const T&)拷贝构造方法。
成员读函数：
Time::hour() ：返回Time的小时数；
Time::minute()：返回Time的分钟数；
Time::second()：返回Time的秒数。
成员写函数：
Time::hour(int) ：传参修改Time的小时数；
Time::minute(int)：传参修改Time的分钟数；
Time::second(int)：传参修改Time的秒数。
对象整体读写方法：
Time::setTime(int,int,int)方法：传递时分秒三个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::setTime(const T&)方法：传递一个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::getTime()方法：返回对象自身的引用。其实，t.getTime()即t。
仅在Time类中的Time::getTime()方法实在是多余，在组合或者继承关系时才会有机会用到。
Time::inputTime()方法：按格式从标准输入读取数据修改Time对象的时分秒数值。该方法返回修改后的对象。
Time::showTime()方法：输出“hh:mm:ss”，不足两位的要前面补0。如果对象不是合法的时间，则输出“Time error”。
你设计一个时间类Time，使得main()函数能够正确运行。
函数调用格式见append.cc。
append.cc中已给出main()函数。main()函数内容稍微繁复，仅为测试对象的各种调用情况。

Input
输入的第一个整数n，表示有n组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在int范围内。

Output
每组测试数据对应一组输出“hh:mm:ss”，不足两位的输出需要前面补0。如果输入的时间不合法，则输出“Time error”。格式见sample。

Sample Input
6
0 0 1
0 59 59
1 1 60
23 0 0
23 59 59
24 1 0
Sample Output
00:00:01
00:59:59
Time error
23:00:00
23:59:59
Time error
HINT

输出格式用头文件中流操作算子：

setw(w) ：设置数据的输出宽度为w个字符

setfill©：设置用字符c作为填充字符

#include<bits/stdc++.h>
using namespace std;
class Time
{
private:
	int h, m, s;
public:
	Time()
	{
		h = 0;
		m = 0;
		s= 0;
	}
	Time(int _hour, int _minute, int _second)
	{
		h = _hour;
		m = _minute;
		s = _second;
	}
	Time(const Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		cout << "There was a call to the copy constructor : " << h << "," << m << "," << s << endl;
	}
	int hour()
	{
		return h;
	}
	int minute()
	{
		return m;
	}
	int second()
	{
		return s;
	}
	void hour(int _hour)
	{
		h= _hour;
	}
	void minute(int _minute)
	{
		m = _minute;
	}
	void second(int _second)
	{
		s = _second;
	}
	Time& setTime(int a, int b, int c)
	{
		h = a;
		m = b;
		s = c;
		return *this;
	}
	Time& setTime(const Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		return *this;
	}
	Time& getTime()
	{
		return *this;
	}
	Time& inputTime() { cin >> h >> m >> s;   return *this; }
	void showTime()
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
		{
			cout << "Time error" << endl;
		}
		else
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << endl;
		}
	}
};
int main()
{
	Time t;
	int cases;
	cin >> cases;
	for (int i = 1; i <= cases; ++i)
	{
		if (i % 4 == 0)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			Time tt(hour, minute, second);
			tt.showTime();
		}
		if (i % 4 == 1)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.setTime(hour, minute, second).showTime();
		}
		if (i % 4 == 2)
			t.inputTime().showTime();
		if (i % 4 == 3)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.hour(hour);
			t.minute(minute);
			t.second(second);
			t.showTime();
		}
	}
}

Problem C: 时间类的常量

Description

封装一个时间类Time，用于时间处理的相关功能，支持以下操作：

Time::Time()无参构造方法。
Time::Time(int,int,int)构造方法：传递时分秒的三个参数构造对象。
Time::Time(const T&)拷贝构造方法。
成员读函数：
Time::hour() ：返回Time的小时数；
Time::minute()：返回Time的分钟数；
Time::second()：返回Time的秒数。
成员写函数：
Time::hour(int) ：传参修改Time的小时数；
Time::minute(int)：传参修改Time的分钟数；
Time::second(int)：传参修改Time的秒数。
对象整体读写方法：
Time::setTime(int,int,int)方法：传递时分秒三个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::setTime(const T&)方法：传递一个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::getTime()方法：返回对象自身的引用。其实，t.getTime()即t。
仅在Time类中的Time::getTime()方法实在是多余，在组合或者继承关系时才会有机会用到。
Time::inputTime()方法：按格式从标准输入读取数据修改Time对象的时分秒数值。该方法返回修改后的对象。
Time::showTime()方法：输出“hh:mm:ss”，不足两位的要前面补0。如果对象不是合法的时间，则输出“Time error”。
注意：为了保证Time类的常量对象能够正确的调用Time类的方法，那些不修改对象数据成员的函数都应该是常量成员函数，在返回对象自身的引用时也应返回常量引用。
你设计一个时间类Time，使得main()函数能够正确运行。
函数调用格式见append.cc。
append.cc中已给出main()函数。main()函数内容稍微繁复，仅为测试对象的各种调用情况。

Input
输入的第一个整数n，表示有n组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在int范围内。

Output
开始部分为由main()函数产生的固定输出，用于测试对象的某些方法的调用情况。输出“Test data output :”之后为测试数据对应的输出：
每组测试数据对应一组输出“hh:mm:ss”，不足两位的输出需要前面补0。如果输入的时间不合法，则输出“Time error”。格式见sample。

Sample Input
6
0 0 1
0 59 59
1 1 60
23 0 0
23 59 59
24 1 0
Sample Output
Constant test output :
00:00:00
01:02:03
Time error

Test data output :
00:00:01
00:59:59
Time error
23:00:00
23:59:59
Time error

#include<bits/stdc++.h>
using namespace std;
class Time
{
private:
	int h, m, s;
public:
	Time()
	{
		h = 0;
		m = 0;
		s = 0;
	}
	Time(int _hour, int _minute, int _second)
	{
		h = _hour;
		m = _minute;
		s = _second;
	}
	Time(const Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		cout << "There was a call to the copy constructor : " << h << "," << m << "," << s << endl;
	}
	int hour()const
	{
		return h;
	}
	int minute()const
	{
		return m;
	}
	int second()const
	{
		return s;
	}
	void hour(int _hour)
	{
		h = _hour;
	}
	void minute(int _minute)
	{
		m = _minute;
	}
	void second(int _second)
	{
		s = _second;
	}
	Time &setTime(int a, int b, int c)
	{
		h = a;
		m = b;
		s = c;
		return *this;
	}
	Time &setTime(Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		return *this;
	}
	const Time &getTime()const
	{
		return *this;
	}
	Time& inputTime()
	{ 
		int a, b, c; 
		cin >> a >> b >> c; 
		h = a;
		m = b; 
		s = c;   
		return *this; 
	}
	void showTime()const
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
		{
			cout << "Time error" << endl;
		}
		else
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << endl;
		}
	}
};
int main()
{
	cout << "Constant test output :" << endl;
	const Time c;
	const Time cc(1, 2, 3);
	const Time ccc(23, 60, 60);
	cout << setw(2) << setfill('0') << c.hour() << ":";
	cout << setw(2) << setfill('0') << c.minute() << ":";
	cout << setw(2) << setfill('0') << c.second() << endl;
	cc.getTime().showTime();
	ccc.showTime();

	cout << "\nTest data output :" << endl;
	Time t;
	int cases;
	cin >> cases;
	for (int i = 1; i <= cases; ++i)
	{
		if (i % 4 == 0)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			Time tt(hour, minute, second);
			tt.showTime();
		}
		if (i % 4 == 1)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.setTime(hour, minute, second).showTime();
		}
		if (i % 4 == 2)
			t.inputTime().showTime();
		if (i % 4 == 3)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.hour(hour);
			t.minute(minute);
			t.second(second);
			t.showTime();
		}
	}
}

Problem D: 时间类的12小时制输出

Description

封装一个时间类Time，用于时间处理的相关功能，支持24小时制和12小时制，支持以下操作：

Time::Time()无参构造方法。
Time::Time(int,int,int)构造方法：传递时分秒的三个参数构造对象。
Time::Time(const T&)拷贝构造方法。
成员读函数：
Time::hour() ：返回Time的小时数；
Time::minute()：返回Time的分钟数；
Time::second()：返回Time的秒数。
成员写函数：
Time::hour(int) ：传参修改Time的小时数；
Time::minute(int)：传参修改Time的分钟数；
Time::second(int)：传参修改Time的秒数。
对象整体读写方法：
Time::setTime(int,int,int)方法：传递时分秒三个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::setTime(const T&)方法：传递一个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::getTime()方法：返回对象自身的引用。其实，t.getTime()即t。
仅在Time类中的Time::getTime()方法实在是多余，在组合或者继承关系时才会有机会用到。
Time::inputTime()方法：按格式从标准输入读取数据修改Time对象的时分秒数值。该方法返回修改后的对象。
Time::showTime()方法：输出“hh:mm:ss”，不足两位的要前面补0。如果对象不是合法的时间，则输出“Time error”。
Time::showTime12Hour()方法：输出12小时制的时间：上午输出“hh:mm:ss a.m.”、下午输出“hh:mm:ss p.m.”。如果对象不是合法的时间，则输出“Time error”。注意：该函数仅显示12小时制时间，并不修改对象的数据成员，对象依然存储24小时制时间。
12小时制以数字12、1、2、3、4、5、6、7、8、9、10、11依次序表示每个时段的。
24小时制的00:00～00:59，是12小时制的12:00 a.m.～12:59 a.m.；
24小时制的1:00～11:59是十二小时制的1:00 a.m.～11:59 a.m.。
24小时制的12:00～12:59，是12小时制的12:00 p.m.～12:59 p.m.；
24小时制的13:00～23:59是十二小时制的1:00 p.m.～11:59 p.m.。
你设计一个时间类Time，使得main()函数能够正确运行。
函数调用格式见append.cc。
append.cc中已给出main()函数。main()函数内容稍微繁复，仅为测试对象的各种调用情况。

Input
输入的第一个整数n，表示有n组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在int范围内。

Output
开始部分为由main()函数产生的固定输出，用于测试对象的某些方法的调用情况。输出“Test data output :”之后为测试数据对应的输出：
每组测试数据对应一组输出，奇数行的输入对应输出24小时制时间“hh:mm:ss”，偶数行的输入对应输出12小时制时间：上午输出“hh:mm:ss a.m.”、下午输出“hh:mm:ss p.m.”，不足两位的输出需要前面补0。如果输入的时间不合法，则输出“Time error”。格式见sample。

Sample Input
6
0 0 1
0 59 59
1 1 60
23 0 0
23 59 59
24 1 0
Sample Output
Constant test output :
11:59:58 a.m.
12:00:01 p.m.
11:59:58
12:00:01

Test data output :
00:00:01
12:59:59 a.m.
Time error
11:00:00 p.m.
23:59:59
Time error

#include<bits/stdc++.h>
using namespace std;
class Time
{
private:
	int h, m, s;
public:
	Time()
	{
		h = 0;
		m = 0;
		s = 0;
	}
	Time(int _hour, int _minute, int _second)
	{
		h = _hour;
		m = _minute;
		s = _second;
	}
	Time(const Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		cout << "There was a call to the copy constructor : " << h << "," << m << "," << s << endl;
	}
	int hour()const
	{
		return h;
	}
	int minute()const
	{
		return m;
	}
	int second()const
	{
		return s;
	}
	void hour(int _hour)
	{
		h = _hour;
	}
	void minute(int _minute)
	{
		m = _minute;
	}
	void second(int _second)
	{
		s = _second;
	}
	Time& setTime(int a, int b, int c)
	{
		h = a;
		m = b;
		s = c;
		return *this;
	}
	Time& setTime(Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		return *this;
	}
	const Time& getTime()const
	{
		return *this;
	}
	Time& inputTime()
	{
		int a, b, c;
		cin >> a >> b >> c;
		h = a;
		m = b;
		s = c;
		return *this;
	}
	void showTime()const
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
		{
			cout << "Time error" << endl;
		}
		else
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << endl;
		}
	}
	void showTime12Hour()const
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
		{
			cout << "Time error" << endl;
		}
		else if (h == 0)
		{
		    cout << setw(2) << setfill('0') << 12 << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << " a.m." << endl;
		}
		else if (h >= 1 && h < 12)
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << " a.m." << endl;
		}
		else if (h >= 12 && h < 13)
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << " p.m." << endl;
		}
		else if (h >= 13)
		{
			cout << setw(2) << setfill('0') << h-12 << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << " p.m." << endl;
		}
	}
};
int main()
{
	cout << "Constant test output :" << endl;
	const Time c(11, 59, 58);
	const Time cc(12, 0, 1);
	c.showTime12Hour();
	cc.showTime12Hour();
	c.showTime();
	cc.showTime();

	cout << "\nTest data output :" << endl;
	Time t;
	int cases;
	cin >> cases;
	for (int i = 1; i <= cases; ++i)
	{
		if (i % 4 == 0)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			Time tt(hour, minute, second);
			tt.showTime12Hour();
		}
		if (i % 4 == 1)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.setTime(hour, minute, second).showTime();
		}
		if (i % 4 == 2)
			t.inputTime().showTime12Hour();
		if (i % 4 == 3)
		{
			int hour, minute, second;
			cin >> hour >> minute >> second;
			t.hour(hour);
			t.minute(minute);
			t.second(second);
			t.showTime();
		}
	}
}

Problem E: 时间类的静态成员计数

Description

封装一个时间类Time，用于时间处理的相关功能，支持以下操作：

Time::Time()无参构造方法。
Time::Time(int,int,int)构造方法：传递时分秒的三个参数构造对象。
Time::Time(const T&)拷贝构造方法。
对象整体读写方法：
Time::setTime(int,int,int)方法：传递时分秒三个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::setTime(const T&)方法：传递一个参数修改Time对象的时分秒数。该方法返回修改后的对象。
Time::getTime()方法：返回对象自身的引用。其实，t.getTime()即t。
仅在Time类中的Time::getTime()方法实在是多余，在组合或者继承关系时才会有机会用到。
Time::showTime()方法：输出“hh:mm:ss”，不足两位的要前面补0。如果对象不是合法的时间，则输出“Time error”。
静态成员方法：
Time::getNumber()方法：返回程序中已创建的Time对象总数。
Time::displayNumber()方法：输出程序中已创建的Time对象总数。
注意：在用Time对象传递参数时应传对象的引用而不是直接传对象，返回对象时同样返回引用，以免产生多余的对象拷贝。多余的拷贝构造会引起对象计数的错误。
你设计一个时间类Time，使得main()函数能够正确运行。
函数调用格式见append.cc。
append.cc中已给出main()函数。main()函数内容稍微繁复，仅为测试对象的各种调用情况。

Input
输入为多行，每行为一组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在int范围内。

Sample Input
0 0 1
0 59 59
1 1 60
23 0 0
23 59 59
24 1 0
Sample Output
Static member test output :
Now, There is 0 object of Time.
Now, There is 1 object of Time.
There was a call to the copy constructor : 0,0,0
Now, There is 2 object of Time.
Now, There is 3 object of Time.
There was a call to the copy constructor : 1,2,3
Now, There is 4 object of Time.

Test data output :
00:00:01
00:59:59
Time error
23:00:00
23:59:59
Time error
6

#include<bits/stdc++.h>
using namespace std;
class Time
{
private:
	int h, m, s;
	static int num;
public:
	Time()
	{
		h = 0;
		m = 0;
		s = 0;
		num++;
	}
	Time(int _hour, int _minute, int _second)
	{
		h = _hour;
		m = _minute;
		s = _second;
		num++;
	}
	Time(const Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		cout << "There was a call to the copy constructor : " << h << "," << m << "," << s << endl;
		num++;
	}
	int hour()const
	{
		return h;
	}
	int minute()const
	{
		return m;
	}
	int second()const
	{
		return s;
	}
	void hour(int _hour)
	{
		h = _hour;
	}
	void minute(int _minute)
	{
		m = _minute;
	}
	void second(int _second)
	{
		s = _second;
	}
	Time& setTime(int a, int b, int c)
	{
		h = a;
		m = b;
		s = c;
		return *this;
	}
	Time& setTime(Time& T)
	{
		h = T.h;
		m = T.m;
		s = T.s;
		return *this;
	}
	const Time& getTime()const
	{
		return *this;
	}
	void showTime()const
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
		{
			cout << "Time error" << endl;
		}
		else
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << endl;
		}
	}
	static int getNumber()
	{
		return num;
	}
	static void displayNumber()
	{
		cout << "Now, There is " << num << " object of Time." << endl;
	}
};
int Time::num = 0;
int main()
{
	cout << "Static member test output :" << endl;
	Time::displayNumber();
	Time t;
	t.displayNumber();
	Time tt(t);
	tt.displayNumber();
	Time ttt(1, 2, 3);
	ttt.displayNumber();
	Time tttt(ttt.getTime());
	tttt.displayNumber();
	int non_cases = Time::getNumber();

	cout << "\nTest data output :" << endl;
	int hour, minute, second;
	while (cin >> hour >> minute >> second)
	{
		Time t;
		t.setTime(hour, minute, second).showTime();
	}
	cout << t.getNumber() - non_cases << endl;
}

Problem F: 时间类的加、减法赋值运算

Description

封装一个时间类Time，在类上重载以下运算符，使得main()函数能够正确运行。

Time::Time()无参构造方法。
Time::inputTime()方法：按格式从标准输入读取数据修改Time对象的时分秒数值。该方法返回修改后的对象。
Time::showTime()方法：输出“hh:mm:ss”，不足两位的要前面补0。如果对象不是合法的时间，则输出“Time error”。
运算符
加法赋值运算符“+=”和减法赋值运算符“-=”：把一个整数m加到Time对象自身，并且仅对合法的时间操作，不会产生不合法的时间，比如：
若原时间对象为“00:00:00”，减去2后的对象为“23:59:58”;
若原时间对象为“23:59:59”，加上1后的对象为“00:00:00”;
若原时间对象为“24:60:60”，加减后的对象仍为“24:60:60”
函数调用格式见append.cc。
append.cc中已给出main()函数

Input
输入的第一个整数n，表示有n组测试数据，每组4个整数，前三个整数为：hh,mm,ss，分别表示时、分、秒，其值都在int范围内，最后一个整数为m。

Output
每个输入对应两行输出，分别为时间“hh,mm,ss”加上m秒和减去m秒后的值。错误的时间输出“Time error”

Sample Input
6
0 0 1 2
0 59 59 1
1 1 60 10
23 0 0 60
23 59 59 100
24 1 0 3
Sample Output
00:00:03
23:59:59
01:00:00
00:59:58
Time error
Time error
23:01:00
22:59:00
00:01:39
23:58:19
Time error
Time error

#include<bits/stdc++.h>
using namespace std;
class Time
{
private:
	int h, m, s,k;
public:
	Time() { h = 0; m = 0; s = 0; }
	Time(int _h, int _m, int _s) { h = _h; m = _m; s = _s; }
	Time(const Time& T) { h = T.h; m = T.m; s = T.s; }
	~Time(){}
	Time& inputTime()
	{
		int a, b, c;
		cin >> a >> b >> c;
		h = a; m = b; s = c;
		return *this;
	}
	void showTime()
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
		{
			cout << "Time error" << endl;
		}
		else
		{
			cout << setw(2) << setfill('0') << h << ":" << setw(2) << setfill('0') << m << ":" << setw(2) << setfill('0') << s << endl;
		}
	}
	Time& operator +=(int t)
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
			return *this;
		else
		{
			k = (h * 3600 + m * 60 + s + t) % (24 * 3600);
			h = k / 3600;
			m = (k - h * 3600) / 60;
			s = k - h * 3600 - m * 60;
			return *this;
		}
	}
	Time& operator -=(int t)
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || m > 59 || s > 59 || h < 0 || s < 0 || m < 0)
			return *this;
		else
		{
			k = (h * 3600 + m * 60 + s - t + 24 * 3600) % (24 * 3600);
			h = k / 3600;
			m = (k - h * 3600) / 60;
			s = k - h * 3600 - m * 60;
			return *this;
		}
	}
};
int main()
{
	int cases;
	cin >> cases;
	for (int i = 1; i <= cases; ++i)
	{
		Time t;
		t.inputTime();
		Time tt(t);
		int num;
		cin >> num;
		t += num;
		t.showTime();
		tt -= num;
		tt.showTime();
	}
}

Problem G: 时间类的流插入、提取和递增、递减运算

Description

封装一个时间类Time，在类上重载以下运算符，使得main()函数能够正确运行。
流插入操作符“>>”，按照输入格式从标准输入读取三个整数：hh,mm,ss，分别表示时、分、秒，其值在int范围内。
流提取操作符“<<”；按照“hh:mm:ss”输出Time类的对象，不合法的时间输出“error!!!”。
前置自增运算符“++”：把时间对象的秒数加1并返回。
前置自减运算符“–”：把时间对象的秒数减1并返回。
后置自增运算符“++”：把时间对象的秒数加1，返回原值。
后置自减运算符“–”：把时间对象的秒数减1，返回原值。
以上4个自增、自减仅对合法的时间操作，并且不会产生不合法的时间。比如：
若原时间对象为“00:00:00”，自减运算后的对象为“23:59:59”;
若原时间对象为“23:59:59”，自增运算后的对象为“00:00:00”;
若原时间对象为“24:60:60”，自增或自减运算后对象仍为“24:60:60”。
函数调用格式见append.cc。
append.cc中已给出main()函数

Input
输入的第一个整数n，表示有n组测试数据，每组3个整数：hh,mm,ss，分别表示时、分、秒，其值都在int范围内。

Output
输出一张表：每列8个字符宽，两列之间有一个空格。
首先，输出一个表头：“++t --t t t-- t++ t ”，
其次，对应每组测试数据在一行内依次以下内容：
前置++、前置–、原值、后置–、后置++、原值。
若输入的日期合法，输出格式为“hh:mm:ss”，不足两位的输出需要前面补0。如果输入的时间不合法，则输出“error!!!”。格式见sample。

Sample Input
6
0 0 1
0 59 59
1 1 60
23 0 0
23 59 59
24 1 0
Sample Output
++t --t t t-- t++ t
00:00:02 00:00:01 00:00:01 00:00:01 00:00:00 00:00:01
01:00:00 00:59:59 00:59:59 00:59:59 00:59:58 00:59:59
error!!! error!!! error!!! error!!! error!!! error!!!
23:00:01 23:00:00 23:00:00 23:00:00 22:59:59 23:00:00
00:00:00 23:59:59 23:59:59 23:59:59 23:59:58 23:59:59
error!!! error!!! error!!! error!!! error!!! error!!!

#include <iostream>
#include <iomanip>
using namespace std;
class Time
{
private:
	int h, m, s;
	int flag;
public:
	friend istream& operator >> (istream& is, Time& t)
	{
		is >> t.h >> t.m >> t.s;
		if (t.h > 23 || t.h < 0 || t.m>59 || t.m < 0 || t.s>59 || t.s < 0)
			t.flag = 1;
		else t.flag = 0;
		return is;
	}
	friend ostream& operator << (ostream & os, const Time & t)
	{
		if (t.h * 3600 + t.m * 60 + t.s >= 24 * 3600 || t.h < 0 || t.s < 0 || t.m < 0 || t.m>59 || t.s>59) { os << "error!!!"; }
		else { os << setw(2) << setfill('0') << t.h << ":" << setw(2) << t.m << ":" << setw(2) << t.s; }
		return os;
	}
	Time& operator ++ ()
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || h < 0 || s < 0 || m < 0 || m>59 || s>59)
			return *this;
		else
		{
			flag = ((h * 3600 + m * 60 + s) + 1) % (24 * 3600);
			h = flag / 3600;
			m = (flag - h * 3600) / 60;
			s = flag - h * 3600 - m * 60;
			return *this;
		}
	}
	Time & operator --()
	{
		if (h * 3600 + m * 60 + s >= 24 * 3600 || h < 0 || s < 0 || m < 0 || m>59 || s>59)
			return *this;
		else
		{
			flag = ((h * 3600 + m * 60 + s) - 1 + 24 * 3600) % (24 * 3600);
			h = flag / 3600;
			m = (flag - h * 3600) / 60;
			s = flag - h * 3600 - m * 60;
			return *this;
		}
	}
	Time operator ++ (int)
	{
		Time t = (*this);
		if (h * 3600 + m * 60 + s >= 24 * 3600 || h < 0 || s < 0 || m < 0 || m>59 || s>59)
			return t;
		else
		{
			flag = ((h * 3600 + m * 60 + s) + 1) % (24 * 3600);
			h = flag / 3600;
			m = (flag - h * 3600) / 60;
			s = flag - h * 3600 - m * 60;
			return t;
		}
	}
	Time operator --(int)
	{
		Time t = (*this);
		if (h * 3600 + m * 60 + s >= 24 * 3600 || h < 0 || s < 0 || m < 0 || m>59 || s>59)
			return t;
		else
		{
			flag = ((h * 3600 + m * 60 + s) - 1 + 24 * 3600) % (24 * 3600);
			h = flag / 3600;
			m = (flag - h * 3600) / 60;
			s = flag - h * 3600 - m * 60;
			return t;
		}
	}
};

int main()
{
	Time t;
	int cases;
	cin >> cases;
	cout << setw(8) << left << "++t" << " ";
	cout << setw(8) << left << "--t" << " ";
	cout << setw(8) << left << "t" << " ";
	cout << setw(8) << left << "t--" << " ";
	cout << setw(8) << left << "t++" << " ";
	cout << setw(8) << left << "t" << right << endl;
	for (int i = 1; i <= cases; ++i)
	{
		cin >> t;
		cout << (++t) << " ";
		cout << (--t) << " ";
		cout << t << " ";
		cout << t-- << " ";
		cout << t++ << " ";
		cout << t << endl;
	}
}