C++ Primer Plus

The components are a horizontal vector (the x component) and a vertical vector (the y component), which add up to the final vector. For example, you can describe a motion as moving a point 30 units to the right and 40 units up (see Figure 11.3). That motion puts the point at the same spot as moving 50 units at an angle of 53.1° from the horizontal. Therefore, a vector with a magnitude of 50 and an angle of 53.1° is equivalent to a vector having a horizontal component of 30 and a vertical component of 40. What counts with displacement vectors is where you start and where you end up, not the exact route taken to get there. This choice of representation is basically the same thing covered with the Chapter 7 program that converts between rectangular and polar coordinates.

Figure 11.3. The x and y components of a vector.

Sometimes one form is more convenient, sometimes the other, so you’ll incorporate both representations into the class description. (See the sidebar “Multiple Representations and Classes,” later in this chapter.) Also you’ll design the class so that if you alter one representation of a vector, the object automatically updates the other representation. The ability to build such intelligence into an object is another C++ class virtue. Listing 11.13 presents a class declaration. To refresh your memory about namespaces, the listing places the class declaration inside the VECTOR namespace. Also the program uses enum to create a couple constants (RECT and POL) for identifying the two representations. (We covered that technique in Chapter 10, so we may as well use it!)

Listing 11.13. vect.h

// vect.h -- Vector class with <<, mode state

#ifndef VECTOR_H_

#define VECTOR_H_

#include

namespace VECTOR

{

    class Vector

    {

    public:

        enum Mode {RECT, POL};

    // RECT for rectangular, POL for Polar modes

    private:

        double x;          // horizontal value

        double y;          // vertical value

        double mag;        // length of vector

        double ang;        // direction of vector in degrees

        Mode mode;         // RECT or POL

    // private methods for setting values

        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;}       // 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 POL

        void rect_mode();                     // set mode to RECT

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

Notice that the four functions in Listing 11.13 that report component values are defined in the class declaration. This automatically makes them inline functions. The fact that these functions are so short makes them excellent candidates for inlining. None of them should alter object data, so they are declared using the const modifier. As you may recall from Chapter 10, this is the syntax for declaring a function that doesn’t modify the object it implicitly accesses.

Listing 11.14 shows all the methods and friend functions declared in Listing 11.13. The listing uses the open nature of namespaces to add the method definitions to the VECTOR namespace. Note how the constructor functions and the reset() function each set both the rectangular and the polar representations of the vector. Thus, either set of values is available immediately without further calculation, should you need them. Also as mentioned in Chapter 4, “Compound Types,” and Chapter 7, C++’s built-in math functions use angles in radians, so the functions build conversion to and from degrees into the methods. The Vector class implementation hides such things as converting from polar coordinates to rectangular coordinates or converting radians to degrees from the user. All the user needs to know is that the class uses angles in degrees and that it makes a vector available in two equivalent representations.

Listing 11.14. vect.cpp

// vect.cpp -- methods for the Vector class

#include

#include "vect.h"   // includes

using std::sqrt;

using std::sin;

using std::cos;

using std::atan;

using std::atan2;

using std::cout;

namespace VECTOR

{

    // compute degrees in one radian

    const double Rad_to_deg = 45.0 / atan(1.0);

    // should be about 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