Re: Basic Explaination of OO in Ada

[Maciej Sobczak <no.spam@no.spam.com>]

Ludovic Brenta wrote:


> Here's another interesting tip for C++ programmers. In C++, once you
> declare a member function to be "virtual", all calls to that member
> function dispatch  dynamically, across the entire program.

Except when you ask it otherwise by qualifying the function name at the 
call site, see below.

> Conversely,
> if a member function lacks the "virtual" keyword, calls to it are
> always static. The only way you can determine whether calls dispatch
> statically or dynamically is by looking at the declaration of the
> member function. Things can become quite nasty if a class overrides an
> inherited, non-virtual member function, and makes it virtual.

Yes, it becomes nasty. It's a classical no-no for C++ programmers.

> I'm not
> even sure what the language rules are in this case.

The static type used to call determines whether it dispatches or not, 
because it's the static type (of the pointer or reference) that allows 
to check whether the function is virtual.

> In contrast, in Ada, you do not declare primitive operations as
> "virtual", or "dynamic" or whatever. Instead, you choose *at the point
> of call* whether or not the call dispatches. Consider:
> 
> with Pak; use Pak;
> procedure Test (Object : in out T'Class) is
> begin
>    P (Object); -- dynamic dispatch
>    P (T (Object)); -- view conversion to a specific type => static
> dispatch
> end Test;

Similar for C++:

p->fun(); // dynamic dispatch if in *p fun is virtual
p->BaseClass::fun(); // no dynamic dispatch


-- 
Maciej Sobczak : http://www.msobczak.com/
Programming    : http://www.msobczak.com/prog/