C++第十一章__用类方法合并另个时间__运算符重载
目录
用类方法合并另个时间&运算符重载
用类方法合并另个时间的代码如下：
1 //mytime.h 2 #ifndef MYTIME_H_ 3 #define MYTIME_H_ 4 5 class Time 6 { 7 private: 8 int hour; 9 int minitue; 10 public: 11 Time(); //声明默认构造函数 12 //Time(int & h, int & m); //声明构造函数,如果是这样声明构造函数的话,在主函数中调用构造函数,传入一个数字是不合法的 13 Time(int h, int m); //声明构造函数 14 Time Sum(Time & T); //声明返回值为类对象的函数，形参为指向类对象的引用 15 void Addhour(int h); //单独的增加小时 16 void Addminitue(int m); //单独的增加分钟 17 void Reset(int h=0, int m=0); //重置时间 18 void show(); 19 }; 20 21 #endifmytime.h
1 //mytime.cpp 2 #include <iostream> 3 #include "mytime.h" 4 5 Time::Time() //默认构造函数的定义，创建类对象时，默认执行以下操作 6 { 7 hour = 0; 8 minitue = 0; 9 } 10 11 12 /*Time::Time(int & h, int & m) *///构造函数定义，创建类对象时，使用构造函数时执行以下操作. 13 //声明构造函数,如果是这样声明构造函数的话,在主函数中调用构造函数,传入一个数字是不合法的 14 //即 int & h = 4; 这样是不合法的 15 Time::Time(int h, int m) //这样在声明类对象的时候，调用该构造函数才是合法的，因为将数字传递给引用是不合法的 16 { 17 hour = h; 18 minitue = m; 19 } 20 21 Time Time::Sum(Time & T) 22 { 23 Time s; //新建一个TIme对象，用于作为该函数的返回值 24 s.minitue = minitue + T.minitue; 25 s.hour = hour + T.hour + s.minitue / 60; 26 //hour是调用Sum()方法的对象中的数据,T.hour是作为实参传入的对象中的数据 27 //最后再加上调用对象的分钟数，和，作为实参传入的分钟数的和，然后取整 28 s.minitue = s.minitue % 60; //对两个对象中数据的分钟数取余 29 30 return s; 31 } 32 //注意:Sum()函数的返回值不能是Time & (指向Time对象的引用),这是由于返回的对象时s，而s是一个在Sum() 33 //中定义的局部变量，Sum()函数执行完毕后，s将会消失，返回一个消失的引用是不合适的 34 //所以这里返回s对象的副本，之后在主函数中可以使用它 35 //以前函数的返回值可以为引用，是因为返回的对象均为从主函数中传入的对象，这些对象都是在主函数中定义的 36 //所以可以返回，比如this指针那里，传入一个对象和this指针指向的调用类方法的对象 37 38 //只是增加小时 39 void Time::Addhour(int h) 40 { 41 hour = hour + h; 42 } 43 44 //只是增加分钟 45 void Time::Addminitue(int m) 46 { 47 minitue = minitue + m; 48 hour = hour + minitue / 60; //如果增加的分钟数超过了60则对minitue以60为底取整 49 minitue = minitue % 60; //如果增加的分钟数超过了60则对minitue以60为底取余 50 } 51 52 //重置时间 53 void Time::Reset(int h, int m) 54 { 55 hour = h; 56 minitue = m; 57 } 58 59 //显示对象中的数据 60 void Time::show() 61 { 62 std::cout << "hour= " << hour << " minitue= " << minitue << std::endl; 63 }mytime.cpp
1 //user_main.cpp 2 #include <iostream> 3 #include "mytime.h" 4 5 int main() 6 { 7 Time s1; //定义一个Time类对象，并用默认构造函数进行初始化 8 Time s2(2, 40); //定义一个Time类对象，并隐式的调用构造函数 9 Time s3(5, 55); //定义一个Time类对象，并隐式的调用构造函数 10 11 s1 = s2.Sum(s3); //将Sum()中的this指向s2，s形参用实参s3代替 12 s1.show(); 13 14 s1.Addhour(3); //对s1对象中的数据,只是增加小时 15 s1.show(); 16 17 system("pause"); 18 return 0; 19 } 20 /* 总结 */ 21 /* 22 01)关于引用的使用方法:int & rt = 3; 这样使用是不合法的,要注意在函数参数传递的时候不要发生这样的错误 23 02)关于函数返回值的问题:如果一个变量(包括对象)是在该函数内创建的，那么是不可以以引用的方式返回的 24 因为引用返回的都是该变量本身，而该变量在对应的函数执行完毕之后就消失了，从而发生错误。 25 但是如果变量(对象)是从主函数中传入的，并且返回的也是从主函数中传入的变量(对象)，那么是可以以引用 26 的方式返回的。 27 03) 28 */user_main.cpp
/* 总结 */
01)关于引用的使用方法:int & rt = 3; 这样使用是不合法的,要注意在函数参数传递的时候不要发生这样的错误
02)关于函数返回值的问题:如果一个变量(包括对象)是在该函数内创建的，那么是不可以以引用的方式返回的
因为引用返回的都是该变量本身，而该变量在对应的函数执行完毕之后就消失了，从而发生错误。
但是如果变量(对象)是从主函数中传入的，并且返回的也是从主函数中传入的变量(对象)，那么是可以以引用
的方式返回的。
执行结果：
运算符重载
01)要使用重载运算符，必须使用被称为运算符函数的特殊函数形式：
operaterop(argument-list)
其中operater为关键字,op是要重载的运算符,argument-list为形参，相当于创建一个名字为operaterop的函数
比如对+进行重载即：operater+()，该函数没有形参
op必须是有效的C++运算符，不能是@，但可以是[],因为[]是数组索引运算符
02)运算符重载实际上仍然是函数调用，只不过换了一种形式
假如对+进行重载即：operater+(Time & s) 其中Time是一个类
那么就可以说使用如下方式对两个对象进行相加：
s1 = s2 + s3; //其中s1、s2、s3都是Time类对象
编译器发现s1 s2 s3都是类对象，因此使用相应的运算符函数进行替换：
s1 = s2.operater+(s3); //所以说运算符重载实际上也还是函数调用
03)s1 = s2 + s3;该式隐式的使用s2(因为s2调用了类方法)，显式的使用了类对象s3(因为s3作为参数传入)
当然s1 = s3 + s2; 也是可以的，因为s2和s3都是类对象
上句就相当于s1 = s3.operater+(s2);了，即s3调用方法，s2作为参数传入
/* 时间的运算，引入了+运算符重载、-运算符重载和*运算符重载 */
1 //mytime.h 2 //使用运算符重载版本 3 //用 Time operater+(Time & s) const 代替Time Sum(Time & T);即可 4 #ifndef MYTIME_H_ 5 #define MYTIME_H_ 6 7 class Time 8 { 9 private: 10 int hour; 11 int minitue; 12 public: 13 Time(); //声明默认构造函数 14 Time(int h, int m); //声明构造函数 15 Time operator+(const Time & T) const; //对运算符进行重载，形参为执行类对象的引用,返回值为Time对象, 16 //const Time & T 表明方法operator+()也不能修改作为参数传入的对象中的数据 17 //最后一个const表明operater+()方法不能修改调用这个方法的对象中的数据 18 Time operator-(const Time & T) const; //两个const可有可无 19 Time operator*(double d) const; //最后一个const还是表明不能修改调用operator*()方法的对象中的数据 20 void Addhour(int h); //单独的增加小时 21 void Addminitue(int m); //单独的增加分钟 22 void Reset(int h=0, int m=0); //重置时间 23 void show(); 24 }; 25 26 #endif 27 28 /* 运算符重载 */ 29 /* 30 01)要使用重载运算符，必须使用被称为运算符函数的特殊函数形式： 31 operaterop(argument-list) 32 其中operater为关键字,op是要重载的运算符,argument-list为形参，相当于创建一个名字为operaterop的函数 33 比如对+进行重载即：operater+()，该函数没有形参 34 op必须是有效的C++运算符，不能是@，但可以是[],因为[]是数组索引运算符 35 02)运算符重载实际上仍然是函数调用，只不过换了一种形式 36 假如对+进行重载即：operater+(Time & s) 其中Time是一个类 37 那么就可以说使用如下方式对两个对象进行相加： 38 s1 = s2 + s3; //其中s1、s2、s3都是Time类对象 39 编译器发现s1 s2 s3都是类对象，因此使用相应的运算符函数进行替换： 40 s1 = s2.operater+(s3); //所以说运算符重载实际上也还是函数调用 41 03)s1 = s2 + s3;该式隐式的使用s2(因为s2调用了类方法)，显式的使用了类对象s3(因为s3作为参数传入) 42 当然s1 = s3 + s2; 也是可以的，因为s2和s3都是类对象 43 上句就相当于s1 = s3.operater+(s2);了，即s3调用方法，s2作为参数传入 44 45 */mytime.h
1 //mytime.cpp 2 //使用运算符重载版本 3 //用 Time operater+(Time & s) const 代替Time Sum(Time & T);即可 4 //重载-运算符Time Time::operator-(const Time & T) const 5 //重载*运算符Time Time::operator*(double d) const 6 #include <iostream> 7 #include "mytime.h" 8 9 Time::Time() //默认构造函数的定义，创建类对象时，默认执行以下操作 10 { 11 hour = 0; 12 minitue = 0; 13 } 14 15 16 /*Time::Time(int & h, int & m) *///构造函数定义，创建类对象时，使用构造函数时执行以下操作. 17 //声明构造函数,如果是这样声明构造函数的话,在主函数中调用构造函数,传入一个数字是不合法的 18 //即 int & h = 4; 这样是不合法的 19 Time::Time(int h, int m) //这样在声明类对象的时候，调用该构造函数才是合法的，因为将数字传递给引用是不合法的 20 { 21 hour = h; 22 minitue = m; 23 } 24 25 Time Time::operator+(const Time & T) const 26 { 27 Time s; //新建一个TIme对象，用于作为该函数的返回值 28 s.minitue = minitue + T.minitue; 29 s.hour = hour + T.hour + s.minitue / 60; 30 //hour是调用Sum()方法的对象中的数据,T.hour是作为实参传入的对象中的数据 31 //最后再加上调用对象的分钟数，和，作为实参传入的分钟数的和，然后取整 32 s.minitue = s.minitue % 60; //对两个对象中数据的分钟数取余 33 34 return s; 35 } 36 //注意:Sum()函数的返回值不能是Time & (指向Time对象的引用),这是由于返回的对象时s，而s是一个在Sum() 37 //中定义的局部变量，Sum()函数执行完毕后，s将会消失，返回一个消失的引用是不合适的 38 //所以这里返回s对象的副本，之后在主函数中可以使用它 39 //以前函数的返回值可以为引用，是因为返回的对象均为从主函数中传入的对象，这些对象都是在主函数中定义的 40 //所以可以返回，比如this指针那里，传入一个对象和this指针指向的调用类方法的对象 41 42 //对-运算符进行重载 43 Time Time::operator-(const Time & T) const 44 { 45 Time s; //创建一个局部对象，作为返回值 46 s.minitue = minitue - T.minitue; 47 s.hour = hour - T.hour + s.minitue/60; //虽然是减，但是为了以防万一，还是加上这个取整吧 48 s.minitue = s.minitue % 60; 49 50 return s; 51 } 52 53 //对*运算符进行重载 54 Time Time::operator*(double d) const 55 { 56 Time s; //创建一个局部对象，作为返回值 57 long total_time = hour * 60 * d + minitue * d;//这种都hour和minitue都相乘的方法是从书中学到的 58 s.hour = total_time / 60; 59 s.minitue = total_time % 60; 60 61 return s; 62 } 63 64 //只是增加小时 65 void Time::Addhour(int h) 66 { 67 hour = hour + h; 68 } 69 70 //只是增加分钟 71 void Time::Addminitue(int m) 72 { 73 minitue = minitue + m; 74 hour = hour + minitue / 60; //如果增加的分钟数超过了60则对minitue以60为底取整 75 minitue = minitue % 60; //如果增加的分钟数超过了60则对minitue以60为底取余 76 } 77 78 //重置时间 79 void Time::Reset(int h, int m) 80 { 81 hour = h; 82 minitue = m; 83 } 84 85 //显示对象中的数据 86 void Time::show() 87 { 88 std::cout << "hour= " << hour << " minitue= " << minitue << std::endl; 89 }mytime.cpp
1 //user_main.cpp 2 //使用运算符重载版本 3 //用s1=s2+s3代替s1 = s2.Sum(s3);即可 4 //s1=s2+s3;实际上是调用函数的方法：s1=s2.operator+(s3); 5 #include <iostream> 6 #include "mytime.h" 7 8 int main() 9 { 10 Time s1; //定义一个Time类对象，并用默认构造函数进行初始化 11 Time s2(2, 40); //定义一个Time类对象，并隐式的调用构造函数 12 Time s3(5, 55); //定义一个Time类对象，并隐式的调用构造函数 13 14 std::cout << "使用+重载运算符：" << std::endl; 15 s1 = s2 + s3; //等价于s1=s2.operator+(s3); s2和s3可以互换位置 16 s1.show(); 17 18 std::cout << "使用类方法Addhour()：" << std::endl; 19 s1.Addhour(3); //对s1对象中的数据,只是增加小时 20 s1.show(); 21 22 std::cout << "使用-运算符重载方法：" << std::endl; 23 s1 = s1 - s2; //等价于s1=s1.operator-(s2);s1和s2可以互换位置 24 s1.show(); 25 26 std::cout << "使用*运算符重载方法：" << std::endl; 27 s1 = s1 * 2; //等价于s1 = s1.operator-(2); 28 s1.show(); 29 //这里s1只能是在*的左边，2只能是在*的右边 30 //在*的左边的标识符是要调用operator*()方法的，显然数字不能调用该方法 31 //此项缺陷也为以后的友元函数的提出打下了基础 32 33 system("pause"); 34 return 0; 35 } 36 /* 总结 */ 37 /* 38 01)关于引用的使用方法:int & rt = 3; 这样使用是不合法的,要注意在函数参数传递的时候不要发生这样的错误 39 02)关于函数返回值的问题:如果一个变量(包括对象)是在该函数内创建的，那么是不可以以引用的方式返回的 40 因为引用返回的都是该变量本身，而该变量在对应的函数执行完毕之后就消失了，从而发生错误。 41 但是如果变量(对象)是从主函数中传入的，并且返回的也是从主函数中传入的变量(对象)，那么是可以以引用 42 的方式返回的。 43 03) 44 */user_main.cpp
执行结果为：
更多精彩
