练习代码

由于无法用一个数来表示矢量，因此应该创建一个类来表示矢量。矢量的相加和相减与普通数学运算有相似之处，所以应重载运算符使之能用于矢量。
本节将实现一个二维矢量，描述二维矢量需要有两个数，但有两种方式：

  1. 用长度和角度表示(极坐标)；

  2. 用水平分量 x 和垂直分量 y 表示(直角坐标)。

    1. #ifndef VECTOR_H_
    2. #define VECTOR_H_
    3. #include <iostream>
    4. namespace VECTOR {
    5.  class Vector {
    6.  public:
    7.      enum Mode {
    8.          RECT, // 直角坐标系
    9.          POL   // 极坐标系
    10.      };
    11.  private:
    12.      double x; // 水平坐标
    13.      double y; // 垂直坐标
    14.      double ang; // 角度
    15.      double mag; // 长度
    16.      Mode mode; // 采用的坐标系
    17.      // 设置私有成员的函数
    18.      void setMag(); // 根据 x, y 设置 mag
    19.      void setAng(); // 根据 x, y 设置 ang
    20.      void setX(); // 根据 mag, ang 设置 x
    21.      void setY(); // 根据 mag, ang 设置 y
    22.  public:
    23.      Vector();
    24.      // 构造函数, 默认采用直角坐标系表示法
    25.      Vector(double n1, double n2, Mode form = RECT);
    26.      ~Vector();
    27.      // 重置 Vector 值, 默认采用直角坐标系表示法
    28.      void reset(double n1, double n2, Mode form = RECT);
    29.      double getXVal() const { return x; }
    30.      double getYVal() const { return y; }
    31.      double getAngVal() const { return ang; }
    32.      double getMagVal() const { return mag; }
    33.      void setPolarMode();
    34.      void setRectMode();
    35.      // 重载运算符 —— 成员函数
    36.      Vector operator+(const Vector & vec) const;
    37.      Vector operator-(const Vector & vec) const;
    38.      Vector operator-() const;
    39.      Vector operator*(double d) const;
    40.      // 重载运算符 —— 友元函数
    41.      friend Vector operator*(double d, const Vector & vec);
    42.      friend std::ostream & operator<<(std::ostream & out, const Vector & vec);
    43.  };
    44. } // end namespace VECTOR
    45. #endif // VECTOR_H_
    1. #include "vector.h"
    2. #include <cmath>
    3. namespace VECTOR {
    4.  using std::sqrt;
    5.  using std::sin;
    6.  using std::cos;
    7.  using std::atan;
    8.  using std::atan2;
    9.  using std::cout;
    11.  const double RadToDeg = 45.0 / atan(1.0); // 计算一弧度对应的角度
    13.  /**
    14.   * Private methods
    15.   */
    16.  void Vector::setAng() {
    17.      // 这里其实不应该用 == 的, double 类型的 == 并不准确
    18.      if (x == 0.0 && y == 0.0)
    19.          ang = 0.0;
    20.      else
    21.          ang = atan2(y, x);
    22.  }
    24.  void Vector::setMag() {
    25.      mag = sqrt(x * x + y * y);
    26.  }
    28.  void Vector::setX() {
    29.      x = mag * cos(ang);
    30.  }
    32.  void Vector::setY() {
    33.      y = mag * sin(ang);
    34.  }
    36.  /**
    37.   * Public methods —— Constructor And Destructor
    38.   */
    39.  Vector::Vector() {
    40.      cout << "Default Constructor.\n";
    41.      x = y = ang = mag = 0.0;
    42.      mode = RECT;
    43.  }
    45.  Vector::Vector(double n1, double n2, Mode form) {
    46.      cout << "Constructor. ";
    47.      mode = form;
    48.      if (form == RECT) {
    49.          x = n1;
    50.          y = n2;
    51.          setMag();
    52.          setAng();
    53.      } else if (form == POL) {
    54.          mag = n1;
    55.          ang = n2 / RadToDeg;
    56.          setX();
    57.          setY();
    58.      } else {
    59.          cout << "构造方法 Vector() 的第三个参数是无效的. 对象的值将被设置为 0, 并且采用直角坐标系.";
    60.          x = y = ang = mag = 0.0;
    61.          mode = RECT;
    62.      }
    63.      cout << std::endl;
    64.  }
    66.  Vector::~Vector() {
    67.      cout << "Destructor.\n";
    68.  }
    70.  /**
    71.   * Public Function.
    72.   */
    73.   // 重新设置 vector 的值
    74.  void Vector::reset(double n1, double n2, Mode form) {
    75.      mode = form;
    76.      if (mode == RECT) {
    77.          x = n1;
    78.          y = n2;
    79.          setAng();
    80.          setMag();
    81.      } else if (mode == POL) {
    82.          mag = n1;
    83.          ang = n2 /RadToDeg;
    84.          setX();
    85.          setY();
    86.      } else {
    87.          cout << "reset() 的第三个参数是无效的. 对象的值将被设置为 0, 并且采用直角坐标系.\n";
    88.          x = y = ang = mag = 0.0;
    89.          mode = RECT;
    90.      }
    91.  }
    93.  void Vector::setPolarMode() { mode = RECT; }
    95.  void Vector::setRectMode() { mode = POL; }
    97.  /**
    98.   * Operator overload —— Member Function
    99.   */
    100.  Vector Vector::operator+(const Vector &vec) const {
    101.      return Vector(x + vec.x, y + vec.y, RECT);
    102.  }
    104.  Vector Vector::operator-(const Vector &vec) const {
    105.      return Vector(x - vec.x, y - vec.y, RECT);
    106.  }
    108.  Vector Vector::operator-() const {
    109.      return Vector(-x, -y, RECT);
    110.  }
    112.  Vector Vector::operator*(double d) const {
    113.      return Vector(x * d, y * d, RECT);
    114.  }
    115.  /**
    116.   * Operator overload —— Friend Function
    117.   */
    118.  Vector operator*(double d, const Vector & vec) {
    119.      return vec * d;
    120.  }
    122.  // 如果 mode 是 RECT, 显示直角坐标系的坐标;
    123.  // 如果 mode 是 POL , 显示极坐标系的坐标.
    124.  std::ostream & operator<<(std::ostream & out, const Vector & vec) {
    125.      if (vec.mode == Vector::RECT) {
    126.          out << "(x, y) = (" << vec.x << ", " << vec.y << ")" << std::endl;
    127.      } else if (vec.mode == Vector::POL) {
    128.          out << "(mag, ang) = (" << vec.mag << ", " << vec.ang * RadToDeg << ")\n";
    129.      } else {
    130.          out << "Vector object mode is invalid.\n";
    131.      }
    132.      return out;
    133.  }
    134. }

    也可以以另一种方式来设计这个类。例如，在对象中只存储直角坐标系，不保存极坐标系，在需要用到极坐标系坐标时使用 getAngVal() 和 getMagVal() 来计算极坐标系。

在重载的 +、-、* 运算符的定义中是通过类构造方法来实现的。如果方法通过计算得到一个新的类对象，则应该考虑是否可以使用类构造函数来完成这种工作。这样不仅可以避免麻烦，而且可以确保新的对象是按照正确的方式创建的。

随机漫步问题

using VECTOR::Vector;
using std::cout;
using std::cin;
using std::endl;

srand(time(0)); // 设置种子
Vector result(0, 0, VECTOR::Vector::RECT); // 采用直角坐标系记录当前所在位置
Vector step; // 记录当前随机的矢量
unsigned long steps = 0; // 记录走过的总步数

double target; // 记录目标距离
double dstep; // 记录每一步的步长

cout << "请输入目标距离(按 q 表示退出):";
while (cin >> target) {
    cout << "请输入步长:";
    if (!(cin >> dstep)) {
        cout << "输入的步长无效,程序将退出.";
        break;
    }

    // 如果距离没有达到目标距离, 继续走下一步
    while (result.getMagVal() < target) {
        // 随机生成下一步的方向, 并利用步长和方向按照极坐标系创建实例
        step = Vector(dstep, rand() % 360, Vector::POL);
        // 往 step 指示方向位移一步
        result = result + step;
        // 走的步数+1
        steps++;
    }

    cout << "经过 " << steps << " 步之后到达指定的距离, 当前位置如下所示: " << endl;
    cout << "(x, y) = (" << result.getXVal() << ", " << result.getYVal()
        << ") or (mag, ang) = (" << result.getMagVal() << ", " << result.getAngVal()
        << ")\n";
    cout << "移动的平均步长为: " << result.getMagVal() / steps << endl;

    // 重置步数和当前所在位置
    steps = 0;
    result.reset(0, 0, Vector::RECT);
    cout << "请输入目标距离(按 q 表示退出):";
}
cout << "Bye!\n";
cin.clear();

time(0) 返回当前系统时间，srand(time(0)) 将当前系统时间作为种子值，rand() 函数将根据 srand() 设置的种子值返回一个伪随机数。

该程序使用 result 记录行走者当前的位置情况。内循环每轮将 step 矢量设置新的方向，并将它与当前的 result 矢量相加。当 result 的长度超过指定的距离之后，该循环结束。

result = result + step;这条语句将 result 设置为 RECT 模式，而不管 result 和 step 的初始模式是什么，这是在 + 运算符重载的实现决定的，如果不希望这样实现，可以修改 operator+() 方法的实现。

如果想要将行走者一系列的位置存储到文件中也是很容易的，只需要包含 fstream 头文件，并声明一个 ofstream 对象，将其同一个文件关联起来，然后使用 << 运算符将位置记录输出到文件中：

#include <fstream>
...
ofstream fout;
fout.open("walker.txt");
fout << result << endl;