• Sean Kelly (33/33) Feb 11 2004 One of the things I like about C++ is the basic container concept, where...

Sean Kelly <sean ffwd.cx> writes:

One of the things I like about C++ is the basic container concept, where 
algorithms can be applied to any set of iterators.  It's pretty easy to 
replicate in D for new types, but dynamic arrays as native types 
complicate things a tad.  First, they don't have "begin" and "end" 
properties.  We could change the semantics like so:

iterator i = begin( myarray );

though I havn't decided if I like it yet.  Iterator semantics can be 
preserved, however, because pointers still work like pointers:

int[2] x;
x[0] = 1;
x[1] = 2;
int* end = &x[x.length-1];
++end;
for( int* i = &x[0]; i != end; ++i )
     printf( "%i\n", *i );

That leaves associative arrays, which looks to be a bit more 
complicated, but I think could follow similar principles--the keys and 
values arrays would likely be stored in the iterator, along with an 
index id.

There are still some differences though.  If an iterator has already 
been created, operations on the map won't be reflected in the iterated 
sequence unless the keys and values arrays are requeried.  And I guess a 
side-issue is efficiency.  Are associative arrays hashed containers, 
balanced trees?

I'm starting to think it makes sense to use external functions for just 
about everything, as it fits best with the default types.  And 
module-level access restrictions seem to support this idea.  But are C++ 
style containers the best way to go?  I haven't seen anything better, 
but then I haven't looked very hard.  My principal concern is that it be 
possible to create algorithms that can operate on a sequence returned by 
any container type, and that the semantics be consistent enough that 
they work well with template operations.


Sean