variable length array of classes.

Question

I have some code which is effectively this:

class dummie_type
{
    public:
    int a;

    void do_stuff()
    {
        // blah
    }
};

class dummie_type dummie[10];

void main()
{
    subroutine();
}

void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[5].do_stuff();
}

Note that the array of classes is global, and I need it to remain so (its a long story). I need to change this code so that the array of classes is of variable length. I know that this will involve making a global pointer, and then setting that to point to a block of memory that gets malloc'ed or new'ed in main and I know that I will have to change the "." characters to "->" but other than that I keep failing to produce something that my compiler will accept. I'm particularly uncertain about the declaration of a global pointer to an array of classes.

Edit: Sorry I should have said earlier, the array size will be calculated once near the start of main() and will remain unchanged from then on.

Answer 1

could you just change it so that's it's a vector?

std::vector<dummie_type> dummie;

int main() {

    //populate();
    //showing alternative loop based approach
    populateWithLoop(calc_size());
    subroutine();
 }

void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[1].do_stuff();
}

void populate() {

   dummie_type a;
   dummie_type b;
   dummie_type c;

   dummie.push_back(a);
   dummie.push_back(b);
   dummie.push_back(c);

   //will print out 3
   std::cout << dummie.size() << std::endl;

   dummie_type d;
   dummie.push_back(d);

   //will print out 4
   std::cout << dummie.size() << std::endl;


}

populateWithLoop(int n) {

   for(int i=0; i<n; i++) {
       dummie_type temp;
       dummie.push_back(temp);
   }
}

You can treat a std::vector pretty much like an array, so any existing code will still continue to work. You get the advantages of a variable length array without the downside's of having to manually manage the memory.

Edit: updated to show Mick how to populate the vector and get it's size.

Answer 2

I know that this will involve making a global pointer, and then setting that to point to a block of memory that gets malloc'ed or new'ed in main and I know that I will have to change the "." characters to "->" but other than that I keep failing to produce something that my compiler will accept. I'm particularly uncertain about the declaration of a global pointer to an array of classes.

That's basically all there is to it. You declare dummie as dummie_type * dummie; and then you do dummie = new dummie_type[size]; in main. And no, you don't need to change . to ->.

Answer 3

Use an array of POINTERS to objects of your class.

Using std::vectors, it could be something like

typedef dummie_type * dummie_ptr;
typedef vector<dummie_ptr> dummie_array;

Of course, you will have to search through all your code to replace a lot of .s with ->s. But that way, you can resize the array without calling the constructor and destructor a lot of times.

Here's an example

int main(int argc, char* argv[])
{
    dummie_array my_array(5); // initial size

    for (int i = 0; i < 5; ++i)
         my_array[i] = new dummie_type(/* constructor parameters */);

    my_array.resize(8);
    for (int i = 5; i < 8; ++i)
         my_array[i] = new dummie_type(/* constructor parameters */);

    for (int i = 0; i < 8; ++i)
         my_array[i]->do_something(/* member function parameters */);

    for (int i = 0; i < 8; ++i)
         delete my_array[i];

    return 0;
}

Answer 4

If you were to implement this as a vector, as Glen has suggested, when you need to do your one-time allocation near the beginning you would reserve(), e.g.:

int slots_i_need = 0;
if (/* ... */)
   slots_i_need = 4096;
else
   // ...
// ...
dummie.reserve(slots_i_need);

A minor efficiency would be to test whether the initial capacity allocated by the compiler is sufficient for your needs. In that case, you wouldn't need to reallocate. A vector's initial capacity is reserved during the first push_back:

// ...
dummie_type a_dummie = new dummie_type();
dummie.push_back(a_dummie);
if (slots_i_need > dummie.capacity())
   dummie.reserve(slots_i_need);
else
   {} // nothing to do.