Чем отличаются dynamic_cast и static_cast?

#include <iostream>
 
 
 
class abc
{
public:
    virtual ~abc() {}
};
 
 
 
class def : public abc
{
public:
    ~def() {}
};
 
 
 
template <typename T_TypeTo, typename T_TypeFrom>
void test_casting(T_TypeFrom *p)
{
    std::cout << std::boolalpha << (NULL != dynamic_cast<T_TypeTo>(p)) << std::endl;
}
 
 
 
int main()
{
    abc *pAbc    = new abc();
    def *pDef    = new def();
    abc *pAbcDef = new def();
 
    test_casting<abc *>(pAbc);
    test_casting<abc *>(pDef);
    test_casting<abc *>(pAbcDef);
    test_casting<def *>(pAbc);
    test_casting<def *>(pDef);
    test_casting<def *>(pAbcDef);
 
    delete pAbcDef;
    delete pDef;
    delete pAbc;
 
    return 0;
}

virtual void Method(Parent* a)
    {
        Child1 object=static_cast<Child1*>(a);
    }

Parent* a=new Child2();

Parent *a = new Parent();

#include <iostream>
 
template <class To, class From>
void cast( From* f )
{
    std::cout << std::boolalpha << (nullptr != dynamic_cast<To>(f)) << std::endl;
}
 
class B
{
public:
    virtual ~B() {}
};
 
class D : protected B 
{
public:
    void f() 
    { 
        B* b = new D(); // ОК
        cast<D*>(b); // true только для public наследования, но компилируется независимо от типа наследования
    }
};
 
int main() {
    
    D d;
    
    // B* b = new D(); // Ошибка компиляции если не public наследование
    
    d.f();
 
    return 0;
}

void foo(int i, char c);

void (int i, char c)