第11章 使用类

1.简单的操作符重载范例

要重载操作符，需使用被称为操作符函数的特殊函数形式。操作符函数格式如下：

operator op(argument-list)

// mytime2.h -- Time class after operator overloading #ifndef MYTIME2_H_ #define MYTIME2_H_ class Time { private: int hours; int minutes; public: Time(); Time(int h, int m = 0); void AddMin(int m); void AddHr(int h); void Reset(int h = 0, int m = 0); Time operator+(const Time & t) const; Time operator-(const Time & t) const; Time operator*(double n) const; void Show() const; }; #endif

// mytime2.cpp -- implementing Time methods #include <iostream> #include "mytime2.h" Time::Time() { hours = minutes = 0; } Time::Time(int h, int m ) { hours = h; minutes = m; } void Time::AddMin(int m) { minutes += m; hours += minutes / 60; minutes %= 60; } void Time::AddHr(int h) { hours += h; } void Time::Reset(int h, int m) { hours = h; minutes = m; } Time Time::operator+(const Time & t) const { Time sum; sum.minutes = minutes + t.minutes; sum.hours = hours + t.hours + sum.minutes / 60; sum.minutes %= 60; return sum; } Time Time::operator-(const Time & t) const { Time diff; int tot1, tot2; tot1 = t.minutes + 60 * t.hours; tot2 = minutes + 60 * hours; diff.minutes = (tot2 - tot1) % 60; diff.hours = (tot2 - tot1) / 60; return diff; } Time Time::operator*(double mult) const { Time result; long totalminutes = hours * mult * 60 + minutes * mult; result.hours = totalminutes / 60; result.minutes = totalminutes % 60; return result; } void Time::Show() const { std::cout << hours << " hours, " << minutes << " minutes"; }

// usetime2.cpp -- using the third draft of the Time class // compile usetime2.cpp and mytime2.cpp together #include <iostream> #include "mytime2.h" int main() { using std::cout; using std::endl; Time weeding(4, 35); Time waxing(2, 47); Time total; Time diff; Time adjusted; cout << "weeding time = "; weeding.Show(); cout << endl; cout << "waxing time = "; waxing.Show(); cout << endl; cout << "total work time = "; total = weeding + waxing; // use operator+() total.Show(); cout << endl; diff = weeding - waxing; // use operator-() cout << "weeding time - waxing time = "; diff.Show(); cout << endl; adjusted = total * 1.5; // use operator+() cout << "adjusted work time = "; adjusted.Show(); cout << endl; return 0; }

2.C++对操作符重载的限制

1）重载后的操作符必须至少有一个操作数是用户定义的类型，这将防止用户为标准类型重载操作符。

2）使用操作符时不能违反操作符原来的句法规则，如：不能将（%）重载成使用一个操作数。同样，不能修改操作符的优先级。

3）不能定义新的操作符。

4）不能重载下面的操作符以及可被重载的操作符：

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091008/1.jpg

5）大多数操作符都可以通过成员或非成员函数进行重载，但下面的操作符只能通过成员函数进行重载。

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091008/2.jpg

3.用友元函数来重载操作符

     初衷：在上面的程序中，从概念上说B*2.75和2.75*B相同，但后一个表达式不对应于成员函数，因为2.75不是Time类型的对象。

     友元函数原型声明前要加关键字friend。但是定义中不要用friend，也不要使用Time::限定符。上面程序的*重载可以写成以下形式：

Time operator* (double m, const Time & t) { Time result; long totalminutes = t.hours*mult*60+t.minutes*mult; result.hours = totalminutes/60; result.minutes = totalminutes%60; return result; }

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091008/3.jpg

4.重载<<操作符

      必须用友元函数。因为trip<<cout;这样将令人迷惑。

      修改后的Time程序：

// mytime3.h -- Time class with friends #ifndef MYTIME3_H_ #define MYTIME3_H_ #include <iostream> class Time { private: ... public: ... Time operator+(const Time & t) const; Time operator-(const Time & t) const; Time operator*(double n) const; friend Time operator*(double m, const Time & t) { return t * m; } // inline definition friend std::ostream & operator<<(std::ostream & os, const Time & t); }; #endif
// mytime3.cpp -- implementing Time methods #include "mytime3.h" std::ostream & operator<<(std::ostream & os, const Time & t) { os << t.hours << " hours, " << t.minutes << " minutes"; return os; }

5.重载操作符作为成员函数还是非成员函数

     非成员函数应是友元函数，这样它才能直接访问类的私有数据。非成员版本的重载操作符函数所需的形参数目与操作符使用的操作符数目相同，而成员版本所需的参数数目少一个，因为其中的一个操作数是被隐式地传递的调用对象。定义操作符时，必须选择其中一种，而不能同时选择。那么哪种格式最好呢？对于某些操作符来说，成员函数是唯一合法的选择，其他情况下，这两种格式没有太大的区别。有时根据类设计，使用非成员版本可能更好（尤其是为类定义类型转换时）。

6.一个矢量类

      注意例子中名字空间的应用

// vect.h -- Vector class with <<, mode state #ifndef VECTOR_H_ #define VECTOR_H_ #include <iostream> namespace VECTOR { class Vector { private: double x; // horizontal value double y; // vertical value double mag; // length of vector double ang; // direction of vector char mode; // 'r' = rectangular, 'p' = polar // private methods for setting values void set_mag(); void set_ang(); void set_x(); void set_y(); public: Vector(); Vector(double n1, double n2, char form = 'r'); void set(double n1, double n2, char form = 'r'); ~Vector(); double xval() const {return x;} // report x value double yval() const {return y;} // report y value double magval() const {return mag;} // report magnitude double angval() const {return ang;} // report angle void polar_mode(); // set mode to 'p' void rect_mode(); // set mode to 'r' // operator overloading Vector operator+(const Vector & b) const; Vector operator-(const Vector & b) const; Vector operator-() const; Vector operator*(double n) const; // friends friend Vector operator*(double n, const Vector & a); friend std::ostream & operator<<(std::ostream & os, const Vector & v); }; } // end namespace VECTOR #endif

// vect.cpp -- methods for Vector class #include <cmath> #include "vect.h" // includes <iostream> using std::cout; namespace VECTOR { const double Rad_to_deg = 57.2957795130823; // private methods // calculates magnitude from x and y void Vector::set_mag() { mag = sqrt(x * x + y * y); } void Vector::set_ang() { if (x == 0.0 && y == 0.0) ang = 0.0; else ang = atan2(y, x); } // set x from polar coordinate void Vector::set_x() { x = mag * cos(ang); } // set y from polar coordinate void Vector::set_y() { y = mag * sin(ang); } // public methods Vector::Vector() // default constructor { x = y = mag = ang = 0.0; mode = 'r'; } // construct vector from rectangular coordinates if form is r // (the default) or else from polar coordinates if form is p Vector::Vector(double n1, double n2, char form) { mode = form; if (form == 'r') { x = n1; y = n2; set_mag(); set_ang(); } else if (form == 'p') { mag = n1; ang = n2 / Rad_to_deg; set_x(); set_y(); } else { cout << "Incorrect 3rd argument to Vector() -- "; cout << "vector set to 0/n"; x = y = mag = ang = 0.0; mode = 'r'; } } // set vector from rectangular coordinates if form is r (the // default) or else from polar coordinates if form is p void Vector:: set(double n1, double n2, char form) { mode = form; if (form == 'r') { x = n1; y = n2; set_mag(); set_ang(); } else if (form == 'p') { mag = n1; ang = n2 / Rad_to_deg; set_x(); set_y(); } else { cout << "Incorrect 3rd argument to Vector() -- "; cout << "vector set to 0/n"; x = y = mag = ang = 0.0; mode = 'r'; } } Vector::~Vector() // destructor { } void Vector::polar_mode() // set to polar mode { mode = 'p'; } void Vector::rect_mode() // set to rectangular mode { mode = 'r'; } // operator overloading // add two Vectors Vector Vector::operator+(const Vector & b) const { return Vector(x + b.x, y + b.y); } // subtract Vector b from a Vector Vector::operator-(const Vector & b) const { return Vector(x - b.x, y - b.y); } // reverse sign of Vector Vector Vector::operator-() const { return Vector(-x, -y); } // multiple vector by n Vector Vector::operator*(double n) const { return Vector(n * x, n * y); } // friend methods // multiply n by Vector a Vector operator*(double n, const Vector & a) { return a * n; } // display rectangular coordinates if mode is r, // else display polar coordinates if mode is p std::ostream & operator<<(std::ostream & os, const Vector & v) { if (v.mode == 'r') os << "(x,y) = (" << v.x << ", " << v.y << ")"; else if (v.mode == 'p') { os << "(m,a) = (" << v.mag << ", " << v.ang * Rad_to_deg << ")"; } else os << "Vector object mode is invalid"; return os; } } // end namespace VECTOR

// randwalk.cpp -- using the Vector class // compile with the vect.cpp file #include <iostream> #include <cstdlib> // rand(), srand() prototypes #include <ctime> // time() prototype #include "vect.h" int main() { using namespace std; using VECTOR::Vector; //important ... return 0; }

7.类的自动转换和强制类型转换

某种类型到类类型的转换：

      接受一个参数的构造函数为将类型与该参数相同的值转换为类提供了蓝图。

      如果有下面的构造函数：Stonewt(double lbs);则可编写这样的代码： Stonewt myCat; myCat=19.6; 程序用构造函数Stonewt(double)来创建一个临时的Stonewt对象，并将19.6作为初始化值。随后，采用逐成员赋值方法将该临时对象的内容复制到myCat中。这一过程称为隐式转换，因为它是自动进行的，不需要显式强制类型转换。只有接受一个参数的构造函数才能作为转换函数。不过，有时候会导致意外的类型转换，C++可以用关键字explicit来关闭这种自动特性。如：explicit Stonewt(double lbs);关闭上述介绍的隐式转换，仍然允许显式强制类型转换：Stonewt myCat; myCat=Stonewt(19.6);myCat=(Stonewt)19.6;

      还有一点，函数原型化提供的参数匹配过程，允许使用Stonewt(double)构造函数来转换其他数值类型。比如Stonewt myCat(7000);首先将int转换为double，然后才使用构造函数。但是，当且仅当转换不存在二义性时，才会进行这种二步转换。比如如果还定义了Stonewt(long)，则编译器将拒绝这些语句，因为不知道将int转换为double还是long。

       再比如有函数void display(const Stonewt & st, int n);而有下面调用代码display(422,2);display()原型表明第一个参数应为Stonewt对象。遇到int参数时，编译器查找Stonewt(int)构造函数，以便将该int转换为Stonewt类型。由于没有找到这样的构造函数，因此编译器寻找接受其他内置类型（int可以转换为这种类型）的构造函数。Stonewt(double)构造函数满足这种要求，因此编译器将int转换为double，然后使用Stonewt(double)将其转换为一个Stonewt对象。

 

类类型到某种类型的转换(转换函数)：

      如何创建转换函数呢？要转换为typeName类型，需要使用这种形式： operator typeName(); 要注意以下几点：转换函数必须是类方法；转换函数不能指定返回类型；转换函数不能有参数。 

// stonewt.h -- definition for the Stonewt class #ifndef STONEWT_H_ #define STONEWT_H_ class Stonewt { private: enum {Lbs_per_stn = 14}; // pounds per stone int stone; // whole stones double pds_left; // fractional pounds double pounds; // entire weight in pounds public: Stonewt(double lbs); // constructor for double pounds Stonewt(int stn, double lbs); // constructor for stone, lbs Stonewt(); // default constructor ~Stonewt(); void show_lbs() const; // show weight in pounds format void show_stn() const; // show weight in stone format }; #endif

// stonewt1.cpp -- Stonewt class methods + conversion functions #include <iostream> using std::cout; #include "stonewt1.h" ...... // conversion functions Stonewt::operator int() const { return int (pounds + 0.5); } Stonewt::operator double()const { return pounds; }

// stone1.cpp -- user-defined conversion functions // compile with stonewt1.cpp #include <iostream> #include "stonewt1.h" int main() { using std::cout; Stonewt poppins(9,2.8); // 9 stone, 2.8 pounds double p_wt = poppins; // implicit conversion cout << "Convert to double => "; cout << "Poppins: " << p_wt << " pounds./n"; cout << "Convert to int => "; cout << "Poppins: " << int (poppins) << " pounds./n"; return 0; }

       如果只是cout<<poppins，由于存在二义性，不知道转换为int还是double。但仍可以用强制类型转换，如long gone=(double)poppins;long gone2=int (poppins);原则上说，最好使用显式转换，而避免隐式转换。explicit不能用于转换函数，但只需要一个功能相同的非转换函数替换该转换函数即可，但仅在被显式地调用时，该函数才会执行。也就是说，可以将：Stonewt::operator int()替换为： int Stonewt::Stonewt_to_Int()。这样，下面语句将是非法的：int plb=poppins;但如果实在需要这种转换，可以这样做：int plb=poppins.Stonewt_to_Int();。

8.在main()之前调用Bootstrap函数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091008/4.jpg