reimplementing an interface in a derived class

[Alex]

On Friday, 4 January 2019 at 02:13:27 UTC, Neia Neutuladh wrote:
> I can't think of a single class system that works like that. 
> C++, Java, C#, Dart, and TypeScript all work like D here. 
> GObject in C works like D.

In the example below, the "2" of B.foo is printed only once. 
Independently of the cast type, after degrading a B to an A the 
degraded object behaves like an A.

´´´ C++ ´´´
#include <iostream>
class A
{
public:
     int foo(){return 1;}
};
class B : public A
{
public:
     int foo(){return 2;}
};

void performFoo(A *a)
{
     std::cout << a->foo() << std::endl;
}

int main() {
     auto a = new A();
     auto b = new B();
     std::cout << a->foo() << std::endl;
     std::cout << b->foo() << std::endl;
     std::cout << dynamic_cast<A*>(b)->foo() << std::endl;
     std::cout << static_cast<A*>(b)->foo() << std::endl;
     std::cout << reinterpret_cast<A*>(b)->foo() << std::endl;
     performFoo(a);
     performFoo(b);
     return 0;
}
´´´
> The point of OOP is that a bundle of data has particular ways 
> of dealing with it. B has different data (at least 
> theoretically), and that data has different ways of working 
> with it. So if casting to a base class changed something to use 
> the base class's behavior, you'd get bugs almost anywhere you 
> used inheritance, since the derived class's data isn't being 
> modified properly.

Now I have the feeling, I'm missing something elementary... sorry 
for this...
But take the classic example of OOP of an Animal and a Dog: 
Animal.
Let the animal implement some default move and eat behavior.
Let the dog override the move method and implement bark.
If you degrade the dog to the animal by casting it should still 
be able to move and eat, but not bark.

This should always be true for inherited objects as the base 
classes define enough content to manage proper behavior of their 
own. (Given they are not abstract, a function is not virtual and 
so on...)