"Dmitry A. Kazakov" <mailbox@[EMAIL PROTECTED]
> writes:
> On Sat, 25 Feb 2006 15:05:02 GMT, Matthew Heaney wrote:
>
> > But you can pass in an Initialize procedure as a parameter of an
insertion
> > operation, to perform whatever initialization needs to be done.
>
> You mean "return .. do" for limited types.
For an unbounded form, you could do it either way, via an Initialize
procedure,
or via a Copy function (using the new return do syntax).
For a bounded form, only an Initialize procedure would work, since the
actual
initialization of the elements happens only once, when the (bounded)
container
object is elaborated.
> It is in-place, but a constructing function does not have safety of a
> constructor.
Huh? An Ada 2005 constructor function *is* a constructor. It's no
different
from a copy ctor in C++.
> Then you cannot ask it from the type, so it can't have a default
> [deduced from the type.]. It is not dispatching in Insert.
Aren't constructors always non-dispatching (unless you're using a Factory
Method pattern)? But this is no different from the C++ STL.
If you have an container (of indefinite elements) instantiated with
(limited)
type T'Class, then I suppose you might want to have a dispatching
constructor.
I'd have to think about how to do that[but see below]. (In my earlier
example
I was really thinking of bounded forms, which cannot have indefinite
elements.)
> What about container of class-wides, i.e. when Node_Type should have
> ET'Class?
Only applies to unbounded containers whose elements are indefinite. GCC
allocates each indefinite element (so Node_Type has a pointer to ET).
In general there's never any direct dispatching inside a generic, since
the
generic formal region doesn't pass in any operations, the formal type
isn't
tagged, and formal operations must be statically bound to the element
type.
If you wanted a contructor to dispatch, you'd have to say (assuming my
knowledge of Ada 2005 is correct):
type ET is tagged limited private;
function Copy (E : ET) return ET; -- primitive op
function Copy_Classwide (E : ET'Class) return ET'Class is
begin
return Copy (E); -- legal Ada 2005?
end;
Then you pass this in as per the example of my earlier post:
package List_Types is
new Limited_Indefinite_Lists (ET'Class);
...
procedure Op (L : in out List) is
begin
...
L.Insert (...New_Item => E, Copy => Copy_Classwide...);
...
end;
Then the primitive Copy operation will dispatch according to the tag of
actual
parameter E. This is always what you do inside a generic to enable
dispatching
(when the generic formal type is non-tagged and indefinite).
> ... and of course passing pointers to functions is ugly.
This is not an argument. The existing API already has function pointers
everywhere, so you might as well get used to it.
|
