Re: Question about OO programming in Ada

[Chad Bremmon <bremmon@acm.org>]

I miss Ada, and it's been a while, but not that long.

C++ piles a lot of crap, pardon the French into the definition for a 
class.

Somewhere, there is a well documented mapping of UML to Ada95, which is 
really what you're trying to ask for.

Since I'm relatively unemployed right now, if I get resounding request 
for it, I could write an OO primer for Ada95.

I know they're out there, but I haven't seen anyone point you right to 
one.

For now I can tell you these things:

1) class wide types are only valuable for dynamic polymorphism

This means that it MUST be a linked list of classwide variables, and the 
compiler cannot possibly know what the type is going to be.

2) to get OO stuff like inheritance, you must declare your operations 
directly after the tagged type definition

3) whether you pass an access or an in/inout, (Has nothing to do with OO 
really.  Everyone else is right.  Stay away from access types unless you 
need them) depends on what you're doing with the tagged type once it is 
passed in.  If it is further used, and the variable (on the stack) may 
become unsafe, then you have to pass an access type so that when the 
program returns, the procedure can't possibly have kept a pointer to 
something on the stack and tried to use it after the variable has been 
popped off the stack

I know I'm babbling...
Here are key OO features and their associated Ada95 features
1.  Inheritance - tagged types
2.  Encapsulation - private types
3.  Polymorphism - 'Class - also access types
4.  Abstraction - packages

That's my penny and a half about it.

Thanks,
Chad
Ekkehard Morgenstern wrote:
> Hi guys,
> 
> I have a question about object-oriented programming in Ada:
> 
> Do I have to use class-wide types for object-oriented programming, or could
> I use regular access types?
> 
> Like, when I declare a procedure
> 
>     procedure A ( B: in access all T'Class )
> 
> could I use a different method and still get all the benefits of Ada
> object-oriented programming?
> 
> Like, what about:
> 
>     procedure A ( B: in access all T )
> 
> or
> 
>     procedure A ( B: in out T )
> 
> or
> 
>     procedure A ( B: in T )
> 
> Also, if I use access types, should I create new types or declare them
> directly in the procedure/function, and what about the 'all' access
> qualifier, should I create two types of access types (one with 'access' and
> one with 'access all'), or should I declare them directly in the procedure
> and decide individually what kind of access I need?
> 
> I would like to program as cleanly as possible in Ada right from the start,
> so I'd be glad if someone could give me some hints. :-)
> 
> 
>