Нужно проверить, лежит ли один шестиугольник в другом

///----------------------------------------------------------------------------|
/// Проверка нахождение выпуклого многоугольника внутри другого многоугольника.
///----------------------------------------------------------------------------:
#include <iostream>
 
#define LOG(v)  std::cout << #v << " = " << v << "\n";
#define BANNER(v1,v2,v3)  std::cout  << v1 << "\n" << v2 << "\n" << v3 << "\n";
 
///----------------------------------------------------------------------------|
/// sPlot.
///----------------------------------------------------------------------------:
struct  sPlot
{   sPlot() : x(0), y(0) {}
    sPlot(int X, int Y) : x(X), y(Y) {}
    double x, y;
    sPlot* info()
    {   std::cout << "Точка:  " << x << ",\t" << y << "\n";
        return this;
    }
};
 
///----------------------------------------------------------------------------|
/// sSquare.
///----------------------------------------------------------------------------:
struct  sSquare
{   sSquare(sPlot* S, size_t N) : s(S), n(N) {}
    sPlot* s;
    size_t n;
};
 
///----------------------------------------------------------------------------|
/// sCheckIntro.
///----------------------------------------------------------------------------:
struct  sCheckIntro
{       sCheckIntro(sSquare& S, sPlot& P) : s(S), p(P)
    {   b = go();
        std::cout << (b ? "ВНУТРИ!" : "СНАРУЖИ!") << "\n\n";
    }
    sSquare& s;
    sPlot&   p;
    bool     b;
 
private:
    bool go()
    {   int gp = 0, gn = 0;
        int vp = 0, vn = 0;
 
        for(int i = 0; i < s.n; i++)
        {   //std::cout << "\n|-------------------------:\n";
            sPlot* s1 = &s.s[i  ];
            sPlot* s2;
            if(i == s.n - 1) s2 = &s.s[0  ];
            else             s2 = &s.s[i+1];
 
            int v = is_side_positive_g(s1, s2);
            if     ( v > 0)  gp++;
            else if( v < 0)  gn--;
 
            v = is_side_positive_v(s1, s2);
            if     ( v > 0)  vp++;
            else if( v < 0)  vn--;
 
            //LOG(gp); LOG(gn); LOG(vp); LOG(vn);
        }
 
        if(gp == 0 || gn == 0 || vp == 0 || vn == 0 )
            return false;
 
        return true;
    }
 
    int is_side_positive_g( sPlot* s1_,
                            sPlot* s2_      )
    {   sPlot& s1 = *s1_;
        sPlot& s2 = *s2_;
 
        ///-----------------------------------------|
        /// (x  - x1)   (y  - y1)                   |
        ///  -------  =  -------                    |
        /// (x2 - x1)   (y2 - y1)                   |
        ///                                         |
        /// x =  (y - y1)*(x2 - x1)/(y2 - y1) + x1  |
        ///-----------------------------------------|
 
        double max_ = std::max(s1.y, s2.y);
        double min_ = std::min(s1.y, s2.y);
 
        if(p.y > max_ ||  p.y < min_)
        {   return 0;
        }
 
        double x = (p.y - s1.y)*(s2.x - s1.x)/(s2.y - s1.y) + s1.x;
 
        if(x >= p.x) return  1;
        return -1;
    }
 
    int is_side_positive_v( sPlot* s1_,
                            sPlot* s2_      )
    {   sPlot& s1 = *s1_;
        sPlot& s2 = *s2_;
 
        double max_ = std::max(s1.x, s2.x);
        double min_ = std::min(s1.x, s2.x);
 
        if(p.x > max_ ||  p.x < min_)
        {   return 0;
        }
 
        ///-----------------------------------------|
        /// (x  - x1)   (y  - y1)                   |
        ///  -------  =  -------                    |
        /// (x2 - x1)   (y2 - y1)                   |
        ///                                         |
        /// y = (x  - x1)*(y2 - y1)/(x2 - x1) + y1  |
        ///-----------------------------------------|
 
        double y = (p.x  - s1.x)*(s2.y - s1.y)/(s2.x - s1.x) + s1.y;
 
        if(y >= p.y) return  1;
        return -1;
    }
};
 
///----------------------------------------------------------------------------|
/// sTask.
///----------------------------------------------------------------------------:
struct  sTask
{   sTask(sSquare& S, sSquare& C) : s(S), c(C)
    {   bool b = go();
        std::cout << "c_square " << (b ? "ВНУТРИ!" : "СНАРУЖИ!") << "\n";
    }
    sSquare& s;
    sSquare& c;
    bool go()
    {   for(int i = 0; i < c.n; i++)
        {   c.s[i].info();
            sCheckIntro check(s, c.s[i]);
            if(!check.b) return false;
        }
        return true;
    }
};
 
///----------------------------------------------------------------------------|
/// Start.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    //---------------------------------|
    // Фигура square.                  |
    // Тут треугольник, но без разницы.|
    // Можно сколь угодно углов!       |
    //---------------------------------:
    sPlot plots[] =
    {   sPlot( 10.,  10.),
        sPlot(100.,  20.),
        sPlot( 50., 120.)
    };
    sSquare square(plots, sizeof(plots)/sizeof(*plots));
 
    //---------------------------------|
    // Фигура c_square.                |
    // Тут треугольник, но без разницы.|
    // Можно сколь угодно углов!       |
    //---------------------------------:
    sPlot test_plots[] =
    {   sPlot( 40.,  22.),
        sPlot( 90.,  21.),
        sPlot( 50., 100.)
    };
    sSquare c_square(test_plots, sizeof(test_plots)/sizeof(*test_plots));
 
                                                    BANNER(
    "///------------------------------------------------|",
    "/// Находится ли фигура c_square внутри square?    |",
    "///------------------------------------------------:")
    sTask task(square, c_square);
    
    std::cin.get();
    return 0;
}