Почему не работает?

# include <iostream>
class Base{
public:
    Base(){
    std::cout<<"In constr"<<std::endl;
    }
    const char* eat;
    void eating(){
    eat="Apple";
    std::cout<<eat<<std::endl;
    }
 
};
 
class Derived:protected Base{
public:
    int Sp;
    Derived(){
    std::cout<<"In cinsttr"<<std::endl;
    }
        void Speed(){   
            Sp=35;
            std::cout<<Sp<<std::endl;
    }
 
 
};
 
int main(){
 
Base* pBase;
pBase=new Derived;//  error
 
 
system("pause");
return 0;
}

#include <iostream>
 
 
 
class A 
{
    public: A(){}
    virtual ~A(){}
    
    void work() 
    {
        std::cout << "A::work beg" << std::endl;
        for(auto& el: arr)
            el = 1;
        std::cout << "A::work end" << std::endl;
    }
    char arr[255];
};
 
class B
{
    public: B(){}
    virtual ~B(){}
    
    void work() 
    {
        std::cout << "B::work beg" << std::endl;
        for(auto& el: arr)
            el = 1;
        std::cout << "B::work end" << std::endl;
    }
    
    int arr[255];
};
 
// при множественном наследовании
class C: protected B, protected A
{
    public: 
    C()
    {
        // --- мы видим, что адреса подобъектов разные
        // --- адреса B* и A* выполнены с некоторым смещением
        // --- это вполне закономерно
        // --- ведь класс С должен вместить в себя и A и B
        // --- и они не должны накладываться друг на друга.
        
        // --- в обычной жизни, компилятор зная о множественном наследовании
        // --- самостоятельно выполнит корректировку адреса
 
        A* a = this;
        B* b = this;
        C* c = this;
        
        std::cout <<"address A: " << a << std::endl;
        std::cout <<"address B: " << b << std::endl;
        std::cout <<"address С: " << c << std::endl;
    }
    virtual ~C(){}
};
 
 
 
void foo(A& a)
{
    std::cout <<"my real address: " << &a << std::endl;
    
    a.work();
}
 
int main()
{
    C c;
    
    // однако, reinterpret_cast не учитывает возможные смещения
    A& a = reinterpret_cast<A&>(c);
    
    // на примере мы видим,
    // что адрес C совпадает с B
    // а вовсе не с А
    // таким образом получаем невалидную ссылку
    foo(a);
}

pBase = (Base*)new Derived;

class B {
public:
int mi; // non-static member
static int si; // static member
};
class D : private B {
};
class DD : public D {
void f() ;
};
void DD:: f() {
mi = 3; // error: mi is private in D
si = 3; // error: si is private in D
:: B b;
b. mi = 3; // OK (b. mi is different from this->mi)
b. si = 3; // OK (b. si is different from this->si)
:: B: : si = 3; // OK
:: B* bp1 = this; // error: B is a private base class
:: B* bp2 = (:: B*) this; // OK with cast
bp2->mi = 3; // OK: access through a pointer to B.
}

pBase = (Base*)new Derived;