🚀 go-pugleaf

David L wrote:

> typedef std::vector <TMyObject*>             V_MyObject_LST;
> typedef std::vector <TMyObject*>::iterator   V_MyObject_Iterator;
> 
> is it possible to share a dynamic list (size between 5000000 and
> 8000000) of these objects in a dll for 3 .exe that need same datas ?

I'd be a little loathe to do that. Such data types are language
specific and even compiler specific. Accessing them through shared
memory would pretty much rely on the executable code of each DLL/client
being generated by the same compiler. I also imagine it would put a
horrible burden on you and other developers to locate and manipulate
the data correctly.

One the of the main benefits of DLLs is that they can be language and
compiler agnostic. As soon as a DLL exports (explicity through the API
or implictly through shared memory) anything beyond simple types that
benefit is lost. In the case of shared memory I think you are also
relying on the clients to understand and respect the layout of complex
structurs in memory. It's bad enough having to do that for yourself but
expecting/trusting other people to do it scares me :)

Unless performance is absolutely, 100% critical I would always far
rather use access functions. By that I mean you export iteration
functions like this:

// DLL code
  int Object_ListBegin()
  {
    return 0;
  }
  int Object_ListEnd()
  {
    return OBJECTLIST_END_MARKER;
  }

  void Object_ListIncrement( int * ObjectHandle )
  {
    if( ( *ObjectHandle!=Object_ListEnd() )&&
        ( *ObjectHandle+1<V_MyObject_LST.size() ) )
      ++( *ObjectHandle );
    else
      *ObjectHandle=ObjectListEnd();
  }       

// Example method call:

  double Object_GetData1( int Handle )
  {
    return V_MyObject_Lst[ Handle ]->GetData1();
  }

Of course you'd probably want to add more validation for the above code
but I hope it conveys the idea.

BTW:Are you sure you want to populate your std::vector with /pointers/
to objects? It is usually better to populate the std::vector with
object instances so that the std::vector can take full ownership and
save you having to worry about correct allocation/deallocation. The
example class you've posted here will store quite nicely in a
std::vector. Of course not all classes will but it's always possible to
create a copy ctor and assignment operators. The additional work for
such classes is usually outwheighed by the advantage of not having to
worry about ownership semantics.
-- 
Andrue Cope [TeamB]
[Bicester, Uk]
http://info.borland.com/newsgroups/guide.html