C++ Primer Plus(再谈重载-一个矢量类)

跟着书敲了一个矢量类，记录如下:
Vector要实现矢量的基本运算，最重要的是为后面实现Drunkard Walk problem打下基础，从这个简单的例子中体会一些OOP思想的运用。

//vect.h
#ifndef VECTOR_H
#define VECTOR_H
#include<iostream>
namespace VECTOR
{
    class Vector {
    public:
        enum Mode { RECT, POL };
        //rectangular mode polar mode
    private:
        double x;
        double y;
        double mag;//magnitude of Vector
        double ang;//direction of Vector in degrees
        Mode mode;//RECT or POL
        void set_mag();
        void set_ang();
        void set_x();
        void set_y();
    public:
        Vector();
        Vector(double n1, double n2, Mode form = RECT);
        void reset(double n1, double n2, Mode form = RECT);
        ~Vector();
        double xval()const { return x; }
        double yval()const { return y; }
        double magval()const{return mag;}
        double angval()const { return ang; }
        void polar_mode();
        void rect_mode();
        //operator overloading
        Vector operator+(const Vector & b)const;
        Vector operator-(const Vector & b)const;
        Vector operator-()const;//reverse sign of Vector
        Vector operator*(double n)const;

        //friends
        friend Vector operator*(double n, const Vector & a);
        friend std::ostream &
            operator<<(std::ostream & os, const Vector & v);
    };
}
#endif

// vector.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include"vect.h"
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::cout;


namespace VECTOR {
    //compute degrees
    const double Rad_to_deg = 45.0 / atan(1.0);

    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);
    }

    void Vector::set_y()
    {
        y = mag * sin(ang);
    }

    Vector::Vector() {
        x = y = mag = ang = 0.0;
        mode = RECT;
    }

    Vector::Vector(double n1, double n2, Mode form)
    {
        mode = form;
        if (form == RECT)
        {
            x = n1;
            y = n2;
            set_mag();
            set_ang();
        }
        else if (form == POL)
        {
            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 = RECT;
        }

    }

    void Vector::reset(double n1, double n2, Mode form)
    {
        mode = form;
        if (form == RECT)
        {
            x = n1;
            y = n2;
            set_mag();
            set_ang();
        }
        else if (form == POL) {
            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 = RECT;

        }
    }

    Vector::~Vector() {};

    void Vector::polar_mode()
    {
        mode = POL;
    }

    void Vector::rect_mode() {
        mode = RECT;
    }

    //operator overloading
    Vector Vector::operator+(const Vector & b)const
    {
        return Vector(x + b.x, y + b.y);
    }

    Vector Vector::operator-(const Vector & b)const
    {
        return Vector(x - b.x, y - b.y);
    }

    Vector Vector::operator-()const
    {
        return Vector(-x, -y);
    }

    Vector Vector::operator*(double n)const
    {
        return Vector(n * x, n * y);
    }

    //multiply n by Vector a
    Vector operator*(double n, const Vector & a)
    {
        return n * a;
    }

    std::ostream & operator<<(std::ostream & os, const Vector & v)
    {
        if (v.mode == Vector::RECT)
            os << "(x,y) = (" << v.x << "," << v.y << ")";
        else if (v.mode == Vector::POL)
        {
            os << "(m,a) = (" << v.mag << "," << v.ang * Rad_to_deg << ")";
        }
        else
            os << "Vector object mode is invalid";
        return os;
    }
}

接下来是随机漫步问题:将一个人领到街灯柱下，这个人开始走动，但每一步方向都是随机的，求这个人走到离灯柱50英尺需要多少步。

#include"stdafx.h"
#include<iostream>
#include<cstdlib>
#include<ctime>
#include"vect.h"
int main()
{
    using namespace std;
    using VECTOR::Vector;
    srand(time(0));
    double direction;
    Vector step;
    Vector result(0.0, 0.0);
    unsigned long steps = 0;
    double target;
    double dstep;
    cout << "Enter target distance (q to quit): ";
    while (cin >> target)
    {
        cout << "Enter target step length: ";
        if (!(cin >> dstep))
            break;
        while (result.magval() < target)
        {
            direction = rand() % 360;
            step.reset(dstep, direction, Vector::POL);
            result = result + step;
            steps++;
        }
        cout << "After " << steps << " steps,the subject "
            "has the following location:\n";
        cout << result << endl;
        result.polar_mode();
        cout << " or\n" << result << endl;
        cout << " Average outward distance per step = ";
        cout << result.magval() / steps << endl;
        steps = 0;
        result.reset(0.0, 0.0);
        cout << "Enter target distance (q to quit): ";

    }
    cout << "Bye!\n";
    cin.clear();
    while (cin.get() != '\n')
        continue;
    return 0;
}