Движение точки по ломаному пути

struct point
{
   int x;
   int y;
};
void goForward(point *mas, const int size)
{
   for(int i=0;i<size-1; i++)
      cout<<"Point go from ("<<mas[i].X<<", "<<mas[i].Y<<") to ("<<mas[i +1].X<<", "<<mas[i +1].Y<<");\n";
}
void goBack(point *mas, const int size)
{
   for(int i=size-1; i>1;i--)
      cout<<"Point go from ("<<mas[i].X<<", "<<mas[i].Y<<") to ("<<mas[i -1].X<<", "<<mas[i -1].Y<<");\n";
}

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cmath>
 
struct Way
{
    float x; // x coordinate.
    float y; // y coordinate.
    int t; // delay.
};
 
class PointWay
{
public:
    PointWay();
    PointWay(float, float, int);
    ~PointWay() {}
    void add_point(float, float, int);
    void show_way();
 
private:
    std::vector<Way> points;
    float ix, iy;
 
    void set_sleep(int);
    float formula_length(std::vector<Way>::const_iterator);
    float get_xfactor(std::vector<Way>::const_iterator);
    float get_yfactor(std::vector<Way>::const_iterator);
    void show_point(std::vector<Way>::const_iterator);
};
 
PointWay::PointWay()
{
    std::clog << "You need initialize point.\n";
    exit(0);
}
 
PointWay::PointWay(float x, float y, int time)
{
    Way pt = { x, y, time };
    ix = x, iy = y;
    points.push_back(pt);
}
 
void PointWay::set_sleep(int t)
{
    clock_t start_count = clock();
    while (clock()/CLOCKS_PER_SEC - start_count/CLOCKS_PER_SEC < t)
        ;
}
 
float PointWay::formula_length(std::vector<Way>::const_iterator i)
{
    return sqrt( (ix - i->x) * (ix - i->x) +
                 (iy - i->y) * (iy - i->y) );
}
 
float PointWay::get_xfactor(std::vector<Way>::const_iterator i)
{
    if (i->x > ix)
    {
        return (i->x - ix) / formula_length(i);
    }
    else
    {
        return -((ix - i->x) / formula_length(i));
    }
}
 
float PointWay::get_yfactor(std::vector<Way>::const_iterator i)
{
    if (i->y > iy)
    {
        return (i->y - iy) / formula_length(i);
    }
    else
    {
        return -((iy - i->y) / formula_length(i));
    }
}
 
void PointWay::add_point(float x, float y, int time)
{
    Way addin = { x, y, time };
    points.push_back(addin);
}
 
void PointWay::show_point(std::vector<Way>::const_iterator it)
{
    float fact_x = get_xfactor(it);
    float fact_y = get_yfactor(it);
    for (int i = formula_length(it); i > 0; --i)
    {
        std::cout.precision(3);
        std::cout << "x: " << (ix += fact_x) << "\t y: " << (iy += fact_y) << '\n';
        set_sleep(it->t);
    }
}
 
void PointWay::show_way()
{
    std::vector<Way>::iterator the_point = points.begin();
    ++the_point; // set to the next position, couse first positioni is
    // initialize by constructor;
 
    // front move.
    for ( ; the_point != points.end(); ++the_point)
    {
        show_point(the_point);
        std::cout << '\n';
    }
 
    // move back.
    for ( --the_point; points.size() > 0; --the_point)
    {
        show_point(the_point);
        std::cout << '\n';
        points.erase(the_point);
        the_point = points.end();
    }
}
 
int main()
{
    PointWay obj(1, 1, 1);
    obj.add_point(-3, 5, 1);
    obj.show_way();
}

#include <iostream>
#include <iomanip>
#include <string>
#include <ctime>
#include <cstdlib>
#include <cmath>
 
struct Point {
  double x, y;
  // это, конечно, моветон, но для примера сойдет.
  Point() : x(rand() % 20), y(rand() % 20) {}
  Point(const double &x, const double &y) : x(x), y(y) {}
  double getDistanceTo(const Point &a) {
    return sqrt(pow(x - a.x, 2) + pow(y - a.y, 2));
  }
  Point advanceTowards(const Point &a, double amount) {
    double distance = getDistanceTo(a);
    return Point(x + (amount * (a.x - x)) / distance,
      y + (amount * (a.y - y)) / distance);
  }
};
 
std::ostream &operator<<(std::ostream &stream, const Point &p) {
  return stream << std::fixed << std::setprecision(4) << 
    "[" << std::setw(7) << p.x << ", " << std::setw(7) << p.y << "]";
}
 
int main(int argc, char *argv[]) {
  srand(time(0));
 
  const size_t numberOfPoints = 10;
  Point points[numberOfPoints];
  Point point;
  double step = (rand() % 10 + 1) / 10.;
 
  for (size_t i = 0; i < numberOfPoints; ++i) {
    while (point.getDistanceTo(points[i]) >= step) {
      std::cout << point << " -> " << points[i] << ", step = " <<
        step << std::endl;
      point = point.advanceTowards(points[i], step);
    }
    point = points[i];
    std::cout << "Point has come to " << points[i] << std::endl;
  }
 
  std::cin.get();
  return 0;
}