Выбрать 3 различные точки, являющимися вершинами треугольника наибольшего периметра

#include         <iostream>
#include            <cmath>
#include           <random>
#include           <chrono>
#include          <conio.h>
#include            <tuple>
#include          <utility>
#include         <iterator>
#include           <vector>
 
class Points
{
public:
    using T_Coord               =                                    double;
    using T_Point               =               std::pair<T_Coord, T_Coord>;
    using T_points_arr          =                      std::vector<T_Point>;
    using T_triangle            =     std::tuple<T_Point, T_Point, T_Point>;
    using T_real_distribution   =    std::uniform_real_distribution<double>;
 
    explicit Points() : Points(0) { }
    explicit Points(const std::size_t count_) : count(count_) { arr_point.resize(count_); }
 
    friend auto operator<<(std::ostream& os, const Points& other) -> std::ostream&
    {
        std::cout << "Points [" << other.arr_point.size() << "]:" << std::endl;
        std::for_each(other.arr_point.cbegin(), other.arr_point.cend(),
            [&os](auto& p_) { os << '(' << p_.first << ',' << p_.second << ')' << std::endl; });
        return os;
    }
 
    friend auto operator>>(std::istream& is, Points& other) -> std::istream&
    {
        int i{ }; unsigned char key;
        do
        {
            std::cout << "Select the action:"          << std::endl
                      << "\t1. Manual input of points" << std::endl
                      << "\t2. Auto entry points"      << std::endl;
 
            key = _getch();
            system("cls");
        } while (key < '1' || key > '2');
        switch (key)
        {
        
        case '1':
        {
            std::for_each(other.arr_point.begin(), other.arr_point.end(),
                [&is, i](auto& p_) mutable {
                std::cout << "Enter Point [" << i + 1 << "]: ";
                is >> p_.first >> p_.second; 
                ++i;
            });
            
        }
        break;
        
        case '2':
        {
            const auto seed = std::chrono::system_clock::now().time_since_epoch().count();
            static std::default_random_engine gen(seed);
 
            std::for_each(other.arr_point.begin(), other.arr_point.end(),
                [&other](auto& p_) {
                p_.first  = Points::T_real_distribution(-100, 100)(gen);
                p_.second = Points::T_real_distribution(-100, 100)(gen);
            });
 
        }
        break;
        }
        
        return is;
    }
 
    static auto distance(const T_Point& lhs_, const T_Point& rhs_) -> T_Coord
    {
        auto dx_ = rhs_.first - lhs_.first;
        auto dy_ = rhs_.second - lhs_.second;
        return std::sqrt(dx_*dx_ + dy_*dy_);
    }
 
    static auto get_perimeter(const T_Point& p1_, const T_Point& p2_, const T_Point& p3_) -> T_Coord
    {
        return distance(p1_, p2_) + distance(p2_, p3_) + distance(p1_, p3_);
    }
 
    static auto is_triangle(const T_Point& p1_, const T_Point& p2_, const T_Point& p3_) -> bool
    {
        if (
            (distance(p1_, p2_) + distance(p2_, p3_) > distance(p1_, p3_)) &&
            (distance(p2_, p3_) + distance(p1_, p3_) > distance(p1_, p2_)) &&
            (distance(p1_, p2_) + distance(p1_, p3_) > distance(p2_, p3_)) &&
            (p1_.first != p2_.first != p3_.first || p1_.second != p2_.second != p3_.second)
                                                                           &&
            (p1_.first != p2_.first != p3_.first && p1_.second != p2_.second != p3_.second)
                                                                           &&
            (p1_.first != p1_.second || p2_.first != p2_.second || p3_.first != p3_.second)
            )
            return true;
        return false;
    }
 
    auto max_perimeter() -> T_Coord
    {
        double max_perm{ }, temp{ };
        T_points_arr::iterator beg = arr_point.begin(), end = arr_point.end(), sec = beg + 1;
        while (beg != end && beg != sec)
        {
            while (sec != end) {
 
                for (T_points_arr::iterator it = sec + 1; it != end; ++it) {
 
                    temp = static_cast<double>(get_perimeter(*beg, *sec, *it));
                    bool flag = is_triangle(*beg, *sec, *it);
 
                    if (max_perm < temp && flag) {
                        max_perm = temp;
 
                        triangle_points_ = std::tie(
                            std::make_pair(beg->first, beg->second),
                            std::make_pair(sec->first, sec->second),
                            std::make_pair(it->first, it->second));
                    }
                }
                ++sec;
            }
            ++beg;
        }
 
        if (max_perm > 0) {
 
            std::cout << "The maximum perimeter between three points ";
            std::cout << '(' << std::get<0>(std::get<0>(triangle_points_)) << ',' << std::get<1>(std::get<0>(triangle_points_)) << ')';
            std::cout << '(' << std::get<0>(std::get<1>(triangle_points_)) << ',' << std::get<1>(std::get<1>(triangle_points_)) << ')';
            std::cout << '(' << std::get<0>(std::get<2>(triangle_points_)) << ',' << std::get<1>(std::get<2>(triangle_points_)) << ')' << ':';
        }
 
        else
            std::cout << "No detected triangle :((" << std::endl;
 
        return max_perm;
    }
private:
    const std::size_t count;
    T_points_arr arr_point;
    T_triangle triangle_points_;
};