喜欢的朋友可以关注收藏一下
本文实现了一个date类型，原版要求如下(括号为超出要求附加)：为Date类实现如下成员：1. 构造器，可以初始化年、月、日。(使用了模板)2. 大于、小于、等于（> 、< 、==）操作符重载，进行日期比较。（>=,<=,==）3. print() 打印出类似 2015-10-1 这样的格式。(print(变长参数)，printA(字符指针，date)）然后创建两个全局函数：1. 第1个函数 CreatePoints生成10个随机的Date，并以数组形式返回；（自定义了随机生成器类class Rand_int）2. 第2个函数 Sort 对第1个函数CreatePoints生成的结果，将其按照从小到大进行排序。 （快速排序算法QuickSort）最后在main函数中调用CreatePoints，并调用print将结果打印出来。然后调用Sort函数对前面结果处理后，并再次调用print将结果打印出来。
在此之前先放一下完整版的代码
// 本文件名 date.h 我的编程环境VS2013
/* 本程序的注释代表仅代表个人理解，不一定完全正确，全是我亲自敲上去的，如有错误请联系我。 */
/* 本程序随机数生成器类和变参数print（）函数使用了C++11 的标准，可能有的编译器不能编译通过，我会截图一下编译结果 */
#ifndef __DATE_H__
#define __DATE_H__
#include
#include //c++ 11 里面不少随机数生成器的引擎和分布只支持c++ 11标准，部分编译器不支持
using namespace std;
template //def template typename is T
class date
{
public:
date(T y = 0, T m = 0, T d = 0) : year(y), month(m), day(d)
{
;
}
T year_fun() const { return year; }
T month_fun() const { return month; }
T day_fun() const { return day; }
date& operator = (const date&); //赋值运算符重载函数
private:
T year, month, day; //def 年，月，日
friend date& __doequ(date*, const date&); //赋值实际运算函数
friend void CreatePoints(date *buff, const int& n);
};
class Rand_int //等概率整数的随机数生成器 随机生成器由引擎（负责生成一组随机值或者伪随机数）和一种分布（负责把引擎产生的值映射到某个数学分布上）
{
public:
Rand_int(int low, int high) : dist{ low, high }
{
;
} //构造函数 初始化随机数范围
int operator()(){ return dist(re); } //操作符（） 重载 得到一个随机int
private:
default_random_engine re; //默认随机引擎
uniform_int_distribution<> dist;//分布：生成的所有整数概率相等
};
/* 函数声明区 */
//inline date printA(const char *a, const date& x);
inline date& __doequ(date* ths, const date& r); //赋值实际运算函数
/************************************************************************************************************/
/* 对 cout<< date 类型的重载 ostream 是 cout的类 */
ostream& operator<<(ostream& os, const date& x)
{
return os << x.year_fun() << '-' << x.month_fun() << '-' << x.day_fun();
}
/* print函数实现方法一（字符串类型输出，date类型的输出） */
inline void
printA(const date& x)
{
cout << x << endl;
}
inline void
printA(const char *a,const date& x)
{
cout << a << x << endl;
}
/**************************************************************/
/* print函数实现方法二 */
//void printX() {
//
//}
//
//template
//void printX(const T1& firstArg, const Types&... args)
//{
// cout << firstArg << endl;
// printX(args...);
//}
namespace guo{ //把函数封装到命名空间guo ,防止里面的函数、变量、类、对象重复定义
void print()
{
;
}
template //class 的定义和 typename 类似 都是说这个模板参数定义的是一个类，而不是变量.class type 和 class... types type 和 types 是模式 ， ... 是包扩展
void print(const type& x, const types&... next)
{
cout << x << endl;
print(next...);
}
}
/* 日期 赋值（=） 实际运算函数 */
inline date&
__doequ(date* ths, const date& r)
{
ths->year = r.year;
ths->month = r.month;
ths->day = r.day;
return *ths;
}
/* 函数名 ooerator= 日期赋值（=） */
inline date&
date::operator=(const date& r)
{
return __doequ(this, r);
}
/**************************************************************/
void CreatePoints(date *buff,const int& n)
{
Rand_int rnd_year{ 1, 2100 }, rnd_month{ 1, 12 }, rnd_day_28{ 1, 28 }, rnd_day_29{ 1, 29 }, rnd_day_30{ 1, 30 }, rnd_day_31{ 1, 31 };
for (int i = 0; i < n; i++)
{
buff[i].year = rnd_year();
buff[i].month = rnd_month();
if (buff[i].month == 2) //2月份
{
if (buff[i].year % 400 == 0 || (buff[i].year % 4 == 0 && buff[i].year % 100 != 0)) //是瑞年
{
buff[i].day = rnd_day_29();
}
else //不是瑞年
{
buff[i].day = rnd_day_28();
}
}
else if (buff[i].month == 1 || buff[i].month == 3 || buff[i].month == 5 || buff[i].month == 7 || buff[i].month == 8 || buff[i].month == 10 || buff[i].month ==12 ) //31天月份 （else减少判断次数，在cpu运算速度慢时（如89c51单片机），如果判断过多甚至可能卡死现象）
{
buff[i].day = rnd_day_31();
}
else if (buff[i].month == 4 || buff[i].month == 6 || buff[i].month == 9 || buff[i].month == 11) //30天月份 (如果直接else,出错可能性会大)
{
buff[i].day = rnd_day_30();
}
}
}
/* 函数名 ooerator==（日期，日期） 判断两个日期是否相等 重载 */
inline bool
operator==(const date& x, const date& y)
{
return x.year_fun() == y.year_fun() && x.month_fun() == y.month_fun() && x.day_fun()==y.day_fun();
}
/* 函数名 ooerator>（日期，日期） 判断 x日期 是否大于 y日期 重载 */
bool operator>(const date& x, const date& y)
{
bool feedback; //定义反馈变量
if (x.year_fun() > y.year_fun())
{
feedback = 1;
}
else if (x.year_fun() < y.year_fun())
{
feedback = 0;
}
else if (x.year_fun() == y.year_fun())
{
if (x.month_fun() > y.month_fun())
{
feedback = 1;
}
else if (x.month_fun() < y.month_fun())
{
feedback = 0;
}
else if (x.month_fun() == y.month_fun())
{
if (x.day_fun() > y.day_fun())
{
feedback = 1;
}
else if (x.day_fun() < y.day_fun())
{
feedback = 0;
}
else if (x.day_fun() == y.day_fun())
{
feedback = 0;
}
}
}
return feedback;
}
/* 函数名 ooerator>=（日期，日期） 判断 x日期 是否大于等于 y日期 重载 */
bool operator>=(const date& x, const date& y)
{
bool feedback; //定义反馈变量
if (x.year_fun() >= y.year_fun())
{
feedback = 1;
}
else if (x.year_fun() < y.year_fun())
{
feedback = 0;
}
return feedback;
}
/* 函数名 ooerator<（日期，日期） 判断 x日期 是否小于 y日期 重载 */
bool operator<(const date& x, const date& y)
{
bool feedback; //定义反馈变量
if (x.year_fun() > y.year_fun())
{
feedback = 0;
}
else if (x.year_fun() < y.year_fun())
{
feedback = 1;
}
else if (x.year_fun() == y.year_fun())
{
if (x.month_fun() > y.month_fun())
{
feedback = 0;
}
else if (x.month_fun() < y.month_fun())
{
feedback = 1;
}
else if (x.month_fun() == y.month_fun())
{
if (x.day_fun() > y.day_fun())
{
feedback = 0;
}
else if (x.day_fun() < y.day_fun())
{
feedback = 1;
}
else if (x.day_fun() == y.day_fun())
{
feedback = 0;
}
}
}
return feedback;
}
/* 函数名 ooerator<=（日期，日期） 判断 x日期 是否小于等于 y日期 重载 */
bool operator<=(const date& x, const date& y)
{
bool feedback; //定义反馈变量
if (x.year_fun() > y.year_fun())
{
feedback = 0;
}
else if (x.year_fun() <= y.year_fun())
{
feedback = 1;
}
return feedback;
}
/* 快速排序算法QuickSort */
int partition(date *arr, int low, int high) //快速排序一次划分算法partition
{
date key;
key = arr[low];
while (low
{
while (low = key) //右侧扫描
{
high--;
}
if (low < high)
{
arr[low++] = arr[high]; //将较小的记录交换到前面
}
while (low < high && arr[low] <= key) //左侧扫描
{
low++;
}
if (low < high)
{
arr[high--] = arr[low]; //将较大的记录交换到后面
}
}
arr[low] = key;
return low; //low为轴值记录的最终位置
}
void sort(date *arr, int start, int end) //快速排序算法QuickSort
{
int pos;
if (start
{
pos = partition(arr, start, end); //一次划分，pos为轴值得最终位置
sort(arr, start, pos - 1); //递归地对左侧子序列进行快速排序
sort(arr, pos + 1, end); //递归地对右侧子序列进行快速排序
}
}
/****************************************************************************************************/
#endif
// 本文件名 date.cpp 我的编程环境VS2013
/* 本程序的注释代表仅代表个人理解，不一定完全正确，全是我亲自敲上去的，如有错误请联系我。 */
/* 本程序随机数生成器类和变参数print（）函数使用了C++11 的标准，可能有的编译器不能编译通过，我会截图一下编译结果 */
#include
#include"date.h"
#include
#include //c++ 11 里面不少随机数生成器的引擎和分布只支持c++ 11标准，部分编译器不支持
const int SUM = 10; //C语言中常用的方法是 #define SUM 10 而这种方法在程序运行过程中可能出现各种错误，如不做类型检查等，所以我采用了宏常量定义const,增加代码的安全性
using namespace std; //这句话其实就表示了所有的标准库函数都在标准命名空间std中进行了定义,其作用就在于避免发生重命名的问题。（本质是把std中定义的函数、变量、类等释放出来）
//using namespace guo; //不能偷懒用这种全局的命名空间声明,因为print();在命名空间std和命名空间guo中都有定义。（ 因为这个声明把命名空间中的guo释放出来以后发现有两个print(); 从语法上会产生歧义 ）
int main(void)
{
//date d1(2017, 4, 15);
//date d2(2017, 4, 16);
//date d3(2017, 4, 17);
date d1{ 2017, 4, 15 }; //一般情况下{}和（）都可以做初始化操作，而前着明确了要做什么（初始化），避免了一些潜在的错误，当然这里（）也是可以的。
date d2{ 2017, 4, 16 };
date d3{ 2017, 4, 17 };
//default_random_engine e; //随机数方法一 默认随机引擎
//uniform_int_distribution dist(1,10000); //分布：生成的所有整数概率相等 （范围1——10000）
//int rand1 = dist(e); ////获取伪随机数
date ten_rand_date[SUM];
CreatePoints(ten_rand_date,SUM);
cout << "d1: " << d1 << endl;
d1 = date(2015, 10, 1); //测试赋值运算符重载
cout << "测试赋值运算符重载: d1 = date(2015, 10, 1); d1:" << d1 << endl;
printA(d1); //printA函数 使用 方法一(date类型的输出)
printA("(使用自定义printA) d1:", d1); //printA函数 使用 方法一（字符串类型输出，date类型的输出）
guo::print("(guo::使用自定义print):", d1, d2, d3); //print函数 使用 方法二 (支持任意类型且参数变长) ( 引用命名空间guo中的print()函数，这样可以和命名空间std中的print（）; 起到区分作用 )
guo::print("随机创建的10个日期为：");
for (int i = 0; i < SUM; i++)
{
guo::print(ten_rand_date[i]);
}
sort(ten_rand_date, 0, SUM - 1); //排序函数 （快速排序算法QuickSort）
guo::print("排序后的10个日期为：");
for (int i = 0; i < SUM; i++)
{
guo::print(ten_rand_date[i]);
}
guo::print("==运算符测试：d1,d2",d1==d2); // 0
guo::print("==运算符测试：d1,d1", d1 == d1);// 1
guo::print(">运算符测试：d1,d2", d1 > d2); // 0
guo::print(">运算符测试：d1,d1", d1 > d1); // 0
guo::print(">运算符测试：d2,d1", d2 > d1); // 1
guo::print("<运算符测试：d1,d2", d1 < d2); // 1
guo::print("<运算符测试：d1,d1", d1 < d1); // 0
guo::print("<运算符测试：d2,d1", d2 < d1); // 0
guo::print(">=运算符测试：d1,d2", d1 >= d2); // 0
guo::print(">=运算符测试：d1,d1", d1 >= d1); // 1
guo::print(">=运算符测试：d2,d1", d2 >= d1); // 1
guo::print("<=运算符测试：d1,d2", d1 <= d2); // 1
guo::print("<=运算符测试：d1,d1", d1 <= d1); // 1
guo::print("<=运算符测试：d2,d1", d2 <= d1); // 0
system("pause");
return 0;
}
