Can you create an array/vector of resizable containers?

Can you create an array of templated, resizable containers? For example, would this array work?

Code:

---

TemplatedContainer<ExampleClass>* ptr;

ptr = new TemplatedContainer<ExampleClass>[value];

---

If my logic is correct, this should work initially, because it will initialize each object in the array to a specific size, but when you try to resize one of the containers it will mess up the array because the memory addresses are contiguous. Am I correct here?

If this is the case, would a vector work?

Code:

---

std::vector<TemplatedContainer<ExampleClass> > example;

---

When you resized one of the objects in the vector, would it properly resize the vector as well, even though you aren't pushing or popping any objects?

That depends on how the container is implemented.

Meaning...?

The templated container should not itself ever physically change size. The memory it manages however might grow/shrink dynamically. A vector for instance is a container that can hold elements whose number can grow or shrink on the demands of the user. The vector itself never changes size, its size is fixed regardless of how many objects it manages. As the vector "grows" or "shrinks" it is really the memory that the vector manages which does the shrinking and growing, not the vector itself. So, an array of vectors for instance has a fixed size as does a single vector but the individual vectors may manage an ever changing number of elements themselves.

Well, suppose TemplatedContainer contained only a pointer to the given type and a current size. In that case when it changes size this will not change the size of the objects stored in the array or vector, it will only change the amount of storage used from the heap.

Quote:

---

Originally Posted by hk_mp5kpdw

The templated container should not itself ever physically change size.

---

More generally, sizeof(T) where T is anything, is a constant.

Quote:

---

Originally Posted by LyTning94

If my logic is correct, this should work initially, because it will initialize each object in the array to a specific size, but when you try to resize one of the containers it will mess up the array because the memory addresses are contiguous. Am I correct here?

---

No.
The TemplatedContainer objects will be contiguous within the array (or vector), but the data that the pointers inside those containers point to would normally be unchanged and still pointing to the effectively arbitrary memory address that it obtained from 'new'. It does depend on how the TemplatedContainer is implemented though, and whether it has sensible copy-constructor, assignment operator, move-constructor, and move-assignment operators.

How about you tell us what this TemplatedContainer is? Show the code if it's something you made.

I did not write the code myself, but here is the grow array function which is called each time an object is added to the container:

Code:

---

template <class T>
void FFreeListTrashArray<T>::growArray()
{
        FFreeListTrashArrayNode* pOldArray;
        int iOldNumSlots;
        int iI;

        assert(m_pArray != NULL);

        pOldArray = m_pArray;
        iOldNumSlots = m_iNumSlots;

        m_iNumSlots *= FLTA_GROWTH_FACTOR;
        assert((m_iNumSlots <= FLTA_MAX_BUCKETS) && "FFreeListTrashArray<T>::growArray() size too large");
        m_pArray = new FFreeListTrashArrayNode[m_iNumSlots];

        for (iI = 0; iI < m_iNumSlots; iI++)
        {
                if (iI < iOldNumSlots)
                {
                        m_pArray[iI] = pOldArray[iI];
                }
                else
                {
                        m_pArray[iI].iNextFreeIndex = FFreeList::INVALID_INDEX;
                        m_pArray[iI].pData = NULL;
                }
        }

        delete [] pOldArray;
}

---

So the size of the array here never changes because all it does is change the memory m_pArray is pointing to? That would mean that creating an array like my first example above would work, right?

Code:

---

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> intVect(20);
    std::vector<char> charVect(20);

    std::cout << "sizeof(intVect)  is " << sizeof(intVect)
              << " and it stores " << intVect.size()
              << " elements" << std::endl;
    std::cout << "sizeof(charVect) is " << sizeof(charVect)
              << " and it stores " << charVect.size()
              << " elements" << std::endl;

    std::cout << "\nDoubling size of vectors\n" << std::endl;
    intVect.resize(intVect.size()*2);
    charVect.resize(charVect.size()*2);

    std::cout << "sizeof(intVect)  is " << sizeof(intVect)
              << " and it stores " << intVect.size()
              << " elements" << std::endl;
    std::cout << "sizeof(charVect) is " << sizeof(charVect)
              << " and it stores " << charVect.size()
              << " elements" << std::endl;

    return 0;
}

---

The output of this is below. Notice the size of the vectors remains constant regardless of what type of data it stores (char or int) and regardless of how many elements it is storing (after the resize operation).

In the case of the intVect, the vector's size is 20 bytes and it manages (initially) 20 ints each of which are 4 bytes in size. Therefore it manages 80 bytes worth of space and takes up 20 bytes itself.

An array of such containers is therefore going to be some fixed size equal to whatever the size of one container is multiplied by how many of them are in your array. This size will not change no matter how many objects the individual array elements (the vectors) are themselves managing.

You shouldn't have any array/memory address issues.

you should probably stick with the already provided containers, e.g.

Code:

---

vector< vector<int> > vectorOfVectors;

---

works fine. don't reinvent the wheel.