Решение всех задач из учебника Стивена Праты - C++ - Ответ 7499988

//  sp_Ch11_Pg588_Ex02 - main.cpp
/// Занятия по книге Стивена Праты "Язык программирования С++" (2013, 6-е изд.).
/// Упражнения по программированию. Глава 11, страница 588, упражнение 2.
/*
Модифицируйте заголовок класса Vector и файлы реализации (листинги 11.13
и 11.14) так, чтобы модуль и направление вектора больше не хранились в виде
компонентов данных. Вместо этого они должны вычисляться по требованию
при вызове методов magval() и angval(). Вы должны оставить открытый
интерфейс без изменений (те же открытые методы с теми же аргументами), но
изменить закрытую часть, включая некоторые из закрытых методов и их
реализации. Протестируйте модифицированную версию с помощью программы из
листинга 11.15, которая должна остаться неизменной, поскольку открытый
интерфейс класса Vector не менялся.
*/
 
#include <cstdlib>      // rand(), srand() prototypes
#include <ctime>        // time() prototype
#include "Vector.h"     // includes <iostream>
int main()
{
    using namespace std;
    using VECTOR::Vector;
 
    srand(time(0));     // seed random-number generator
    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 step length: ";
        if (!(cin >> dstep))
            break;
 
        while (result.magval() < target)
        {
            direction = rand() % 360;
            step.reset(dstep, direction, VECTOR::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 = "
            << result.magval()/steps << endl;
        steps = 0;
        result.reset(0.0, 0.0);
        cout << "Enter target distance (q to quit): ";
    }
    cout << "Bye!\n";
/* keep window open
    cin.clear();
    while (cin.get() != '\n')
        continue;
    cin.get();
*/
    return 0;
}

//  sp_Ch11_Pg588_Ex02 - Vector.h
 
#ifndef VECTOR_H
#define VECTOR_H
 
#include <iostream>
 
namespace VECTOR
{
    class Vector
    {
        public:
            enum Mode {RECT, POL};  // RECT for rectangular, POL for Polar modes
 
            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;              // calculate magnitude
            double angval() const;              // calculate 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);
 
        private:
            double x;          // horizontal value
            double y;          // vertical value
            Mode mode;         // RECT or POL
    };
 
}   // end namespace VECTOR
 
#endif // VECTOR_H

//  sp_Ch11_Pg588_Ex02 - Vector.cpp
//  methods for the Vector class
 
#include <cmath>
#include "Vector.h"  // includes <iostream>
 
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
 
 
// ===================public methods====================
 
    Vector::Vector()             // default constructor
    {
        x = y = 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;
        }
        else if (form == POL)
        {
             x = n1 * cos(n2 / Rad_to_deg);
             y = n1 * sin(n2 / Rad_to_deg);
        }
        else
        {
             cout << "Incorrect 3rd argument to Vector() -- ";
             cout << "vector set to 0\n";
             x = y = 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;
        }
        else if (form == POL)
        {
             x = n1 * cos(n2 / Rad_to_deg);
             y = n1 * sin(n2 / Rad_to_deg);
        }
        else
        {
             cout << "Incorrect 3rd argument to Vector() -- ";
             cout << "vector set to 0\n";
             x = y = 0.0;
             mode = RECT;
        }
    }
 
    Vector::~Vector()    // destructor
    {
    }
 
    double Vector::magval() const   // calculate magnitude
    {
        return sqrt(x * x + y * y);
    }
 
    double Vector::angval() const   // calculate angle
    {
        return (x == 0.0 && y == 0.0) ? 0.0 : atan2(y, x);
    }
 
    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.magval() << ", "
                 << v.angval() * Rad_to_deg << ")";
        }
        else
             os << "Vector object mode is invalid";
        return os;
    }
 
}  // end namespace VECTOR