Thread: Can you create an array/vector of resizable containers?

That depends on how the container is implemented.

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.

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.

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.

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.