Теоретические основы (с тестов)

#include <iostream> 
using namespace std; 
 
class A{ 
public: 
    virtual ~A() {} 
}; 
 
class B: public A{ }; 
 
int main(){ 
    A * a = new A(); 
    try{ 
        B * b = dynamic_cast<B *>(a); 
    }catch(...){         
    }     
    return 0; 
}

A * a = new B();

class Base { 
    public: 
        void method1(); 
    protected: 
        void method2(); 
    private: 
        void method3(); 
}; 
 
class Child : public Base { 
    protected: 
        void method1() { } 
        void method2() { } 
        void method3() { } 
}; 
 
int main() {  
    Base* base = new Child(); 
    base->method1();         // 1 
    base->method2();         // 2 
    base->method3();         // 3 
    return 0;  
}

        void method1(); 
        void method2(); 
        void method3();

#include <iostream> 
 
class A{ 
    public: 
    virtual void foo() = 0; 
}; 
 
void A::foo() { std::cout << "A foo"; } 
 
class B : public A{}; 
 
class C : public A{ 
    public: 
    void foo(); 
}; 
 
void C::foo() { std::cout << "C foo"; } 
 
class D: public A{ 
    public: 
    void foo(); 
}; 
 
void D::foo() { A::foo(); } 
 
class E: public A{ 
    public: 
    //using A::foo; 
    void foo(int) { std::cout << "E foo"; } 
}; 
 
int main(){ 
    (new A)->foo();  // 1 
    (new B)->foo();  // 2 
    (new C)->foo();  // 3 
    (new D)->foo();  // 4 
    (new E)->foo(2); // 5 
}

    B* b = static_cast<B *>(a);

... 
class A{}; 
class B: public A {}; 
... 
A * a = new B(); 
std::cout<<typeid(a).name();

class A{ 
    public: 
    virtual void foo() = 0; 
};
class E: public A{ 
    public: 
    //using A::foo; 
    void foo(int) { std::cout << "E foo"; } 
};

void foo();