Пересекаются ли две фигуры, или нет?

bool Point::intersect(Shape* P, Shape* S) {
    P=this; //??
    S->     //??

#include <iostream>
#include <math.h>
class Shape {
public:
    virtual void print()=0;
    virtual double area()=0;
    virtual Shape* move(int, int)=0;
    virtual bool intersect(Shape*, Shape*);
    virtual~ Shape() {}
};
class Point :public Shape {
public:
    double x;
    double y;
    Point(double X=0, double Y=0) {x=X; y=Y;}
    double get_xP()const {return x;}
    double get_yP()const {return y; }
    double area() { return 0;}
    friend double distance(Point , Point );
    bool intersect(Shape*, Shape*);
    Point* move(int x1, int y1) {x=x1; y=y1; return this;}
    void print() {std::cout<<"Print point : ("<<x<<","<<y<<")\n";}
};
double distance(Point a, Point b) { 
    double x=abs(b.get_yP()-a.get_yP()); 
    double y=abs(b.get_xP()-a.get_xP()); 
    return sqrt(x*x+y*y);
}
bool Point::intersect(Shape* P, Shape* S) {
    P=this;
    S->
class Triangle : public Shape {
    Point a;
    Point b;
    Point c;
public:
    Triangle () : a(0), b(0), c(0) {}
    Triangle (Point a1, Point b1, Point c1) : a(a1), b(b1), c(c1) {}
    Triangle(const Triangle&);
    double area();
    Triangle* move(int, int) {return this;}
    void print() {std::cout<<"Print Triangle : ";a.print(); b.print(); c.print(); }
};
Triangle::Triangle(const Triangle& T) {
 
    a=T.a;
    b=T.b;
    c=T.c;
}
double Triangle::area() {
 
    double p= (distance(b,a)+distance(c,a)+distance(c,b))/2;
    double s=sqrt(p*(p-distance(b,a))*(p-distance(b,c))*(p-distance(c,a)));
    return s;
}

#include <iostream>
#include <math.h>
class Shape {
public:
    virtual void print()=0;
    virtual double area()=0;
    virtual Shape* move(int, int)=0;
    virtual bool intersect(Shape*, Shape*)=0;
    virtual~ Shape() {}
};
class Point :public Shape {
public:
    double x;
    double y;
    Point(double X=0, double Y=0) {x=X; y=Y;}
    double get_xP()const {return x;}
    double get_yP()const {return y; }
    double area() { return 0;}
    bool intersect(Point*, Triangle*); // ??
    bool intersect(Point*, Circle*); //??
    friend double distance(Point , Point );
    Point* move(int x1, int y1) {x=x1; y=y1; return this;}
    void print() {std::cout<<"Print point : ("<<x<<","<<y<<")\n";}
};

#include <boost/variant.hpp>
 
#include <iostream>
using namespace std;
 
 
// допустим, это наши какие то фигуры
struct line {};
struct arc {};
 
 
// тогда механизм выявления их пересечений будет:    
struct intersects_algo : boost::static_visitor<bool> {
    bool operator()( const line& l1, const line& l2 ) const {
        cout<<"line vs line\n"; return true;
    }
 
    bool operator()( const arc& a1, const arc& a2 ) const {
        cout<<"arc vs arc\n"; return true;
    }
 
    bool operator()( const line& l, const arc& a ) const {
        cout<<"line vs arc\n"; return true;
    }
    bool operator()( const arc& a, const line& l ) const {
        return this->operator()( l, a );
    }
};
 
 
// порождаем вариативный тип данных
// который умеет наши фигуры
using element = boost::variant<line, arc>;
 
bool intersects( const element& e1, const element& e2 ) {
    return boost::apply_visitor(intersects_algo(), e1, e2 );
}
 
 
 
// пример использования:
int main() {
 
    element e1 = line{};
    element e2 = arc{};
 
    bool result = intersects(e1, e2);
}

//Title of this code
//g++  4.9.2
 
#include <iostream>
 
struct Shape
{
    virtual ~Shape(){}
    
    virtual bool intersect(const Shape&)const = 0;
    
};
 
struct Triangle;
struct Rect;
 
 
struct Triangle: Shape
{
    bool intersect(const Shape& obj)const;
};
 
struct Rect: Shape
{
    bool intersect(const Shape& obj)const;
};
 
bool Triangle::intersect(const Shape& obj)const 
{
    if( dynamic_cast<const Triangle*>(&obj))
        std::cout<<"triange vs triange\n";
    else if (dynamic_cast<const Rect*>(&obj))
        std::cout<<"triange vs rect\n";
    else
        std::cout<<"triange vs unkown\n";
    return true;
}
 
bool Rect::intersect(const Shape& obj)const 
{
    if( dynamic_cast<const Triangle*>(&obj))
        std::cout<<"rect vs triange\n";
    else if (dynamic_cast<const Rect*>(&obj))
        std::cout<<"rect vs rect\n";
    else
        std::cout<<"rect vs unkown\n";
    return true;
}
 
 
 
 
void intersect(const Shape& obj1, const Shape& obj2)
{
    obj1.intersect(obj2);
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    Rect rect;
    Triangle triangle;
    
    intersect(rect, triangle);
    
}