Re: how to store list of varying types

"Nick Schultz" <nick.schultz@flir.com> ha scritto nel messaggio
news:ekB5f1Y0IHA.4500@TK2MSFTNGP03.phx.gbl...


I would need more details, but in general I would say that in C++, I prefer
using std::vector as container (instead of raw pointer), and std::wstring or
some other string class instead of char*.

Moreover, there is a usual naming convention in C++, that class names start
with an upper-case letter (so, I would use DataElement instead of
dataElement).
Lower-case tends to be used for other cases, like class instances.
e.g.

   // Instantiate a DataElement
   DataElement dataElement;

So, I would define a class or a struct like this:

  class DataElement
  {
   public:

       std::vector< BYTE > Data;

       // You don't need a size-in-bytes field here,
       // because vector has a size() method for
       // that purpose.
       // So Data.size() gives you that size.

      // I assume that your "field names" here are ANSI only.
      // For Unicode, you may use std::wstring.
      std::string Name;
  };

Then I would store all these DataElement's in a vector like this:

 typedef std::vector< DataElement * > DataElementList;

 DataElementList myDataElements;

Note that the vector stores *pointers* to DataElement instances.
If these pointers have a shared ownership semantic, I would wrap them in a
smart pointer like shared_ptr.
e.g.

  typedef boost::shared_ptr< DataElement > DataElementSP;
  typedef std::vector< DataElementSP > DataElementList;

In that way, you don't have to pay attention to DataElement destruction (the
shared_ptr smart pointer stores a reference count, and when it gets 0, the
object is automatically deleted).


In C++, you would use new[] instead of malloc(), or a robust container like
std::vector.

 SomeType * p = new SomeType[ count ];

 std::vector< SomeType > v[ count ];

From vector, you can have the pointer to the first element using:

  SomeType * pFirst = &v[0];

If you use new[], you must also delete (sooner or later) your data, using
delete[].
Instead, vector has a destructor that does cleanup.

Moreover, vector can safely grow its size if necessary (e.g. after a
..push_back( <new data> ); ), and it's guarded against buffer overruns (which
are security enemy #1).
Instead, using raw new[], you may have lots of problems like off-by-one
index, or index completely out-of-range, corrupting nearby memory, etc.
It's not that you must not use new[]: you may use new[], but you (or those
who will mantain your code) must pay lots more attention, and the code is
less robust, more fragile, thant using a robust C++ container class like
std::vector.

Note that there are also MFC versions of the classes I mentioned in this
post: you can use CString to store strings, and CArray template instead of
std::vector.
(AFAIK, MFC has no equivalent of smart pointer like shared_ptr...).

HTH,
Giovanni