CODEWITHSUNDEEP
c++vector
TheNotMe
TheNotMe

Reputation: 1058

Vector of vectors, heap versus stack (C++)

I wanted to initialize a vector of vectors that contain pointers to Courses. I declared this:

std::vector<std::vector<Course*> > *CSPlan = 
        new std::vector<std::vector<Course*> >(smsNum);

What I wanted to do by this is to have a vector of vectors, each inside vector is a vector that contains pointers to Courses, and I wanted the MAIN vector to be of size int smsNum. Furthermore, I wanted it on the heap.

My questions are:

  1. Are both the main vector AND the inside vectors allocated on the heap? or is it only the MAIN vector is on the heap and its' indexes are pointers to other smaller vectors on the stack?

  2. I declared it to be of size int smsNum so the Main vector is of size 10, but what about the smaller vectors? are they also of that size or are they still dynamic?

My goal in the end is to have a vector of vectors, both the Main vector and the child vectors on the heap, and ONLY the Main vector is of size smsNum, while the rest are dynamic.

Upvotes: 3

Views: 1125

Answers (1)

Rubens
Rubens

Reputation: 14768

Any structure that can grow as large as the user wants it to is going to be allocated on the heap. The memory stack, on the other hand, is used to allocate statically allocated variables, that the program has control of the size statically, during the compilation process.

Since you can have a loop like this:

for (i = 0; i < your_value; i++) {
    vector.insert(...);
}

And considering your_value as an integer read from the standard input, the compiler have no control on how large will be your vector, i.e., it does not know what is the maximum amount of inserts you may perform.

To solve this, the structure must be allocated on the heap, where it may grow as large as the OS allows it to -- considering primary memory, and swap. As a complement, if you use the pointer to the vector, you'll be simply dynamically allocating a variable to reference the vector. This changes NOT the fact that the contents of the vector is, necessarily, being allocated on the heap.

You'll have, in your stack:

  • a variable "x" that stores the address of a variable "y";

And in your heap:

  • the value of the variable "y", that is a reference to your vector of vectors;

  • the contents of your vector of vectors (accessed by "y", that is accessed by "x").

Upvotes: 5

Related Questions