---恢复内容开始---
目录
- 用类方法合并另个时间(涉及到函数返回值能不能是引用的问题)
- 运算符重载
- 友元函数
- 对<<运算符的重载&友元函数
- cin.clear()的用法
- 极坐标和直角坐标的相互转换(随机漫步的实现)
- 将double、int等数据类型赋值给类对象
- 将类对象赋值给double、int等型的变量（转换函数）
用类方法合并另个时间&运算符重载(涉及到函数返回值能不能是引用的问题)
用类方法合并另个时间的代码如下：
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 #endif
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 }
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 */
/* 总结 */
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 */
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 }
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 */
执行结果为：
友元函数
01)问题的提出：
对于上一个代码中的对*的函数重载中 Time operator*(double d) const;
对Time对象s1和s2，以及一个double值2.1
使用方法只能是s1 = s2*2.1;//实际上是调用对*的重载函数：s1=s2.operator(2.1);
所以s1 = 2.1*s2; 是会报错的
02)解决方法：
A 写注释：告诉每个人只能按照s2*2.1这种方式去写，不能写成2.1*s2
B 使用非成员函数，非成员函数不是由对象调用的，它使用的值都必须是由实参的形式传入的
但是也引发了一个新问题：非成员函数不能访问私有数据。最终的解决方法是使用友元函数
此处引入友元函数的目的是实现乘法的交换律
03)友元函数的声明方法：使用关键字friend
friend Time operator*(doubla m,const Time & t);//该友元函数同时对*运算符进行了重载
该声明意味着下面两点：
A 虽然operator*()是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用； ***
B 虽然operatir*()不是成员函数，但它有成员函数的访问权限。(可以访问私有数据) ***
04)友元函数的定义方法：不用使用关键字friend，因为它不是成员函数，所以也不用使用Time::限定符
Time operator*(double m, Time & t) const
{
Time result;
long total_time = t.hour * m + t.minitue * m;
result.hour = total_time / 60;
result.minitue = total_time % 60;
return result;
}
05)友元函数调用方法：
有了友元函数之后，就可以直接使用 s1 = 2.1*s2;
编译器将s1 = 2.1*s2;转换成s1 = operator*(2.1,s2);友元函数版本
06)稍作修改，就可以将友元函数改变成非友元函数：
//在该非友元函数中调用对*的重载函数
Time operator*(double m, Time & t) const
{
return t*m; //即实际调用的函数为 t.operator*(m)，即调用的函数是对*的重载的函数
//原来的版本是显式的访问t.hour和t.minitue.由于这里是将对象t整体使用的,所以t*m将调用对*的重载函数
}
07)总结：
如果在类声明中即声明了对*的重载函数Time operator*(double d) const;
在类声明在又声明了友元函数：friend Time operator*(doubla m,const Time & t);
该友元函数同时对*运算符进行了重载，那么在主函数中就可以使用下面的两种方式
s1 = s2 * 2.1; //调用对*的重载函数，编译器将其转换为s1 = s2.operator(2.1);
s1 = 2.1 * s2; //调用友元函数，编译器将其转换为:s1 = operator(2.1,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; 16 Time operator-(const Time & T) const; //两个const可有可无 17 Time operator*(double d) const; //最后一个const还是表明不能修改调用operator*()方法的对象中的数据 18 friend Time operator*(double m, const Time & t); //声明一个友元函数,只允许中声明的时候使用friend关键字 19 void Addhour(int h); //单独的增加小时 20 void Addminitue(int m); //单独的增加分钟 21 void Reset(int h=0, int m=0); //重置时间 22 void show(); 23 }; 24 25 #endif 26 27 28 /* 友元函数 */ 29 /* 30 01)问题的提出： 31 对于上一个代码中的对*的函数重载中 Time operator*(double d) const; 32 对Time对象s1和s2，以及一个double值2.1 33 使用方法只能是s1 = s2*2.1;//实际上是调用对*的重载函数：s1=s2.operator(2.1); 34 所以s1 = 2.1*s2; 是会报错的 35 02)解决方法： 36 A 写注释：告诉每个人只能按照s2*2.1这种方式去写，不能写成2.1*s2 37 B 使用非成员函数，非成员函数不是由对象调用的，它使用的值都必须是由实参的形式传入的 38 但是也引发了一个新问题：非成员函数不能访问私有数据。最终的解决方法是使用友元函数 39 03)友元函数的声明方法：使用关键字friend 40 friend Time operator*(doubla m,const Time & t);//该友元函数同时对*运算符进行了重载 41 该声明意味着下面两点： 42 A 虽然operator*()是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用； 43 B 虽然operatir*()不是成员函数，但它有成员函数的访问权限。(可以访问私有数据) 44 04)友元函数的定义方法：不用使用关键字friend，因为它不是成员函数，所以也不用使用Time::限定符 45 Time operator*(double m, Time & t) const 46 { 47 Time result; 48 long total_time = t.hour * m + t.minitue * m; 49 result.hour = total_time / 60; 50 result.minitue = total_time % 60; 51 return result; 52 } 53 05)友元函数调用方法： 54 有了友元函数之后，就可以直接使用 s1 = 2.1*s2; 55 编译器将s1 = 2.1*s2;转换成s1 = operator*(2.1,s2);友元函数版本 56 06)稍作修改，就可以将友元函数改变成非友元函数： 57 //在该非友元函数中调用对*的重载函数 58 Time operator*(double m, Time & t) const 59 { 60 return t*m; 61 //原来的版本是显式的访问t.hour和t.minitue.由于这里是将对象t整体使用的,所以t*m将调用对*的重载函数 62 //即实际调用的函数为 t.operator*(m) 63 } 64 07)总结： 65 如果在类声明中即声明了对*的重载函数Time operator*(double d) const; 66 在类声明在又声明了友元函数：friend Time operator*(doubla m,const Time & t); 67 该友元函数同时对*运算符进行了重载，那么在主函数中就可以使用下面的两种方式 68 s1 = s2 * 2.1; //调用对*的重载函数，编译器将其转换为s1 = s2.operator(2.1); 69 s1 = 2.1 * s2; //调用友元函数，编译器将其转换为:s1 = operator(2.1,s2); 70 即实现了乘法的交换律。 71 */
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 //由于友元函数不是类成员函数，所以不能使用Time::限定符 87 //在友元函数的定义中也不能出现关键字friend 88 //但是友元函数却可以访问Time类中的私有数据和公有数据 89 Time operator*(double m, const Time & t) 90 { 91 Time result; 92 long total_time = t.hour * 60 * m + t.minitue * m; 93 result.hour = total_time / 60; 94 result.minitue = total_time % 60; 95 96 return result; 97 } 98 99 //显示对象中的数据 100 void Time::show() 101 { 102 std::cout << "hour= " << hour << " minitue= " << minitue << std::endl; 103 }
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 * 2; //等价于s1 = s1.operator*(2); 16 s1.show(); 17 18 s2.Reset(2,40); //对象s2调用类方法Reset()，并使用实参覆盖掉默认参数 19 20 std::cout << "使用友元函数：" << std::endl; 21 s1 = 2 * s2; //等价于s1 = operator*(2,s2); 22 s1.show(); 23 24 25 system("pause"); 26 return 0; 27 }
执行结果为：
对<<运算符的重载&友元函数
01)问题的提出：
在以前的程序版本中，加入要为显示一个Time对象trip的值，我们都是用的一个类方法show()，对象调用类方法
的方式为trip.show()。能不能用cout<<trip;呢，答案是可以的，因为<<也是C++运算符之一
02)运算符<<的历史和cout对象的相关介绍
最初<<运算符是c和c++位运算符，将值中的位左移。ostream类对该运算符进行了重载，将其转换为一个输出工具。
而cout又是类ostream的一个对象，能够识别C++基本类型。这是因为对于每种C++基本类型，ostream类声明中
都包含了相应的重载operator<<()定义。也就是说，一个定义使用int型参数，一个定义使用double型参数，一个定义
使用char型参数等等。因此要让cout能够识别TIme对象，一种方法是将一个新的函数运算符定义添加到ostream
类声明中，但修改ostream类是一个坏主意；一种方法是让Time知道任何使用cout，即在Time中声明对<<的重载函数
03)那么在Time类中声明友元函数还是非友元函数？
如果是声明常规的类方法，则在<<运算符的左边一定是一个Time对象，那么输出就是下面的那样了：
trip<<cout; //这样显然是不合适的
所以要使用友元函数：
void operator<<(ostream & os, const Time & t) //其中ostream是一个类
{
os << t.hour <<" hours" << t.minitue <<"minitues
";
}
这样就可以使用下面的语句了：
cout<<trip; //显示对象trip中的数据了
调用cout<<trip应使用cout对象本身，而不是cout的副本，因此应该使用ostream & os以用，而不是按值传递
Time对象可以按值传递或者是按引用传递，按引用传递比按值传递使用的时间和内存都要少，因此使用按引用传递。
04)改进
很显然，上面对<<重载友元函数对于下面这样的语句是无能为力的：
cout<<"Trip time: "<<trip<<"(Tuesday)
";
05)解决方法：让cout<<"Trip time: "返回一个cout即可解决问题。反应在对<<重载友元函数来说就是返回值为
指向ostream对象的引用即可，即下面改进的对<<重载友元函数版本：
ostream & operator<<(ostream & os, const Time & t) //其中ostream是一个类
{
os << t.hour <<" hours" << t.minitue <<"minitues
";
return os;
}
注意：返回值不再是void了，而是指向ostream对象的引用
06)上面的这个operator<<()函数版本还可以用于将输出写如到文件中：
#include <fstream> //for ofstream
...
ofstream fout; //创建一个ofstream类对象fout
fout.open("savetime.txt"); //对象fout和一个txt文件关联
Time trip(12,40); //创建一个Time类对象trip，并隐式的调用构造函数初始化trip对象
fout<<trip; //实际调用方式为 operator<<(fout,trip);
1 //mytime.h 2 //包含了operator*()和operatro<<()两个友元函数 3 //将operator*()作为内联函数，因为其代码很短(定义也是原型时，要使用关键字friend) 4 5 #ifndef MYTIME_H_ 6 #define MYTIME_H_ 7 #include <iostream> //这里声明了,在mytime.cpp就只包含mytime.h头文件,便可以提供iostream头文件的支持 8 9 class Time 10 { 11 private: 12 int hour; 13 int minitue; 14 public: 15 Time(); //声明默认构造函数 16 Time(int h, int m); //声明构造函数 17 Time operator+(const Time & T) const; 18 Time operator-(const Time & T) const; //两个const可有可无 19 Time operator*(double d) const; //最后一个const还是表明不能修改调用operator*()方法的对象中的数据 20 friend Time operator*(double m, const Time & t) //即使原型是定义,要使用关键字friend,同时也是内联函数 21 { 22 return t * m; //实际上调用方法为t.operator*(m),即调用对*的重载函数 23 } 24 friend std::ostream & operator<<(std::ostream & os, Time & t);//声明一个对运算符<<重载的友元函数 25 void Addhour(int h); //单独的增加小时 26 void Addminitue(int m); //单独的增加分钟 27 void Reset(int h=0, int m=0); //重置时间 28 void show(); 29 }; 30 31 #endif 32 33 34 /* 友元函数 */ 35 /* 36 01)问题的提出： 37 对于上一个代码中的对*的函数重载中 Time operator*(double d) const; 38 对Time对象s1和s2，以及一个double值2.1 39 使用方法只能是s1 = s2*2.1;//实际上是调用对*的重载函数：s1=s2.operator(2.1); 40 所以s1 = 2.1*s2; 是会报错的 41 02)解决方法： 42 A 写注释：告诉每个人只能按照s2*2.1这种方式去写，不能写成2.1*s2 43 B 使用非成员函数，非成员函数不是由对象调用的，它使用的值都必须是由实参的形式传入的 44 但是也引发了一个新问题：非成员函数不能访问私有数据。最终的解决方法是使用友元函数 45 03)友元函数的声明方法：使用关键字friend 46 friend Time operator*(doubla m,const Time & t);//该友元函数同时对*运算符进行了重载 47 该声明意味着下面两点： 48 A 虽然operator*()是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用； 49 B 虽然operatir*()不是成员函数，但它有成员函数的访问权限。(可以访问私有数据) 50 04)友元函数的定义方法：不用使用关键字friend，因为它不是成员函数，所以也不用使用Time::限定符 51 Time operator*(double m, Time & t) const 52 { 53 Time result; 54 long total_time = t.hour * m + t.minitue * m; 55 result.hour = total_time / 60; 56 result.minitue = total_time % 60; 57 return result; 58 } 59 05)友元函数调用方法： 60 有了友元函数之后，就可以直接使用 s1 = 2.1*s2; 61 编译器将s1 = 2.1*s2;转换成s1 = operator*(2.1,s2);友元函数版本 62 06)稍作修改，就可以将友元函数改变成非友元函数： 63 //在该非友元函数中调用对*的重载函数 64 Time operator*(double m, Time & t) const 65 { 66 return t*m; 67 //原来的版本是显式的访问t.hour和t.minitue.由于这里是将对象t整体使用的,所以t*m将调用对*的重载函数 68 //即实际调用的函数为 t.operator*(m) 69 } 70 07)总结： 71 如果在类声明中即声明了对*的重载函数Time operator*(double d) const; 72 在类声明在又声明了友元函数：friend Time operator*(doubla m,const Time & t); 73 该友元函数同时对*运算符进行了重载，那么在主函数中就可以使用下面的两种方式 74 s1 = s2 * 2.1; //调用对*的重载函数，编译器将其转换为s1 = s2.operator(2.1); 75 s1 = 2.1 * s2; //调用友元函数，编译器将其转换为:s1 = operator(2.1,s2); 76 即实现了乘法的交换律。 77 */ 78 79 /* 对<<运算符的重载&友元函数 */ 80 /* 81 01)问题的提出： 82 在以前的程序版本中，加入要为显示一个Time对象trip的值，我们都是用的一个类方法show()，对象调用类方法 83 的方式为trip.show()。能不能用cout<<trip;呢，答案是可以的，因为<<也是C++运算符之一 84 02)运算符<<的历史和cout对象的相关介绍 85 最初<<运算符是c和c++位运算符，将值中的位左移。ostream类对该运算符进行了重载，将其转换为一个输出工具。 86 而cout又是类ostream的一个对象，能够识别C++基本类型。这是因为对于每种C++基本类型，ostream类声明中 87 都包含了相应的重载operator<<()定义。也就是说，一个定义使用int型参数，一个定义使用double型参数，一个定义 88 使用char型参数等等。因此要让cout能够识别TIme对象，一种方法是将一个新的函数运算符定义添加到ostream 89 类声明中，但修改ostream类是一个坏主意；一种方法是让Time知道任何使用cout，即在Time中声明对<<的重载函数 90 03)那么在Time类中声明友元函数还是非友元函数？ 91 如果是声明常规的类方法，则在<<运算符的左边一定是一个Time对象，那么输出就是下面的那样了： 92 trip<<cout; //这样显然是不合适的 93 所以要使用友元函数： 94 void operator<<(ostream & os, const Time & t) //其中ostream是一个类 95 { 96 os << t.hour <<" hours" << t.minitue <<"minitues "; 97 } 98 这样就可以使用下面的语句了： 99 cout<<trip; //显示对象trip中的数据了 100 调用cout<<trip应使用cout对象本身，而不是cout的副本，因此应该使用ostream & os以用，而不是按值传递 101 Time对象可以按值传递或者是按引用传递，按引用传递比按值传递使用的时间和内存都要少，因此使用按引用传递。 102 04)改进 103 很显然，上面对<<重载友元函数对于下面这样的语句是无能为力的： 104 cout<<"Trip time: "<<trip<<"(Tuesday) "; 105 05)解决方法：让cout<<"Trip time: "返回一个cout即可解决问题。反应在对<<重载友元函数来说就是返回值为 106 指向ostream对象的引用即可，即下面改进的对<<重载友元函数版本： 107 ostream & operator<<(ostream & os, const Time & t) //其中ostream是一个类 108 { 109 os << t.hour <<" hours" << t.minitue <<"minitues "; 110 return os; 111 } 112 注意：返回值不再是void了，而是指向ostream对象的引用 113 06)上面的这个operator<<()函数版本还可以用于将输出写如到文件中： 114 #include <fstream> //for ofstream 115 ... 116 ofstream fout; //创建一个ofstream类对象fout 117 fout.open("savetime.txt"); //对象fout和一个txt文件关联 118 Time trip(12,40); //创建一个Time类对象trip，并隐式的调用构造函数初始化trip对象 119 fout<<trip; //实际调用方式为 operator<<(fout,trip); 120 121 */
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> //可以不包含该头文件了,因为在mytime.h头文件中引用了该头文件,且在本文件中包含了mytime.h头文件 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 37 //对-运算符进行重载 38 Time Time::operator-(const Time & T) const 39 { 40 Time s; //创建一个局部对象，作为返回值 41 s.minitue = minitue - T.minitue; 42 s.hour = hour - T.hour + s.minitue/60; //虽然是减，但是为了以防万一，还是加上这个取整吧 43 s.minitue = s.minitue % 60; 44 45 return s; 46 } 47 48 //对*运算符进行重载 49 Time Time::operator*(double d) const 50 { 51 Time s; //创建一个局部对象，作为返回值 52 long total_time = hour * 60 * d + minitue * d;//这种都hour和minitue都相乘的方法是从书中学到的 53 s.hour = total_time / 60; 54 s.minitue = total_time % 60; 55 56 return s; 57 } 58 59 //只是增加小时，常规类方法 60 void Time::Addhour(int h) 61 { 62 hour = hour + h; 63 } 64 65 //只是增加分钟，常规类方法 66 void Time::Addminitue(int m) 67 { 68 minitue = minitue + m; 69 hour = hour + minitue / 60; //如果增加的分钟数超过了60则对minitue以60为底取整 70 minitue = minitue % 60; //如果增加的分钟数超过了60则对minitue以60为底取余 71 } 72 73 //重置时间,常规类方法 74 void Time::Reset(int h, int m) 75 { 76 hour = h; 77 minitue = m; 78 } 79 80 //友元函数的定义 81 //由于友元函数不是类成员函数，所以不能使用Time::限定符 82 //在友元函数的定义中也不能出现关键字friend 83 //但是友元函数却可以访问Time类中的私有数据和公有数据 84 //Time operator*(double m, const Time & t) //该函数已经在头文件中声明和定义 85 //{ 86 // Time result; 87 // long total_time = t.hour * 60 * m + t.minitue * m; 88 // result.hour = total_time / 60; 89 // result.minitue = total_time % 60; 90 // 91 // return result; 92 //} 93 94 //cout<<trip实现 95 //对<<运算符进行重载的友元函数定义 96 //由于ostream在名称空间std中，所以要使用std::限定符 97 //对于os，将被从主函数传入的实参代替，由于该实参是在转函数中产生，所以operator<<()函数执行完毕后 98 //该实参也存在，所以返回值的类型可以是引用 99 //如果是在一个子函数中创建的局部变量，则返回类型就不能是引用了 100 std::ostream & operator<<(std::ostream & os, Time & t) 101 { 102 os << t.hour << " hours" << t.minitue << " minitues "; 103 return os; 104 } 105 106 //显示对象中的数据 107 void Time::show() 108 { 109 std::cout << "hour= " << hour << " minitue= " << minitue << std::endl; 110 }
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 using std::cout; 11 using std::endl; 12 13 Time s1; //定义一个Time类对象，并用默认构造函数进行初始化 14 Time s2(2, 40); //定义一个Time类对象，并隐式的调用构造函数 15 Time s3(5, 55); //定义一个Time类对象，并隐式的调用构造函数 16 17 std::cout << "使用*运算符重载方法：" << std::endl; 18 s1 = s2 * 2; //等价于s1 = s1.operator*(2); 19 cout << s1; //和使用s1.show()的作用是一样的 20 21 s2.Reset(2,40); //对象s2调用类方法Reset()，并使用实参覆盖掉默认参数 22 23 std::cout << "使用友元函数：" << std::endl; 24 s1 = 2 * s2; //等价于s1 = operator*(2,s2); 25 cout << s1; //和使用s1.show()的作用是一样的 26 27 28 system("pause"); 29 return 0; 30 }
执行结果为：
cin.clear()的用法 m5
我们谈谈cin.clear的作用,第一次看到这东西,很多人以为就是清空cin里面的数据流,而实际上却与此相差很远,首先我们看看以下代码:
#include <iostream> using namespace std; int main() { int a; cin>>a; cout<<cin.rdstate()<<endl; if(cin.rdstate() == ios::goodbit) { cout<<"输入数据的类型正确，无错误！"<<endl; } if(cin.rdstate() == ios_base::failbit) { cout<<"输入数据类型错误，非致命错误，可清除输入缓冲区挽回！"<<endl; } system("pause"); }我们定义要输入到的变量是整型,但如果我们输入了英文字母或者汉字,那就会发生错误,cin里有个方法能检测这个错误,就是cin.rdstate(); 当cin.rdstate()返回0(即ios::goodbit)时表示无错误,可以继续输入或者操作,若返回4则发生非致命错误即ios::failbit,则不能继续输入或操作.而cin.clear则可以控制我们此时cin里对这个问题的一个标识.语发如下: cin.clear(标识符); 标识符号为:
goodbit 无错误
Eofbit 已到达文件尾
failbit 非致命的输入/输出错误，可挽回
badbit 致命的输入/输出错误,无法挽回 若在输入输出类里.需要加ios::标识符号
通过cin.clear,我们能确认它的内部标识符,如果输入错误则能重新输入.结合真正的清空数据流方法cin.sync(),请看下例:
goodbit 无错误
Eofbit 已到达文件尾
failbit 非致命的输入/输出错误，可挽回
badbit 致命的输入/输出错误,无法挽回 若在输入输出类里.需要加ios::标识符号
通过cin.clear,我们能确认它的内部标识符,如果输入错误则能重新输入.结合真正的清空数据流方法cin.sync(),请看下例:
#include <iostream> using namespace std; int main() { int a; while(1) { cin>>a; if(!cin) //条件可改写为cin.fail() { cout<<"输入有错!请重新输入"<<endl; cin.clear(); cin.sync(); //清空流 } else { cout<<a; break; } } system("pause"); }上面的cin.clear()默认参数为0,即无错误,正常操作.当我们输入英文字母'k'时,它的状态标识改为fail,即错误,用cout对用户输出信息,再用cin.clear让错误标识改回为0,让我们可以继续输入,再清空流数据继续输入.如果我们没有了cin.clear,则会进入死循环,其过程为我们输入了英文字母,它的状态标识便为fail,当运行到条件判断时,便总是回到错误的条件表示里,并且我们再也没办法输入,因为错误的表示关闭了cin,所以会进入死循环.
极坐标和直角坐标的相互转换(随机漫步的实现)
/* 总结 */
01)对象是不可以直接调用类中的私有变量的，只能调用公有函数！！
所以加入对象result要使用x值怎么办？result.x是不合法的，所以使用result.xval();
02)使用了名称空间来创建类，或在名称空间中创建类，那么类中的方法定义的时候，一种方法是和h文件中写的一样：使用
namespace VECT{ ... }; 另一种方法就是在cpp文件中使用using声明
03)如果使用using声明，那么定义友元函数的时候，在友元函数名之前是要加上名称空间的名字+双冒号的，否则友元函数
不能访问类中的私有数据
1 //vect.h 2 //极坐标和直角坐标的相互转换 3 4 #ifndef VECTOR_H_ 5 #define VECTOR_H_ 6 7 //定义一个名称空间VECTOR，将类定义放在名称空间中 8 namespace VECTOR 9 { 10 class Vector 11 { 12 public: 13 enum Mode {RECT,POL}; //定义枚举量Mode，可以用Mode去定义变量,例如Mode M; 但是只能用RECT和POL对M赋值 14 private: 15 double x; //直角坐标系的横坐标 16 double y; //直角坐标系的纵坐标 17 double mag; //极坐标系的长度 18 double ang; //极坐标系的角度 19 Mode mode; //用枚举量定义一个枚举变量，mode的值只能是RECT或POL 20 void set_mag(); //设置极坐标系的长度函数 21 void set_ang(); //设置极坐标系的角度函数 22 void set_x(); 23 void set_y(); 24 public: 25 Vector(); //默认构造函数的声明 26 ~Vector(); //析构函数的声明 27 //声明构造函数,n1和n2是传入的直角坐标系或者是极坐标系的坐标,默认是RECT(直角坐标系模式) 28 Vector(double n1, double n2, Mode form = RECT); 29 //声明重置函数，作用类似于析构函数,只不过reset()可以随时使用,而是构函数只有在类创建对象的时候才会被使用 30 void reset(double n1, double n2, Mode form = RECT); 31 //定义返回x、y、mag、ang的值的函数，由于是在类中定义，自动成为内联函数 32 //const放在了函数名括号的后面,表示该函数不可以修改调用该函数对象的参数 33 //对象是不可以直接调用类中的私有变量的，只能调用公有函数！！ 34 //所以加入对象result要使用x值怎么办？result.x是不合法的，所以使用result.xval(); 35 double xval() const { return x; } 36 double yval() const { return y; } 37 double magval() const { return mag; } 38 double angval() const { return ang; } 39 //直角坐标系或者是极坐标系模式的选择 40 void polar_mode(); 41 void rect_mode(); 42 //运算符重载 43 Vector operator+(const Vector & b) const; //第一个Vector表示operator+()函数的返回值为Vector类对象 44 Vector operator-(const Vector & b) const; 45 Vector operator-() const; //对类对象中的数据进行去反操作，即正负的变换 46 Vector operator*(double n) const; 47 //友元函数的声明 48 friend Vector operator*(double n,const Vector & b); 49 friend std::ostream & operator<<(std::ostream & os, const Vector & v); 50 }; 51 } 52 53 #endif 54 55 /* 总结 */ 56 /* 57 01)对象是不可以直接调用类中的私有变量的，只能调用公有函数！！ 58 所以加入对象result要使用x值怎么办？result.x是不合法的，所以使用result.xval(); 59 02)使用了名称空间来创建类，或在名称空间中创建类，那么类中的方法定义的时候，一种方法是和h文件中写的一样：使用 60 namespace VECT{ ... }; 另一种方法就是在cpp文件中使用using声明 61 03)如果使用using声明，那么定义友元函数的时候，在友元函数名之前是要加上名称空间的名字+双冒号的，否则友元函数 62 不能访问类中的私有数据 63 */
1 //vector.cpp 2 #include <iostream> 3 #include <cmath> //for sqrt()、sin()、cos()、atan()、atan()、 4 #include "vect.h" 5 6 7 using VECTOR::Vector; //声明名称空间中的类，以后就可以直接使用类中的方法 8 using std::sqrt; //开根号 9 using std::sin; 10 using std::cos; 11 using std::atan; //atan(x)表示求x的反正切，返回值为[-pi/2,pi/2]区间的一个值,返回弧度值 12 using std::atan2; //atan2(y,x)表示求y/x的正切，返回值为[-pi,pi]区间的一个值,y是纵坐标的值 13 using std::cout; 14 using std::endl; 15 16 //输入的是度数，而程序中要用弧度值，所以需要180/pi,例如将60°转换为弧度值方法为60/rad_to_deg 17 const double rad_to_deg = 180.0 / 3.14; 18 19 //默认构造函数定义 20 Vector::Vector() 21 { 22 x = y = mag = ang = 0; 23 mode = RECT; //刚刚这一句丢了 24 } 25 26 //析构函数定义 27 Vector::~Vector() 28 { 29 30 } 31 32 //构造函数定义 33 Vector::Vector(double n1, double n2, Mode form) 34 { 35 mode = form; 36 if (form == RECT) 37 { 38 x = n1; //将传入的直角坐标系的参数传递给类中的成员变量x和y 39 y = n2; 40 set_mag(); //设置x和y对应的极坐标系中的值 41 set_ang(); 42 } 43 else if (form == POL) 44 { 45 mag = n1; 46 ang = n2 / rad_to_deg; //将度数转换为弧度制 47 set_x(); 48 set_y(); 49 } 50 else 51 { 52 cout << "您输入有误,将坐标系的值全部设置为0" << endl; 53 x = y = mag = ang = 0; 54 } 55 56 } 57 58 //重置函数的定义 这个方法不能用 59 //void Vector::reset(double n1, double n2, Mode f) 60 //{ 61 // Vector(n1, n2, f); //调用构造函数 62 //} 63 void Vector::reset(double n1, double n2, Mode form) 64 { 65 mode = form; 66 if (form == RECT) 67 { 68 x = n1; //将传入的直角坐标系的参数传递给类中的成员变量x和y 69 y = n2; 70 set_mag(); //设置x和y对应的极坐标系中的值 71 set_ang(); 72 } 73 else if (form == POL) 74 { 75 mag = n1; 76 ang = n2 / rad_to_deg; //将度数转换为弧度制 77 set_x(); 78 set_y(); 79 } 80 else 81 { 82 cout << "您输入有误,将坐标系的值全部设置为0" << endl; 83 x = y = mag = ang = 0; 84 } 85 } 86 87 //设置极坐标系的长度函数 88 void Vector::set_mag() 89 { 90 mag = sqrt(x * x + y * y); 91 } 92 void Vector::set_ang() 93 { 94 ang = atan2(y, x); //返回(x,y)的正切值 95 } 96 void Vector::set_x() 97 { 98 x = mag * cos(ang); 99 } 100 void Vector::set_y() 101 { 102 y = mag * sin(ang); 103 } 104 105 //直角坐标系或者是极坐标系模式的选择 106 void Vector::polar_mode() 107 { 108 mode = POL; 109 } 110 void Vector::rect_mode() 111 { 112 mode = RECT; 113 } 114 115 //运算符重载 116 Vector Vector::operator+(const Vector & b) const 117 { 118 //Vector V; //新建一个类对象，作为返回值 119 //V.x = x + b.x; //自己的想法 120 121 return Vector(x + b.x, y + b.y); //调用构造函数，模式选择为默认值RECT 122 //不用去别另外的一个模式，因为在主函数中即使是用RECT模式去减 123 //接下来，RECT模式也会转换为POL模式中的参数的 124 //x和y的值为调用operator+()对象中的数据，b.x为作为实参传入的对象中的数据 125 126 } 127 Vector Vector::operator-(const Vector & b) const 128 { 129 return Vector(x - b.x, y - b.y); //调用构造函数，模式选择为默认值RECT 130 //x和y的值为调用operator-()对象中的数据，b.x为作为实参传入的对象中的数据 131 } 132 Vector Vector::operator-() const 133 { 134 return Vector(-x, -y); 135 //x和y的值为调用operator-()对象中的数据 136 } 137 Vector Vector::operator*(double n) const 138 { 139 return Vector(x*n, y*n); 140 //x和y的值为调用operator-()对象中的数据 141 } 142 143 //友元函数的声明 144 //Vector operator*(double n, const Vector & b) //刚刚没有使用名称空间对operator*()声明，导致b.x出错 145 //如果友元函数在名称空间中，必须要使用名称空间对友元函数的函数名进行声明，否则无法访问类中的数据 146 //还有一个方法是在cpp文件中也将namespace VECTOR{...}，按照h文件中的写法，照样搬过来就可以不用加VECTOR:: 147 Vector VECTOR::operator*(double n, const Vector & b) 148 { 149 return Vector(b.x * n , b.y * n); 150 //return b * n; 151 } 152 std::ostream & VECTOR::operator<<(std::ostream & os, const Vector & v) 153 { 154 if (v.mode == Vector::RECT) 155 os << "(x,y) = " << "(" << v.x << "," << v.y << ") "; 156 else if (v.mode == Vector::POL) 157 os << "(mag,ang) = " << "(" << v.mag << "," << v.ang * rad_to_deg << ") "; //将rad转换为度数 158 else 159 os << "Vector object mode is invalid "; 160 return os; 161 }
1 #include <iostream> 2 #include <ctime> //for time() 3 #include <cstdlib> //for rand()、srand() 4 #include"vect.h" 5 6 int main() 7 { 8 using namespace std; 9 using VECTOR::Vector; 10 11 srand(time(0)); 12 13 Vector step; //使用默认构造函数创建对象，该对象中的数据全部为0，默认为直角坐标系 14 Vector result(0.0, 0.0); //隐式的调用构造函数创建对象,并将该对象中的变量设置为0，默认为直角坐标系 15 double direction = 0.0; //走的方向 16 double dstep = 0.0; //每步走的长度 17 double target = 0.0; //要走的长度，该长度为极坐标系中的长度 18 unsigned long steps = 0.0; //定义走的总步数 19 20 cout << "Enter target distance(任意子母键退出): "; 21 while (cin >> target) 22 { 23 cout << "Enter step length: "; 24 if (!(cin >> dstep)) 25 { 26 break; //如果输入的不是数字，那么退出while循环 27 } 28 //对象时不可以直接调用类中的私有变量的，只能调用公有函数！！ 29 while (result.magval() < target) 30 { 31 direction = rand() % 360; //防止随机数大于360出现的情况 32 step.reset(dstep, direction, Vector::POL); //重置step对象在的数据 33 result = result + step; 34 /*steps++;*/ //走的总步数 35 cout << steps++ << endl; 36 cout << result.magval() << endl; 37 } 38 cout << "After " << steps << " steps, 对象到达了如下坐标(直角坐标系)："; 39 cout << result << endl; //输出对象result中的数据，默认result对象的模式为RECT(直角坐标系) 40 result.polar_mode(); //设置result对象的模式为极坐标系POL 41 cout << "或者在极坐标系下的坐标为：" << endl; 42 cout << result << endl; //极坐标系下输出 43 44 cout << "平均每步走的距离为：" << result.magval() / steps << endl; 45 46 //重置变量，为下一次循环做准备 47 steps = 0; 48 result.reset(0.0, 0.0); 49 cout << "Enter target distance(任意子母键退出): "; 50 } 51 52 cout << "Bye! "; 53 cin.clear(); 54 while (cin.get() != ' ') 55 continue; 56 system("pause"); 57 return 0; 58 }
---恢复内容结束---
目录
用类方法合并另个时间&运算符重载(涉及到函数返回值能不能是引用的问题)
用类方法合并另个时间的代码如下：
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 #endif
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 }
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 */
/* 总结 */
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 */
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 }
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 */
执行结果为：
友元函数
01)问题的提出：
对于上一个代码中的对*的函数重载中 Time operator*(double d) const;
对Time对象s1和s2，以及一个double值2.1
使用方法只能是s1 = s2*2.1;//实际上是调用对*的重载函数：s1=s2.operator(2.1);
所以s1 = 2.1*s2; 是会报错的
02)解决方法：
A 写注释：告诉每个人只能按照s2*2.1这种方式去写，不能写成2.1*s2
B 使用非成员函数，非成员函数不是由对象调用的，它使用的值都必须是由实参的形式传入的
但是也引发了一个新问题：非成员函数不能访问私有数据。最终的解决方法是使用友元函数
此处引入友元函数的目的是实现乘法的交换律
C 友元函数是一种介于类非成员函数和类成员函数之间的一种函数，友元函数不是类成员函数，但是可以访问类私有数据(拥有 类成员函数的权限)
03)友元函数的声明方法：使用关键字friend
friend Time operator*(doubla m,const Time & t);//该友元函数同时对*运算符进行了重载
该声明意味着下面两点：
A 虽然operator*()是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用； ***
B 虽然operatir*()不是成员函数，但它有成员函数的访问权限。(可以访问私有数据) ***
04)友元函数的定义方法：不用使用关键字friend，因为它不是成员函数，所以也不用使用Time::限定符
Time operator*(double m, Time & t) const
{
Time result;
long total_time = t.hour * m + t.minitue * m;
result.hour = total_time / 60;
result.minitue = total_time % 60;
return result;
}
05)友元函数调用方法：
有了友元函数之后，就可以直接使用 s1 = 2.1*s2;
编译器将s1 = 2.1*s2;转换成s1 = operator*(2.1,s2);友元函数版本
06)稍作修改，就可以将友元函数改变成非友元函数：
//在该非友元函数中调用对*的重载函数
Time operator*(double m, Time & t) const
{
return t*m; //即实际调用的函数为 t.operator*(m)，即调用的函数是对*的重载的函数
//原来的版本是显式的访问t.hour和t.minitue.由于这里是将对象t整体使用的,所以t*m将调用对*的重载函数
}
07)总结：
如果在类声明中即声明了对*的重载函数Time operator*(double d) const;
在类声明在又声明了友元函数：friend Time operator*(doubla m,const Time & t);
该友元函数同时对*运算符进行了重载，那么在主函数中就可以使用下面的两种方式
s1 = s2 * 2.1; //调用对*的重载函数，编译器将其转换为s1 = s2.operator(2.1);
s1 = 2.1 * s2; //调用友元函数，编译器将其转换为:s1 = operator(2.1,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; 16 Time operator-(const Time & T) const; //两个const可有可无 17 Time operator*(double d) const; //最后一个const还是表明不能修改调用operator*()方法的对象中的数据 18 friend Time operator*(double m, const Time & t); //声明一个友元函数,只允许中声明的时候使用friend关键字 19 void Addhour(int h); //单独的增加小时 20 void Addminitue(int m); //单独的增加分钟 21 void Reset(int h=0, int m=0); //重置时间 22 void show(); 23 }; 24 25 #endif 26 27 28 /* 友元函数 */ 29 /* 30 01)问题的提出： 31 对于上一个代码中的对*的函数重载中 Time operator*(double d) const; 32 对Time对象s1和s2，以及一个double值2.1 33 使用方法只能是s1 = s2*2.1;//实际上是调用对*的重载函数：s1=s2.operator(2.1); 34 所以s1 = 2.1*s2; 是会报错的 35 02)解决方法： 36 A 写注释：告诉每个人只能按照s2*2.1这种方式去写，不能写成2.1*s2 37 B 使用非成员函数，非成员函数不是由对象调用的，它使用的值都必须是由实参的形式传入的 38 但是也引发了一个新问题：非成员函数不能访问私有数据。最终的解决方法是使用友元函数 39 03)友元函数的声明方法：使用关键字friend 40 friend Time operator*(doubla m,const Time & t);//该友元函数同时对*运算符进行了重载 41 该声明意味着下面两点： 42 A 虽然operator*()是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用； 43 B 虽然operatir*()不是成员函数，但它有成员函数的访问权限。(可以访问私有数据) 44 04)友元函数的定义方法：不用使用关键字friend，因为它不是成员函数，所以也不用使用Time::限定符 45 Time operator*(double m, Time & t) const 46 { 47 Time result; 48 long total_time = t.hour * m + t.minitue * m; 49 result.hour = total_time / 60; 50 result.minitue = total_time % 60; 51 return result; 52 } 53 05)友元函数调用方法： 54 有了友元函数之后，就可以直接使用 s1 = 2.1*s2; 55 编译器将s1 = 2.1*s2;转换成s1 = operator*(2.1,s2);友元函数版本 56 06)稍作修改，就可以将友元函数改变成非友元函数： 57 //在该非友元函数中调用对*的重载函数 58 Time operator*(double m, Time & t) const 59 { 60 return t*m; 61 //原来的版本是显式的访问t.hour和t.minitue.由于这里是将对象t整体使用的,所以t*m将调用对*的重载函数 62 //即实际调用的函数为 t.operator*(m) 63 } 64 07)总结： 65 如果在类声明中即声明了对*的重载函数Time operator*(double d) const; 66 在类声明在又声明了友元函数：friend Time operator*(doubla m,const Time & t); 67 该友元函数同时对*运算符进行了重载，那么在主函数中就可以使用下面的两种方式 68 s1 = s2 * 2.1; //调用对*的重载函数，编译器将其转换为s1 = s2.operator(2.1); 69 s1 = 2.1 * s2; //调用友元函数，编译器将其转换为:s1 = operator(2.1,s2); 70 即实现了乘法的交换律。 71 */
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 //由于友元函数不是类成员函数，所以不能使用Time::限定符 87 //在友元函数的定义中也不能出现关键字friend 88 //但是友元函数却可以访问Time类中的私有数据和公有数据 89 Time operator*(double m, const Time & t) 90 { 91 Time result; 92 long total_time = t.hour * 60 * m + t.minitue * m; 93 result.hour = total_time / 60; 94 result.minitue = total_time % 60; 95 96 return result; 97 } 98 99 //显示对象中的数据 100 void Time::show() 101 { 102 std::cout << "hour= " << hour << " minitue= " << minitue << std::endl; 103 }
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 * 2; //等价于s1 = s1.operator*(2); 16 s1.show(); 17 18 s2.Reset(2,40); //对象s2调用类方法Reset()，并使用实参覆盖掉默认参数 19 20 std::cout << "使用友元函数：" << std::endl; 21 s1 = 2 * s2; //等价于s1 = operator*(2,s2); 22 s1.show(); 23 24 25 system("pause"); 26 return 0; 27 }
执行结果为：
对<<运算符的重载&友元函数
01)问题的提出：
在以前的程序版本中，加入要为显示一个Time对象trip的值，我们都是用的一个类方法show()，对象调用类方法
的方式为trip.show()。能不能用cout<<trip;呢，答案是可以的，因为<<也是C++运算符之一
02)运算符<<的历史和cout对象的相关介绍
最初<<运算符是c和c++位运算符，将值中的位左移。ostream类对该运算符进行了重载，将其转换为一个输出工具。
而cout又是类ostream的一个对象，能够识别C++基本类型。这是因为对于每种C++基本类型，ostream类声明中
都包含了相应的重载operator<<()定义。也就是说，一个定义使用int型参数，一个定义使用double型参数，一个定义
使用char型参数等等。因此要让cout能够识别TIme对象，一种方法是将一个新的函数运算符定义添加到ostream
类声明中，但修改ostream类是一个坏主意；一种方法是让Time知道任何使用cout，即在Time中声明对<<的重载函数
03)那么在Time类中声明友元函数还是非友元函数？
如果是声明常规的类方法，则在<<运算符的左边一定是一个Time对象，那么输出就是下面的那样了：
trip<<cout; //这样显然是不合适的
所以要使用友元函数：
void operator<<(ostream & os, const Time & t) //其中ostream是一个类
{
os << t.hour <<" hours" << t.minitue <<"minitues
";
}
这样就可以使用下面的语句了：
cout<<trip; //显示对象trip中的数据了
调用cout<<trip应使用cout对象本身，而不是cout的副本，因此应该使用ostream & os以用，而不是按值传递
Time对象可以按值传递或者是按引用传递，按引用传递比按值传递使用的时间和内存都要少，因此使用按引用传递。
04)改进
很显然，上面对<<重载友元函数对于下面这样的语句是无能为力的：
cout<<"Trip time: "<<trip<<"(Tuesday)
";
05)解决方法：让cout<<"Trip time: "返回一个cout即可解决问题。反应在对<<重载友元函数来说就是返回值为
指向ostream对象的引用即可，即下面改进的对<<重载友元函数版本：
ostream & operator<<(ostream & os, const Time & t) //其中ostream是一个类
{
os << t.hour <<" hours" << t.minitue <<"minitues
";
return os;
}
注意：返回值不再是void了，而是指向ostream对象的引用
06)上面的这个operator<<()函数版本还可以用于将输出写如到文件中：
#include <fstream> //for ofstream
...
ofstream fout; //创建一个ofstream类对象fout
fout.open("savetime.txt"); //对象fout和一个txt文件关联
Time trip(12,40); //创建一个Time类对象trip，并隐式的调用构造函数初始化trip对象
fout<<trip; //实际调用方式为 operator<<(fout,trip);
1 //mytime.h 2 //包含了operator*()和operatro<<()两个友元函数 3 //将operator*()作为内联函数，因为其代码很短(定义也是原型时，要使用关键字friend) 4 5 #ifndef MYTIME_H_ 6 #define MYTIME_H_ 7 #include <iostream> //这里声明了,在mytime.cpp就只包含mytime.h头文件,便可以提供iostream头文件的支持 8 9 class Time 10 { 11 private: 12 int hour; 13 int minitue; 14 public: 15 Time(); //声明默认构造函数 16 Time(int h, int m); //声明构造函数 17 Time operator+(const Time & T) const; 18 Time operator-(const Time & T) const; //两个const可有可无 19 Time operator*(double d) const; //最后一个const还是表明不能修改调用operator*()方法的对象中的数据 20 friend Time operator*(double m, const Time & t) //即使原型是定义,要使用关键字friend,同时也是内联函数 21 { 22 return t * m; //实际上调用方法为t.operator*(m),即调用对*的重载函数 23 } 24 friend std::ostream & operator<<(std::ostream & os, Time & t);//声明一个对运算符<<重载的友元函数 25 void Addhour(int h); //单独的增加小时 26 void Addminitue(int m); //单独的增加分钟 27 void Reset(int h=0, int m=0); //重置时间 28 void show(); 29 }; 30 31 #endif 32 33 34 /* 友元函数 */ 35 /* 36 01)问题的提出： 37 对于上一个代码中的对*的函数重载中 Time operator*(double d) const; 38 对Time对象s1和s2，以及一个double值2.1 39 使用方法只能是s1 = s2*2.1;//实际上是调用对*的重载函数：s1=s2.operator(2.1); 40 所以s1 = 2.1*s2; 是会报错的 41 02)解决方法： 42 A 写注释：告诉每个人只能按照s2*2.1这种方式去写，不能写成2.1*s2 43 B 使用非成员函数，非成员函数不是由对象调用的，它使用的值都必须是由实参的形式传入的 44 但是也引发了一个新问题：非成员函数不能访问私有数据。最终的解决方法是使用友元函数 45 03)友元函数的声明方法：使用关键字friend 46 friend Time operator*(doubla m,const Time & t);//该友元函数同时对*运算符进行了重载 47 该声明意味着下面两点： 48 A 虽然operator*()是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用； 49 B 虽然operatir*()不是成员函数，但它有成员函数的访问权限。(可以访问私有数据) 50 04)友元函数的定义方法：不用使用关键字friend，因为它不是成员函数，所以也不用使用Time::限定符 51 Time operator*(double m, Time & t) const 52 { 53 Time result; 54 long total_time = t.hour * m + t.minitue * m; 55 result.hour = total_time / 60; 56 result.minitue = total_time % 60; 57 return result; 58 } 59 05)友元函数调用方法： 60 有了友元函数之后，就可以直接使用 s1 = 2.1*s2; 61 编译器将s1 = 2.1*s2;转换成s1 = operator*(2.1,s2);友元函数版本 62 06)稍作修改，就可以将友元函数改变成非友元函数： 63 //在该非友元函数中调用对*的重载函数 64 Time operator*(double m, Time & t) const 65 { 66 return t*m; 67 //原来的版本是显式的访问t.hour和t.minitue.由于这里是将对象t整体使用的,所以t*m将调用对*的重载函数 68 //即实际调用的函数为 t.operator*(m) 69 } 70 07)总结： 71 如果在类声明中即声明了对*的重载函数Time operator*(double d) const; 72 在类声明在又声明了友元函数：friend Time operator*(doubla m,const Time & t); 73 该友元函数同时对*运算符进行了重载，那么在主函数中就可以使用下面的两种方式 74 s1 = s2 * 2.1; //调用对*的重载函数，编译器将其转换为s1 = s2.operator(2.1); 75 s1 = 2.1 * s2; //调用友元函数，编译器将其转换为:s1 = operator(2.1,s2); 76 即实现了乘法的交换律。 77 */ 78 79 /* 对<<运算符的重载&友元函数 */ 80 /* 81 01)问题的提出： 82 在以前的程序版本中，加入要为显示一个Time对象trip的值，我们都是用的一个类方法show()，对象调用类方法 83 的方式为trip.show()。能不能用cout<<trip;呢，答案是可以的，因为<<也是C++运算符之一 84 02)运算符<<的历史和cout对象的相关介绍 85 最初<<运算符是c和c++位运算符，将值中的位左移。ostream类对该运算符进行了重载，将其转换为一个输出工具。 86 而cout又是类ostream的一个对象，能够识别C++基本类型。这是因为对于每种C++基本类型，ostream类声明中 87 都包含了相应的重载operator<<()定义。也就是说，一个定义使用int型参数，一个定义使用double型参数，一个定义 88 使用char型参数等等。因此要让cout能够识别TIme对象，一种方法是将一个新的函数运算符定义添加到ostream 89 类声明中，但修改ostream类是一个坏主意；一种方法是让Time知道任何使用cout，即在Time中声明对<<的重载函数 90 03)那么在Time类中声明友元函数还是非友元函数？ 91 如果是声明常规的类方法，则在<<运算符的左边一定是一个Time对象，那么输出就是下面的那样了： 92 trip<<cout; //这样显然是不合适的 93 所以要使用友元函数： 94 void operator<<(ostream & os, const Time & t) //其中ostream是一个类 95 { 96 os << t.hour <<" hours" << t.minitue <<"minitues "; 97 } 98 这样就可以使用下面的语句了： 99 cout<<trip; //显示对象trip中的数据了 100 调用cout<<trip应使用cout对象本身，而不是cout的副本，因此应该使用ostream & os以用，而不是按值传递 101 Time对象可以按值传递或者是按引用传递，按引用传递比按值传递使用的时间和内存都要少，因此使用按引用传递。 102 04)改进 103 很显然，上面对<<重载友元函数对于下面这样的语句是无能为力的： 104 cout<<"Trip time: "<<trip<<"(Tuesday) "; 105 05)解决方法：让cout<<"Trip time: "返回一个cout即可解决问题。反应在对<<重载友元函数来说就是返回值为 106 指向ostream对象的引用即可，即下面改进的对<<重载友元函数版本： 107 ostream & operator<<(ostream & os, const Time & t) //其中ostream是一个类 108 { 109 os << t.hour <<" hours" << t.minitue <<"minitues "; 110 return os; 111 } 112 注意：返回值不再是void了，而是指向ostream对象的引用 113 06)上面的这个operator<<()函数版本还可以用于将输出写如到文件中： 114 #include <fstream> //for ofstream 115 ... 116 ofstream fout; //创建一个ofstream类对象fout 117 fout.open("savetime.txt"); //对象fout和一个txt文件关联 118 Time trip(12,40); //创建一个Time类对象trip，并隐式的调用构造函数初始化trip对象 119 fout<<trip; //实际调用方式为 operator<<(fout,trip); 120 121 */
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> //可以不包含该头文件了,因为在mytime.h头文件中引用了该头文件,且在本文件中包含了mytime.h头文件 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 37 //对-运算符进行重载 38 Time Time::operator-(const Time & T) const 39 { 40 Time s; //创建一个局部对象，作为返回值 41 s.minitue = minitue - T.minitue; 42 s.hour = hour - T.hour + s.minitue/60; //虽然是减，但是为了以防万一，还是加上这个取整吧 43 s.minitue = s.minitue % 60; 44 45 return s; 46 } 47 48 //对*运算符进行重载 49 Time Time::operator*(double d) const 50 { 51 Time s; //创建一个局部对象，作为返回值 52 long total_time = hour * 60 * d + minitue * d;//这种都hour和minitue都相乘的方法是从书中学到的 53 s.hour = total_time / 60; 54 s.minitue = total_time % 60; 55 56 return s; 57 } 58 59 //只是增加小时，常规类方法 60 void Time::Addhour(int h) 61 { 62 hour = hour + h; 63 } 64 65 //只是增加分钟，常规类方法 66 void Time::Addminitue(int m) 67 { 68 minitue = minitue + m; 69 hour = hour + minitue / 60; //如果增加的分钟数超过了60则对minitue以60为底取整 70 minitue = minitue % 60; //如果增加的分钟数超过了60则对minitue以60为底取余 71 } 72 73 //重置时间,常规类方法 74 void Time::Reset(int h, int m) 75 { 76 hour = h; 77 minitue = m; 78 } 79 80 //友元函数的定义 81 //由于友元函数不是类成员函数，所以不能使用Time::限定符 82 //在友元函数的定义中也不能出现关键字friend 83 //但是友元函数却可以访问Time类中的私有数据和公有数据 84 //Time operator*(double m, const Time & t) //该函数已经在头文件中声明和定义 85 //{ 86 // Time result; 87 // long total_time = t.hour * 60 * m + t.minitue * m; 88 // result.hour = total_time / 60; 89 // result.minitue = total_time % 60; 90 // 91 // return result; 92 //} 93 94 //cout<<trip实现 95 //对<<运算符进行重载的友元函数定义 96 //由于ostream在名称空间std中，所以要使用std::限定符 97 //对于os，将被从主函数传入的实参代替，由于该实参是在转函数中产生，所以operator<<()函数执行完毕后 98 //该实参也存在，所以返回值的类型可以是引用 99 //如果是在一个子函数中创建的局部变量，则返回类型就不能是引用了 100 std::ostream & operator<<(std::ostream & os, Time & t) 101 { 102 os << t.hour << " hours" << t.minitue << " minitues "; 103 return os; 104 } 105 106 //显示对象中的数据 107 void Time::show() 108 { 109 std::cout << "hour= " << hour << " minitue= " << minitue << std::endl; 110 }
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 using std::cout; 11 using std::endl; 12 13 Time s1; //定义一个Time类对象，并用默认构造函数进行初始化 14 Time s2(2, 40); //定义一个Time类对象，并隐式的调用构造函数 15 Time s3(5, 55); //定义一个Time类对象，并隐式的调用构造函数 16 17 std::cout << "使用*运算符重载方法：" << std::endl; 18 s1 = s2 * 2; //等价于s1 = s1.operator*(2); 19 cout << s1; //和使用s1.show()的作用是一样的 20 21 s2.Reset(2,40); //对象s2调用类方法Reset()，并使用实参覆盖掉默认参数 22 23 std::cout << "使用友元函数：" << std::endl; 24 s1 = 2 * s2; //等价于s1 = operator*(2,s2); 25 cout << s1; //和使用s1.show()的作用是一样的 26 27 28 system("pause"); 29 return 0; 30 }
执行结果为：
cin.clear()的用法
我们谈谈cin.clear的作用,第一次看到这东西,很多人以为就是清空cin里面的数据流,而实际上却与此相差很远,首先我们看看以下代码:
#include <iostream> using namespace std; int main() { int a; cin>>a; cout<<cin.rdstate()<<endl; if(cin.rdstate() == ios::goodbit) { cout<<"输入数据的类型正确，无错误！"<<endl; } if(cin.rdstate() == ios_base::failbit) { cout<<"输入数据类型错误，非致命错误，可清除输入缓冲区挽回！"<<endl; } system("pause"); }我们定义要输入到的变量是整型,但如果我们输入了英文字母或者汉字,那就会发生错误,cin里有个方法能检测这个错误,就是cin.rdstate(); 当cin.rdstate()返回0(即ios::goodbit)时表示无错误,可以继续输入或者操作,若返回4则发生非致命错误即ios::failbit,则不能继续输入或操作.而cin.clear则可以控制我们此时cin里对这个问题的一个标识.语发如下: cin.clear(标识符); 标识符号为:
goodbit 无错误
Eofbit 已到达文件尾
failbit 非致命的输入/输出错误，可挽回
badbit 致命的输入/输出错误,无法挽回 若在输入输出类里.需要加ios::标识符号
通过cin.clear,我们能确认它的内部标识符,如果输入错误则能重新输入.结合真正的清空数据流方法cin.sync(),请看下例:
goodbit 无错误
Eofbit 已到达文件尾
failbit 非致命的输入/输出错误，可挽回
badbit 致命的输入/输出错误,无法挽回 若在输入输出类里.需要加ios::标识符号
通过cin.clear,我们能确认它的内部标识符,如果输入错误则能重新输入.结合真正的清空数据流方法cin.sync(),请看下例:
#include <iostream> using namespace std; int main() { int a; while(1) { cin>>a; if(!cin) //条件可改写为cin.fail() { cout<<"输入有错!请重新输入"<<endl; cin.clear(); cin.sync(); //清空流 } else { cout<<a; break; } } system("pause"); }上面的cin.clear()默认参数为0,即无错误,正常操作.当我们输入英文字母'k'时,它的状态标识改为fail,即错误,用cout对用户输出信息,再用cin.clear让错误标识改回为0,让我们可以继续输入,再清空流数据继续输入.如果我们没有了cin.clear,则会进入死循环,其过程为我们输入了英文字母,它的状态标识便为fail,当运行到条件判断时,便总是回到错误的条件表示里,并且我们再也没办法输入,因为错误的表示关闭了cin,所以会进入死循环.极坐标和直角坐标的相互转换(随机漫步的实现)
极坐标和直角坐标的相互转换(随机漫步的实现)
/* 总结 */
01)对象是不可以直接调用类中的私有变量的，只能调用公有函数！！
所以加入对象result要使用x值怎么办？result.x是不合法的，所以使用result.xval();
02)使用了名称空间来创建类，或在名称空间中创建类，那么类中的方法定义的时候，一种方法是和h文件中写的一样：使用
namespace VECT{ ... }; 另一种方法就是在cpp文件中使用using声明
03)如果使用using声明，那么定义友元函数的时候，在友元函数名之前是要加上名称空间的名字+双冒号的，否则友元函数
不能访问类中的私有数据
1 //vect.h 2 //极坐标和直角坐标的相互转换 3 4 #ifndef VECTOR_H_ 5 #define VECTOR_H_ 6 7 //定义一个名称空间VECTOR，将类定义放在名称空间中 8 namespace VECTOR 9 { 10 class Vector 11 { 12 public: 13 enum Mode {RECT,POL}; //定义枚举量Mode，可以用Mode去定义变量,例如Mode M; 但是只能用RECT和POL对M赋值 14 private: 15 double x; //直角坐标系的横坐标 16 double y; //直角坐标系的纵坐标 17 double mag; //极坐标系的长度 18 double ang; //极坐标系的角度 19 Mode mode; //用枚举量定义一个枚举变量，mode的值只能是RECT或POL 20 void set_mag(); //设置极坐标系的长度函数 21 void set_ang(); //设置极坐标系的角度函数 22 void set_x(); 23 void set_y(); 24 public: 25 Vector(); //默认构造函数的声明 26 ~Vector(); //析构函数的声明 27 //声明构造函数,n1和n2是传入的直角坐标系或者是极坐标系的坐标,默认是RECT(直角坐标系模式) 28 Vector(double n1, double n2, Mode form = RECT); 29 //声明重置函数，作用类似于析构函数,只不过reset()可以随时使用,而是构函数只有在类创建对象的时候才会被使用 30 void reset(double n1, double n2, Mode form = RECT); 31 //定义返回x、y、mag、ang的值的函数，由于是在类中定义，自动成为内联函数 32 //const放在了函数名括号的后面,表示该函数不可以修改调用该函数对象的参数 33 //对象是不可以直接调用类中的私有变量的，只能调用公有函数！！ 34 //所以加入对象result要使用x值怎么办？result.x是不合法的，所以使用result.xval(); 35 double xval() const { return x; } 36 double yval() const { return y; } 37 double magval() const { return mag; } 38 double angval() const { return ang; } 39 //直角坐标系或者是极坐标系模式的选择 40 void polar_mode(); 41 void rect_mode(); 42 //运算符重载 43 Vector operator+(const Vector & b) const; //第一个Vector表示operator+()函数的返回值为Vector类对象 44 Vector operator-(const Vector & b) const; 45 Vector operator-() const; //对类对象中的数据进行去反操作，即正负的变换 46 Vector operator*(double n) const; 47 //友元函数的声明 48 friend Vector operator*(double n,const Vector & b); 49 friend std::ostream & operator<<(std::ostream & os, const Vector & v); 50 }; 51 } 52 53 #endif 54 55 /* 总结 */ 56 /* 57 01)对象是不可以直接调用类中的私有变量的，只能调用公有函数！！ 58 所以加入对象result要使用x值怎么办？result.x是不合法的，所以使用result.xval(); 59 02)使用了名称空间来创建类，或在名称空间中创建类，那么类中的方法定义的时候，一种方法是和h文件中写的一样：使用 60 namespace VECT{ ... }; 另一种方法就是在cpp文件中使用using声明 61 03)如果使用using声明，那么定义友元函数的时候，在友元函数名之前是要加上名称空间的名字+双冒号的，否则友元函数 62 不能访问类中的私有数据 63 */
1 //vector.cpp 2 #include <iostream> 3 #include <cmath> //for sqrt()、sin()、cos()、atan()、atan()、 4 #include "vect.h" 5 6 7 using VECTOR::Vector; //声明名称空间中的类，以后就可以直接使用类中的方法 8 using std::sqrt; //开根号 9 using std::sin; 10 using std::cos; 11 using std::atan; //atan(x)表示求x的反正切，返回值为[-pi/2,pi/2]区间的一个值,返回弧度值 12 using std::atan2; //atan2(y,x)表示求y/x的正切，返回值为[-pi,pi]区间的一个值,y是纵坐标的值 13 using std::cout; 14 using std::endl; 15 16 //输入的是度数，而程序中要用弧度值，所以需要180/pi,例如将60°转换为弧度值方法为60/rad_to_deg 17 const double rad_to_deg = 180.0 / 3.14; 18 19 //默认构造函数定义 20 Vector::Vector() 21 { 22 x = y = mag = ang = 0; 23 mode = RECT; //刚刚这一句丢了 24 } 25 26 //析构函数定义 27 Vector::~Vector() 28 { 29 30 } 31 32 //构造函数定义 33 Vector::Vector(double n1, double n2, Mode form) 34 { 35 mode = form; 36 if (form == RECT) 37 { 38 x = n1; //将传入的直角坐标系的参数传递给类中的成员变量x和y 39 y = n2; 40 set_mag(); //设置x和y对应的极坐标系中的值 41 set_ang(); 42 } 43 else if (form == POL) 44 { 45 mag = n1; 46 ang = n2 / rad_to_deg; //将度数转换为弧度制 47 set_x(); 48 set_y(); 49 } 50 else 51 { 52 cout << "您输入有误,将坐标系的值全部设置为0" << endl; 53 x = y = mag = ang = 0; 54 } 55 56 } 57 58 //重置函数的定义 这个方法不能用 59 //void Vector::reset(double n1, double n2, Mode f) 60 //{ 61 // Vector(n1, n2, f); //调用构造函数 62 //} 63 void Vector::reset(double n1, double n2, Mode form) 64 { 65 mode = form; 66 if (form == RECT) 67 { 68 x = n1; //将传入的直角坐标系的参数传递给类中的成员变量x和y 69 y = n2; 70 set_mag(); //设置x和y对应的极坐标系中的值 71 set_ang(); 72 } 73 else if (form == POL) 74 { 75 mag = n1; 76 ang = n2 / rad_to_deg; //将度数转换为弧度制 77 set_x(); 78 set_y(); 79 } 80 else 81 { 82 cout << "您输入有误,将坐标系的值全部设置为0" << endl; 83 x = y = mag = ang = 0; 84 } 85 } 86 87 //设置极坐标系的长度函数 88 void Vector::set_mag() 89 { 90 mag = sqrt(x * x + y * y); 91 } 92 void Vector::set_ang() 93 { 94 ang = atan2(y, x); //返回(x,y)的正切值 95 } 96 void Vector::set_x() 97 { 98 x = mag * cos(ang); 99 } 100 void Vector::set_y() 101 { 102 y = mag * sin(ang); 103 } 104 105 //直角坐标系或者是极坐标系模式的选择 106 void Vector::polar_mode() 107 { 108 mode = POL; 109 } 110 void Vector::rect_mode() 111 { 112 mode = RECT; 113 } 114 115 //运算符重载 116 Vector Vector::operator+(const Vector & b) const 117 { 118 //Vector V; //新建一个类对象，作为返回值 119 //V.x = x + b.x; //自己的想法 120 121 return Vector(x + b.x, y + b.y); //调用构造函数，模式选择为默认值RECT 122 //不用去别另外的一个模式，因为在主函数中即使是用RECT模式去减 123 //接下来，RECT模式也会转换为POL模式中的参数的 124 //x和y的值为调用operator+()对象中的数据，b.x为作为实参传入的对象中的数据 125 126 } 127 Vector Vector::operator-(const Vector & b) const 128 { 129 return Vector(x - b.x, y - b.y); //调用构造函数，模式选择为默认值RECT 130 //x和y的值为调用operator-()对象中的数据，b.x为作为实参传入的对象中的数据 131 } 132 Vector Vector::operator-() const 133 { 134 return Vector(-x, -y); 135 //x和y的值为调用operator-()对象中的数据 136 } 137 Vector Vector::operator*(double n) const 138 { 139 return Vector(x*n, y*n); 140 //x和y的值为调用operator-()对象中的数据 141 } 142 143 //友元函数的声明 144 //Vector operator*(double n, const Vector & b) //刚刚没有使用名称空间对operator*()声明，导致b.x出错 145 //如果友元函数在名称空间中，必须要使用名称空间对友元函数的函数名进行声明，否则无法访问类中的数据 146 //还有一个方法是在cpp文件中也将namespace VECTOR{...}，按照h文件中的写法，照样搬过来就可以不用加VECTOR:: 147 Vector VECTOR::operator*(double n, const Vector & b) 148 { 149 return Vector(b.x * n , b.y * n); 150 //return b * n; 151 } 152 std::ostream & VECTOR::operator<<(std::ostream & os, const Vector & v) 153 { 154 if (v.mode == Vector::RECT) 155 os << "(x,y) = " << "(" << v.x << "," << v.y << ") "; 156 else if (v.mode == Vector::POL) 157 os << "(mag,ang) = " << "(" << v.mag << "," << v.ang * rad_to_deg << ") "; //将rad转换为度数 158 else 159 os << "Vector object mode is invalid "; 160 return os; 161 }
1 #include <iostream> 2 #include <ctime> //for time() 3 #include <cstdlib> //for rand()、srand() 4 #include"vect.h" 5 6 int main() 7 { 8 using namespace std; 9 using VECTOR::Vector; 10 11 srand(time(0)); 12 13 Vector step; //使用默认构造函数创建对象，该对象中的数据全部为0，默认为直角坐标系 14 Vector result(0.0, 0.0); //隐式的调用构造函数创建对象,并将该对象中的变量设置为0，默认为直角坐标系 15 double direction = 0.0; //走的方向 16 double dstep = 0.0; //每步走的长度 17 double target = 0.0; //要走的长度，该长度为极坐标系中的长度 18 unsigned long steps = 0.0; //定义走的总步数 19 20 cout << "Enter target distance(任意子母键退出): "; 21 while (cin >> target) 22 { 23 cout << "Enter step length: "; 24 if (!(cin >> dstep)) 25 { 26 break; //如果输入的不是数字，那么退出while循环 27 } 28 //对象时不可以直接调用类中的私有变量的，只能调用公有函数！！ 29 while (result.magval() < target) 30 { 31 direction = rand() % 360; //防止随机数大于360出现的情况 32 step.reset(dstep, direction, Vector::POL); //重置step对象在的数据 33 result = result + step; 34 /*steps++;*/ //走的总步数 35 cout << steps++ << endl; 36 cout << result.magval() << endl; 37 } 38 cout << "After " << steps << " steps, 对象到达了如下坐标(直角坐标系)："; 39 cout << result << endl; //输出对象result中的数据，默认result对象的模式为RECT(直角坐标系) 40 result.polar_mode(); //设置result对象的模式为极坐标系POL 41 cout << "或者在极坐标系下的坐标为：" << endl; 42 cout << result << endl; //极坐标系下输出 43 44 cout << "平均每步走的距离为：" << result.magval() / steps << endl; 45 46 //重置变量，为下一次循环做准备 47 steps = 0; 48 result.reset(0.0, 0.0); 49 cout << "Enter target distance(任意子母键退出): "; 50 } 51 52 cout << "Bye! "; 53 cin.clear(); 54 while (cin.get() != ' ') 55 continue; 56 system("pause"); 57 return 0; 58 }
将double、int等数据类型赋值给类对象
01)以前声明对象并使用构造函数对其进行初始化的方法：
Stonewt blossem(132.5); //使用一个参数的构造函数对对象blossem进行初始化
Stonewt blossem = Stonewt(132.5); //显式的调用构造函数对类对象进行初始化
Stonewt buttercup(10, 2); //使用两个参数的构造函数对对象buttercup进行初始化
Stonewt bubbles; //使用默认构造函数对bubbles进行初始化
02)如果一个参数的构造函数创建了类对象，那么该对象可以接受一个double型、int型等数据类型对其进行赋值，如：
Stonewt myCat; //声明一个对象
myCat = 19.6; //使用一个数对类对象进行赋值，前提是该类中得有只有一个形参的构造函数
//以上代码使用Stonewt(double lbs)创建一个类对象，并将19.6作为初始值。这一过程是自动进行的，即隐式的
03)使用explicit来声明只有一个形参的构造函数，目的是防止意外的类型转换。如：
explicit Stonewt(double lbs); //这将关闭上边的隐式转换
Stonewt myCat;
myCat = 19.6; //此时是不合法的，因为使用了关键字explicit声明只有一个形参的构造函数
myCat = Stonewt(19.6); //合法，显式的进行类型强制转换
myCat = Stonewt(7000); //合法，先将7000转换为double类型，然后进行强制转换
myCat = (Stonewt)19.6; //合法，老式的方法
04)如果使用了关键字explicit声明构造函数，那么该构造函数就只能用来进行显式强制转换
05)如果类方法中定义了一个下面的带一个参数的构造函数：
Stonewt(double lbs);
那么再定义一个下面的只带一个参数的构造函数是不允许的：
Stonewt(long lbs);
1 #ifndef STONEWT_H_ 2 #define STONEWT_H_ 3 4 class Stonewt 5 { 6 private: 7 enum { Lbs_per_Stn = 14 }; //用枚举的方法定义一个常量,14后面不用加分号 8 int stone; 9 double pds_left; 10 double pounds; 11 public: 12 Stonewt(double lbs); //声明一个参数的构造函数 13 Stonewt(int stn, double lbs); //声明两个参数的构造函数 14 Stonewt(); //声明默认构造函数 15 ~Stonewt(); //声明析构函数 16 void show_lbs() const; 17 void show_stn() const; 18 }; 19 20 #endif 21 22 /* 将double、int等数据类型赋值给类对象 */ 23 /* 24 01)以前声明对象并使用构造函数对其进行初始化的方法： 25 Stonewt blossem(132.5); //使用一个参数的构造函数对对象blossem进行初始化 26 Stonewt blossem = Stonewt(132.5); //显式的调用构造函数对类对象进行初始化 27 Stonewt buttercup(10, 2); //使用两个参数的构造函数对对象buttercup进行初始化 28 Stonewt bubbles; //使用默认构造函数对bubbles进行初始化 29 02)如果一个参数的构造函数创建了类对象，那么该对象可以接受一个double型、int型等数据类型对其进行赋值，如： 30 Stonewt myCat; //声明一个对象 31 myCat = 19.6; //使用一个数对类对象进行赋值，前提是该类中得有只有一个形参的构造函数 32 //以上代码使用Stonewt(double lbs)创建一个类对象，并将19.6作为初始值。这一过程是自动进行的，即隐式的 33 03)使用explicit来声明只有一个形参的构造函数，目的是防止意外的类型转换。如： 34 explicit Stonewt(double lbs); //这将关闭上边的隐式转换 35 36 Stonewt myCat; 37 myCat = 19.6; //此时是不合法的，因为使用了关键字explicit声明只有一个形参的构造函数 38 myCat = Stonewt(19.6); //合法，显式的进行类型强制转换 39 myCat = Stonewt(7000); //合法，先将7000转换为double类型，然后进行强制转换 40 myCat = (Stonewt)19.6; //合法，老式的方法 41 04)如果使用了关键字explicit声明构造函数，那么该构造函数就只能用来进行显式强制转换 42 05)如果类方法中定义了一个下面的带一个参数的构造函数： 43 Stonewt(double lbs); 44 那么再定义一个下面的只带一个参数的构造函数是不允许的： 45 Stonewt(long lbs); 46 05) 47 48 */
1 //stonewt.cpp 2 #include <iostream> 3 #include "stonewt.h" 4 5 using std::cout; 6 using std::endl; 7 8 //接受一个参数的构造函数 9 //可以使用数字对类对象进行初始化，即： 10 //Stonewt myCat; 11 //myCat=19.6; //该句表明，上句是使用只有一个形参的构造函数创建的对象 12 Stonewt::Stonewt(double lbs) 13 { 14 stone = int(lbs) / Lbs_per_Stn; 15 pds_left = int(lbs) % Lbs_per_Stn; 16 pounds = lbs; 17 } 18 19 //接受一个参数的构造函数(使用关键字explicit) 20 //可以使用数字对类对象进行初始化，即： 21 //Stonewt myCat = Stonewt(19.6); //使用关键字explicit之后，就只能只有初始化对象 22 /*explicit Stonewt::Stonewt(double lbs) 23 { 24 stone = int(lbs) / Lbs_per_Stn; 25 pds_left = int(lbs) % Lbs_per_Stn; 26 pounds = lbs; 27 }*/ 28 29 //接受两个参数的构造函数 30 Stonewt::Stonewt(int stn, double lbs) 31 { 32 stone = stn; 33 pds_left = lbs; 34 pounds = stn * Lbs_per_Stn + lbs; 35 } 36 37 //默认构造函数 38 Stonewt::Stonewt() 39 { 40 stone = pounds = pds_left = 0; 41 } 42 43 //析构函数 44 Stonewt::~Stonewt() 45 { 46 47 } 48 49 //普通类方法 50 void Stonewt::show_stn() const 51 { 52 cout << stone << " stone, " << pds_left << " pounds" << endl; 53 } 54 void Stonewt::show_lbs() const 55 { 56 cout << pounds << " pounds" << endl; 57 }
1 //user_main,cpp 2 #include <iostream> 3 #include "stonewt.h" 4 5 using std::cout; 6 using std::endl; 7 8 void display(const Stonewt & st, int n);//第一个形参可以接受Stonewt对象或者是数字都可以 9 //如果第一个形参接受的实参为一个数字，在这里也是允许的，即： 10 // Stonewt & st = 422; 类似于Stonewt st=422; //使用接受一个参数的构造函数对st进行初始化 11 12 int main() 13 { 14 Stonewt incognito = 275; //先对275转换成double型，然后再用接受一个参数的构造函数对类对象进行初始化 15 //Stonewt(double lbs)即lbs=275 16 Stonewt wolfe(285.7); //以前初始化对象的方法，等价于Stonewt wolfe = 285.7; 17 Stonewt taft(21, 8); //使用接受两个参数的构造函数对类对象进行初始化 18 //Stonewt(int stn, double lbs)即stn=21,lbs=8 19 20 cout << "The celebrity weighted "; 21 incognito.show_stn(); 22 23 cout << "The detective weighted "; 24 wolfe.show_stn(); 25 26 cout << "The president weighted "; 27 taft.show_stn(); 28 29 incognito = 276.8; //同样是调用Stonewt(double lbs)构造函数，对类对象进行重新初始化 30 taft = 325; //调用Stonewt(double lbs)构造函数，对类对象taft进行重新初始化,虽然他taft不是使用接受一个参数的构造函数创建的 31 32 display(taft, 2); //display()第一个形参指向taft对象 33 display(422, 2); //display()第一个实参为数字，也是可以的，只是在类对象初始化是可以的 34 35 36 system("pause"); 37 return 0; 38 } 39 40 void display(const Stonewt & st, int n) 41 { 42 for (int i = 0; i < n; i++) 43 { 44 cout << "Wow! "; 45 st.show_stn(); 46 } 47 } 48 49 /* 总结 */ 50 /* 51 01)如果类中有只有一个参数的构造函数，那么下面的引用的用法是可以的 52 Stonewt & st = 422; //类似于Stonewt st=422; 使用接受一个参数的构造函数对st进行初始化 53 编译器会将该数字(422)通过Stonewt(double lbs)构造函数，编程Stonewt对象，然后 再赋给引用st 54 02)类对象使用数字对其进行初始化了之后，允许以后再次使用数字对其进行初始化，如下： 55 incognito = 276.8; 56 */
/* 总结 */
01)如果类中有只有一个参数的构造函数，那么下面的引用的用法是可以的
Stonewt & st = 422; //类似于Stonewt st=422; 使用接受一个参数的构造函数对st进行初始化
编译器会将该数字(422)通过Stonewt(double lbs)构造函数，编程Stonewt对象，然后 再赋给引用st
02)类对象使用数字对其进行初始化了之后，允许以后再次使用数字对其进行初始化，如下：
incognito = 276.8;
将类对象赋值给double、int等型的变量 m8
01)问题的提出：
上一节中提到了可以将double、int型的数据赋值给类对象，那么反过来呢？
即：Stonewt wolfe(285.7);
double host = wolfe; //这样也是可以的，只不过得在类中声明转换函数
02)转换函数的声明方法：
operator typeName(); //typeName为要转换成的数据类型，如double、int等
如：operator double(); //声明由类对象转换成double型数据的类方法
注意以下几点：
A 转换函数是类方法
B 转换函数不能指定返回类型且没有任何的参数
03)转换函数的定义方法：(由于转换函数是类方法，所以在定义时必须使用类限定符Stonewt::)
Stonewt::operator double()
{ return pounds;} //一般是在函数体中返回一直类中的私有变量
04)转换函数的使用方法：
Stonewt wolfe(285.7);
double host = wolfe; //隐式的调用转换函数
double host = double(wolfe) //显式的调用转换函数
需要注意的是，如果定义了多个转换函数：
operator int(); //#1
operator double(); //#2
隐式的调用转换函数是不合法的，因为编译器不知道是调用#1还是调用#2,从而产生二义性，产生报错
05)原则上说最好使用显式转换，为此，C++提供了关键字explicit用于转换函数，如：
explicit operator double(); //不能使用隐式的调用该函数,必须使用显式的转换方法
explicit operator int(); //同理
即：
Stonewt wolfe(285.7);
double host = wolfe; //如果转换函数前加了关键字explicit，隐式的调用转换函数是不合法的
double host = double(wolfe) //显式的调用转换函数，合法
定义的时候使用如下方法：
explicit Stonewt::operator int() //注意explicit的位置
{ return pounds; }
06)除了使用转换函数，我们也可以使用类方法去实现将类对象赋值给常规变量
即下面两种方法是等价的：
explicit Stonewt::operator int() //定义转换函数实现将类对象赋值给常规变量
{ return pounds; }
double Stonewt::Stone_to_double() //定义方法实现将类对象赋值给常规变量
{ return double(pounds);}
第一种方法的调用方法是：
Stonewt wolfe(285.7);
double host = double(wolfe) //显式的调用转换函数，合法
第二种方法的调用方法是：
Stonewt wolfe(285.7);
double wo = wolfe.Stone_to_double(); //类对象wolfe调用类方法Stone_to_double()