Двойная диспетчеризация :)

class Circle;
class Triangle;
class Square;
 
class Shape {
public:
    virtual double getIntersection(const Shape& other) const = 0;  // Функция, которая вызывается для определения площади пересечения
    // Эти функции вычисляют площадь пересечения с конкретной фигурой
    // Для ясности к именам добавлена буква, идентифицирующая класс,
    // но на самом деле необходимости в ней нет, компилятор сориентируется по типам ссылок
    virtual double getIntersectionC(const Circle& c) const = 0;
    virtual double getIntersectionT(const Triangle& t) const = 0;
    virtual double getIntersectionS(const Square& s) const = 0;
};
 
class Circle: public Shape {
public:
    virtual double getIntersection(const Shape& other) const
    {
        return other->getIntersectionС(*this);  // Разворачиваем вызов, надёжно идентифицируя себя как круг
    }
 
    // Реализуем вычисление площади, зная тип нашей фигуры (круг) и второй фигуры
    virtual double getIntersectionC(const Circle& c) const;
    virtual double getIntersectionT(const Triangle& t) const;
    virtual double getIntersectionS(const Square& s) const;    
};
 
// Классы Triangle и Square реализуются аналогично
 
// Получим площадь пересечения фигур, зная их имена
double getIntersectionByNames(const Drawing& drawing, const string& name1, const string& name2)
{
    const Shape& shape1 = Drawing.getByName(name1); // Допустим, это Triangle
    const Shape& shape2 = Drawing.getByName(name2); // Допустим, это Circle
    return shape1.getIntersection(shape2);  // будет вызвана виртуальная функция Triangle::getIntersection, которая
    // в свою очередь вызовет у shape2 виртуальный метод Circle::getIntersectionT
}

#include <iostream>
using std::cout;
using std::endl;
 
class Base {
public:
    void foo() const {cout << "Base::foo" << endl;}
    virtual void bar() const {cout << "Base::bar" << endl;}
};
 
class Derived: public Base{
public:
    void foo() const {cout << "Derived::foo" << endl;}
    virtual void bar() const {cout << "Derived::bar" << endl;}
};
 
int main()
{
    Base b;
    Derived d;
    Base* pb = &d;
    b.foo();  // Печатает Base::foo
    b.bar();  // Печатает Base::bar
    d.foo();  // Печатает Derived::foo
    d.bar();  // Печатает Derived::bar
    pb->foo();    // Печатает Base::foo, хотя pb указывает на объект Derived, потому что pb имеет тип Base*
    pb->bar();    // Печатает Derived::bar, потому что функция виртуальная и вызывается через сам объект, который знает свой настоящий тип
}

#include <iostream>
 
class Base
{
public:
   virtual ~Base() {}
   virtual void f() = 0;
};
 
void Base::f() { std::cout << "f" << std::endl; }
 
class Der : public Base
{
public:
   void f() { std::cout << "Der::f" << std::endl; Base::f(); }
};
 
int main()
{
   Base* b = new Der();
   b->f();
   delete b;
}

class Derived: public Base{
public:
    void foo() const {cout << "Derived::foo" << endl;}
    void bar() const {cout << "Derived::bar" << endl;}
};

int main()
{
    Base b;
    Derived d;
    Base* pb = &d;
    b.foo();  // Печатает Base::foo
    b.bar();  // Печатает Base::bar
    d.foo();  // Печатает Derived::foo
    d.bar();  // Печатает Derived::bar
    pb->foo();    // Печатает Base::foo, хотя pb указывает на объект Derived, потому что pb имеет тип Base*
    pb->bar();    // Печатает Derived::bar, потому что функция виртуальная и вызывается через сам объект, который знает свой настоящий тип
}

#include <iostream>
using std::cout;
using std::endl;
 
class Shape
{
public:
    virtual void intersec(Shape a, Shape b){};//f opredel9yucha9 perecechenie
};
 
class Triangle : public Shape
{
public:
    virtual void intersec(Shape a, Shape b)
    {
        cout <<"intersec Triangle"<<endl;
    }
};
 
class Square : public Shape
{
public:
    virtual void intersec(Shape a, Shape b)
    {
        cout <<"intersec Square"<<endl;
    }
};
 
class Rectangle : public Shape
{
public:
    virtual void intersec(Shape a, Shape b)
    {
        cout <<"intersec Rectangle"<<endl;
    }
};
 
int main()
{
    Shape* Shape;
    Rectangle R;
    Triangle T;
    Square S;
    Shape=&R;
    Shape->intersec(R,T);//intersec Rectangle
    
    return 0;
}

#include <variant>
#include <iostream>
 
struct line {};
 
struct arc {};
 
struct intersects_algo
{
    bool operator()( const line&, const line&) const
    {
        std::cout<<"line vs line\n";
        return true;
    }
    bool operator()(const arc&, const arc&) const
    {
        std::cout<<"arc vs arc\n"; 
        return true;
    }
    bool operator()(const line&, const arc&) const
    {
        std::cout<<"line vs arc\n"; 
        return true;
    }
    bool operator()(const arc& a, const line& l) const
        { return this->operator()(l, a); }
};
 
using element = std::variant<line, arc>;
 
bool intersect(const element& e1, const element& e2 )
{
    return std::visit(intersects_algo(), e1, e2 );
}
 
int main()
{
    const element e1 = line {};
    const element e2 = arc {};
    const bool result = intersect(e1, e2);
    std::cout << "trsult: " << result << '\n';
}