Класс "Отрезок". Вычислить длину отрезка.

#include <iostream>
#include <cmath>
 
//-----------------
struct point
{
  double x;
  double y;
  
  point(double x, double y)
    : x(x), 
      y(y)
  {
  }
};
 
//-----------------
class line_segment
{
  private:
    point a_;
    point b_;
    double len_;
 
  public:
    line_segment(const point& a, const point& b)
      : a_(a), 
        b_(b)
    {
      len_ = std::sqrt(std::pow(b.y - a.y, 2) + std::pow(b.x - a.x, 2));
    }
 
    double length() const
    {
      return len_;
    }
};
 
//-----------------
int main()
{
  line_segment obj(point(3, 5), point(5, 8));
  std::cout << obj.length() << std::endl; 
}

struct pt {
    int x, y;
};
 
inline int area (pt a, pt b, pt c) {
    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
 
inline bool intersect_1 (int a, int b, int c, int d) {
    if (a > b)  swap (a, b);
    if (c > d)  swap (c, d);
    return max(a,c) <= min(b,d);
}
 
bool intersect (pt a, pt b, pt c, pt d) {
    return intersect_1 (a.x, b.x, c.x, d.x)
        && intersect_1 (a.y, b.y, c.y, d.y)
        && area(a,b,c) * area(a,b,d) <= 0
        && area(c,d,a) * area(c,d,b) <= 0;
}

const double EPS = 1E-9;
 
struct pt {
    double x, y;
 
    bool operator< (const pt & p) const {
        return x < p.x-EPS || abs(x-p.x) < EPS && y < p.y - EPS;
    }
};
 
struct line {
    double a, b, c;
 
    line() {}
    line (pt p, pt q) {
        a = p.y - q.y;
        b = q.x - p.x;
        c = - a * p.x - b * p.y;
        norm();
    }
 
    void norm() {
        double z = sqrt (a*a + b*b);
        if (abs(z) > EPS)
            a /= z,  b /= z,  c /= z;
    }
 
    double dist (pt p) const {
        return a * p.x + b * p.y + c;
    }
};
 
#define det(a,b,c,d)  (a*d-b*c)
 
inline bool betw (double l, double r, double x) {
    return min(l,r) <= x + EPS && x <= max(l,r) + EPS;
}
 
inline bool intersect_1d (double a, double b, double c, double d) {
    if (a > b)  swap (a, b);
    if (c > d)  swap (c, d);
    return max (a, c) <= min (b, d) + EPS;
}
 
bool intersect (pt a, pt b, pt c, pt d, pt & left, pt & right) {
    if (! intersect_1d (a.x, b.x, c.x, d.x) || ! intersect_1d (a.y, b.y, c.y, d.y))
        return false;
    line m (a, b);
    line n (c, d);
    double zn = det (m.a, m.b, n.a, n.b);
    if (abs (zn) < EPS) {
        if (abs (m.dist (c)) > EPS || abs (n.dist (a)) > EPS)
            return false;
        if (b < a)  swap (a, b);
        if (d < c)  swap (c, d);
        left = max (a, c);
        right = min (b, d);
        return true;
    }
    else {
        left.x = right.x = - det (m.c, m.b, n.c, n.b) / zn;
        left.y = right.y = - det (m.a, m.c, n.a, n.c) / zn;
        return betw (a.x, b.x, left.x)
            && betw (a.y, b.y, left.y)
            && betw (c.x, d.x, left.x)
            && betw (c.y, d.y, left.y);
    }
}