C++ Primer Plus

    void Vector::set_y()

    {

        y = mag * sin(ang);

    }

    // public methods

    Vector::Vector()             // default constructor

    {

        x = y = mag = ang = 0.0;

        mode = RECT;

    }

    // 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, 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;

        }

    }

    // reset vector from rectangular coordinates if form is

    // RECT (the default) or else from polar coordinates if

    // form is POL

    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()    // destructor

    {

    }

    void Vector::polar_mode()    // set to polar mode

    {

        mode = POL;

    }

    void Vector::rect_mode()     // set to rectangular mode

    {

        mode = RECT;

    }

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

    }

    // multiply 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 RECT,

    // else display polar coordinates if mode is POL

    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;

    }

}  // end namespace VECTOR

You could design the class differently. For example, the object could store the rectangular coordinates and not the polar coordinates. In that case, the computation of polar coordinates could be moved to the magval() and angval() methods. For applications in which conversions are seldom used, this could be a more efficient design. Also the reset() method isn’t really needed. Suppose shove is a Vector object and that you have the following code:

shove.reset(100,300);

You can get the same result by using a constructor instead:

shove = Vector(100,300);    // create and assign a temporary object

However, the set() method alters the contents of shove directly, whereas using the constructor adds the extra steps of creating a temporary object and assigning it to shove.

These design decisions follow the OOP tradition of having the class interface concentrate on the essentials (the abstract model) while hiding the details. Thus, when you use the Vector class, you can think about a vector’s general features, such as that they can represent displacements and that you can add two vectors. Whether you express a vector in component notation or in magnitude, direction notation becomes secondary because you can set a vector’s values and display them in whichever format is most convenient at the time.

We’ll look at some of the features the Vector class in more detail next.

Using a State Member

The Vector class stores both the rectangular coordinates and the polar coordinates for a vector. It uses a member called mode to control which form the constructor, the reset() method, and the overloaded operator<<() function use, with the enumerations RECT representing the rectangular mode (the default) and POL the polar mode. Such a member is termed a state member because it describes the state an object is in. To see what this means, look at the code for the constructor:

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;

    }

}

If the third argument is RECT or if it is omitted (in which case the prototype assigns a default value of RECT), the inputs are interpreted as rectangular coordinates, whereas a value of POL causes them to be interpreted as polar coordinates:

Vector folly(3.0, 4.0);            // set x = 3, y = 4

Vector foolery(20.0, 30.0, VECTOR::Vector::POL);   // set mag = 20, ang = 30