Даны целые числа. Выяснить, найдутся ли среди точек четыре таких, которые являются вершинами квадрата

#include <stdio.h>
#include <math.h>
 
struct POINT
{
    int x, y;
};
 
struct LINE
{
    POINT p1, p2;
};
 
struct QUARE
{
    POINT topLeft, bottomRight;
};
 
//Растояние между точками
float distance( POINT p1, POINT p2)
{
    return sqrt( (p2.x - p1.x)*(p2.x - p1.x) + (p2.y - p1.y)*(p2.y - p1.y) );
};
 
//проверка паралельности прямых
bool parallel(LINE l1, LINE l2)
{
    bool p;
    //A1*B2-A2*B1
    p = (l1.p1.y - l1.p2.y)*(l2.p2.x - l2.p1.x) - (l2.p1.y - l2.p2.y)*(l1.p2.x - l1.p1.x);
    return p?false:true;
};
 
int _tmain(int argc, _TCHAR* argv[])
{
 
    return 0;
}

//проверка квадрата
/*
   tl _____ tr
     |       |
     |____|
   bl         br
*/
bool isquare(POINT tl, POINT bl, POINT br, POINT tr)
{
    if( tl.x!=tr.x && bl.x!=br.x ) return false;
    if( tl.y!=bl.y && tr.y!=br.y ) return false;
    return true;
};

bool isquare(POINT tl, POINT bl, POINT br, POINT tr)
{
        if( tl.x!=tr.x && bl.x!=br.x ) return false;
        if( tl.y!=bl.y && tr.y!=br.y ) return false;
        if( distance(tl, tr)!=distance(tl, bl) ) return false;
        return true;
};

//////////////////////////////////////////////////////////////////////////////////////
//Даны целые числа x1, y1, x2, y2, ...xn, yn.Выяснить, найдутся ли среди точек 
//с координатами (x1;y1), (x2;y2),...(xn;yn) четыре таких, которые являются 
//вершинами квадрата.Определить подпрограммы вычисления расстояния между 2-мя точками, 
//определения взаимного расположения прямых и другие, необходимые для решения.
//////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <iterator>
#include <set>
//////////////////////////////////////////////////////////////////////////////////////
struct  T_int_point
{
    int X_;
    int Y_;
    //--------------------------------------------------------------------------------
    T_int_point(int X, int Y) : X_(X), Y_(Y)
    {}
    //--------------------------------------------------------------------------------
    T_int_point  operator+(T_int_point  p) const
    {
        int  X_res = X_ + p.X_;
        int  Y_res = Y_ + p.Y_;
        return  T_int_point(X_res, Y_res);
    }
    //--------------------------------------------------------------------------------
    T_int_point  operator-(T_int_point  p) const
    {
        int  X_res = X_ - p.X_;
        int  Y_res = Y_ - p.Y_;
        return  T_int_point(X_res, Y_res);
    }
    //--------------------------------------------------------------------------------
    void  print() const
    {
        std::cout << "("
                  << X_
                  << ", "
                  << Y_
                  << ")";
    }
    //--------------------------------------------------------------------------------
    bool  operator< (T_int_point  p) const
    {
        return  X_ == p.X_ ? Y_ < p.Y_ : X_ < p.X_;
    }
};
//////////////////////////////////////////////////////////////////////////////////////
typedef  std::set<T_int_point>   T_int_points;
typedef  std::set<T_int_points>  T_squares;
//////////////////////////////////////////////////////////////////////////////////////
T_int_point  vect(const T_int_point  A, const T_int_point  B)
{
    return  B - A;
}
//////////////////////////////////////////////////////////////////////////////////////
int dist_a_square(const T_int_point  A, const T_int_point  B)
{
    T_int_point  vect_AB = vect(A, B);
    return  vect_AB.X_ * vect_AB.X_ + vect_AB.Y_ * vect_AB.Y_;
}
//////////////////////////////////////////////////////////////////////////////////////
void  print_points_forming_squares(const T_int_points&  int_points)
{ 
    T_squares  squares;
    //Перебираем все сочетания по две точки в поисках гипотенузы 
    //прямоугольного треугольника:
    for(T_int_points::const_iterator  A_hip_it = int_points.begin(); 
        A_hip_it != int_points.end(); ++A_hip_it)
    {
        for(T_int_points::const_iterator  B_hip_it = A_hip_it; 
            B_hip_it != int_points.end(); ++B_hip_it)
        {
            if(B_hip_it == A_hip_it)
            {
                continue;
            }
            //Перебираем все точки множества в поисках вершины
            //для предполагаемой гипотенузы прямоугольного треугольника.
            for(T_int_points::const_iterator  C_it = int_points.begin();  
                C_it != int_points.end(); ++C_it)
            {
                if(    C_it == A_hip_it
                    || C_it == B_hip_it)
                {
                    continue;
                }
                //Проверяем, образуют ли точки равнобедренный 
                //прямоугольный треугольник с гипотенузой AB.
                int AB_hip_len2 = dist_a_square(*A_hip_it, *B_hip_it);
                int AC_cat_len2 = dist_a_square(*A_hip_it, *C_it);
                int BC_cat_len2 = dist_a_square(*B_hip_it, *C_it);
 
                if(AC_cat_len2 == BC_cat_len2
                   && AB_hip_len2 == AC_cat_len2 + BC_cat_len2)
                {
                    T_int_point  D = *C_it + vect(*C_it, *B_hip_it) + vect(*C_it, *A_hip_it);                    
                    //Если точка, дополняющая прямоугольный 
                    //треугольник до квадрата существует:
                    if(int_points.find(D) != int_points.end())
                    {
                        T_int_points  square;
                        square.insert(*A_hip_it);                        
                        square.insert(*B_hip_it);
                        square.insert(*C_it);
                        square.insert(D);
 
                        squares.insert(square);
                    }
                }
            }
        }
    }
 
    std::cout << (squares.empty() 
                      ? "Нет вершин квадратов."
                      : "В данном множестве точек являются вершинами квадратов:")
              << std::endl;
 
    //Печатаем все квадраты из squares:   
    for(T_squares::iterator  square_it = squares.begin(); 
        square_it != squares.end(); ++square_it)
    {
        std::cout << "квадрат № "                  
                  << std::distance(squares.begin(), square_it) + 1
                  << "\t\t";
        for(T_int_points::const_iterator  vertice_it = square_it->begin(); 
            vertice_it != square_it->end(); ++vertice_it)
        {
            
            vertice_it->print();
            std::cout << "    ";
        }
        std::cout << std::endl
                  << std::endl
                  << std::endl;
    }    
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    const int  POINTS_IN_SQUARE = 4;
    int  n;
    do
    {
        std::cout << "Введите количество точек >= "
                  << POINTS_IN_SQUARE
                  << ": ";
        std::cin >> n;
    }while(n < POINTS_IN_SQUARE);
    
    std::cout << "Введите целые координаты "
              << n
              << " различных точек: "
              << std::endl;
 
    T_int_points  int_points;
    do
    {
        std::cout << "X" 
                  << int_points.size() + 1 
                  << " = ";
        int x = 0;
        std::cin >> x;
 
        std::cout << "Y"
                  << int_points.size() + 1 
                  << " = ";
        int y = 0;
        std::cin >> y;
        std::cout << std::endl;
        int_points.insert(T_int_point(x, y));
    }while(static_cast<int>(int_points.size()) < n);
 
    print_points_forming_squares(int_points);
}