Re: object arrays and constuctors

tripleF wrote:


Unfortunately, you cannot do so directly. You would have to do
something like this:

Object ** ppSprite = new Object*[5];
for (int i=0; i<5; ++i) {
   ppSprite[i] = new Object(1,1);
}

But it would probably be in your best interest to use a vector.

vector<Object*> cpSprite;
for (int i=0; i<5; ++i) {
   cpSprite.push_back(new Object(1,1));
}

Note, I use a 'c' prefix to indicate a container. It is not standard
notation. Though Hungarian notation is seldom standard. ;)

Make sure you delete all elements in the array/vector prior to deleting
the array/vector or you will have a memory leak.

There are a few reasons why not to have an aggregate object container,
i.e. new Object[5].

1. If Object is a base class, all inherited objects may not fit as they
    can add attributes to the base class implementation.
2. If you will _never_ inherit from this base class, it is somewhat
    tricky to initialise it correctly. IIRC an array will by default,
    init all elements by the default constructor (if one is available),
    unless you specify the initialisation of each element. I.e.:

      Object array[5] = { Object(1,1), Object(2,3) };

    will init the first two elements using the constructors stated, but
    the last 3 will be initialised via the default constructor. I think
    if the array is of a type that has no constructor and no init list is
    specified, then the memory state is undefined in the array. Note,
    you *cannot* do this:

      Object* pArray = (new Object[5] = { Object(1,1), Object(2,3) });

    though it would be cool if you could.

    A vector can have an arbitrary init object to copy from using the
    constructor:

      vector( size_type num, const TYPE& val = TYPE() );

    or by copying from an already existing containing type that uses
    iterators via the constructor:

      vector( input_iterator start, input_iterator end );

    but those elements are initialised by copying that object/those
    objects most likely using the copy constructor over untyped
    memory[*], which means that that object/those objects from where the
    vector is copying from would have to be constructed previously. This
    might not be bad if the array being copied from was constructed at
    startup. However if this init array is constructed in the function
    that is dynamically creating the vector, it could increase the
    allocation time by 2 (or more in a bad vector implementation).

The decision, as always, is up to the programmer. There may be good
reason to do this, you just need to determine if it is good enough.

Adrian

[*] This is a most likely scenario but I think it is implementation
     dependent. By untyped, I mean that the memory used to store the
     data has no type associated with it that will call a constructor on
     it (like char). Again this is implementation specific and if you
     don't know what I am talking about, just know that to copy, you
     first have to have something to copy from.
--
  _____________________________________________________________________
  \/Adrian_Hawryluk BSc. - Specialties: UML, OOPD, Real-Time Systems\/
   \ My newsgroup writings are licensed under a Creative Commons /
    \ Attribution-Share Alike 3.0 License /
     \_______[http://creativecommons.org/licenses/by-sa/3.0/]______/
      \/_______[blog:_http://adrians-musings.blogspot.com/]______\/

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]