CODEWITHSUNDEEP
c++vectorallocation
Shadi Iskander
Shadi Iskander

Reputation: 57

Can I keep vector data even after out of scope

I come from a C background. I used to allocate memory/array, for example, sending it to somewhere else, and the pointer stayed there, even after, the scope where it was allocated was destroyed.

Now, if I do the same with vectors : initialize, pass it by reference, and then keep that reference saved somewhere. After the initial method, that actually created the vector, goes out of scope, would it be destroyed ? Or as the pointer to it is still saved, it will be kept.

Upvotes: 3

Views: 4227

Answers (4)

atabb
atabb

Reputation: 1

The existing answers are good, will add here:

block A
{
vector<int> my_vec(10, 0);
//...something...
}
block B

The my_vec vector will go out of scope and be destroyed at the closing bracket. Now that's stl (Standard Template Library) vectors.

You can also use C-style arrays (but with different syntax). For very large arrays, I have found the allocation time with a dynamically-allocated array to be faster than STL vectors. 

//static, goes out of scope and memory handled at the end of code block
int arr0[10];

//dynamic, not destroyed unless delete called.
int* arr1 = new int[10];
//...work with arr1...
delete [] arr1;

Just like in C, you need to take care of de-allocating any memory you create using new.

Upvotes: 0

Lightness Races in Orbit
Lightness Races in Orbit

Reputation: 385164

No if I do the same with vectors, I initialize a vector, pass it by reference, then keep the reference saved somewhere. After the initial method that actually created the vector goes out of scope, would it be destoryed?

Yes.

or because a pointer to it is still saved it will still be kept?

No.

You can have dangling pointers in C++ just like you can in C. It's exactly the same.

This is also often the case for references (though in some cases the lifetime of the object is extended for a little bit).

It is true that the vector's data is internally managed by the vector, but that's by-the-by since you're asking about the vector itself. Forget the vector and ask the same question about an int, then you'll realise the answer is just as you'd expect it to be in C.

Upvotes: 1

Max Vollmer
Max Vollmer

Reputation: 8598

std::vector frees the memory it holds when it is destroyed. Holding a reference to an object that gets destroyed is very bad. Accessing it is UB. General rule: Do not store references, only use them where you can be sure that the object exists for the entire scope, e.g. as parameter of a function.

If you want to keep a copy of the data, simply copy the std::vector. No reference needed.

If you want to be able to access the data from different locations, and have it live as long as at least one location still has a reference/pointer to it, don't use std::vector, use std::shared_ptr.

If you want to combine the benefits of std::vector with the benefits of shared memory that lives until the last place lets go of it, combine them: std::shared_ptr<std::vector<...>>.

If you want to have the std::vector live in one place for a bit, and then live in another place but not in the first place anymore, use move semantics:

std::vector<int> foo = {1, 2, 3};
std::vector<int> bar = std::move(foo); // bar now holds the data that foo held, foo is empty, no copy was performed

Upvotes: 8

463035818_is_not_an_ai
463035818_is_not_an_ai

Reputation: 122458

A pointer to an array on the stack will not keep the array alive, I suppose thats the same in C. Now a vector is not an array. It is a wrapper around a heap allocated array which frees the memory of the array when it goes out of scope.

... because a pointer to it is still saved it will still be kept?

No! A pointer or reference to a std::vector will not keep the vector alive. The canonical wrong example is:

std::vector<T>& foo() {
    std::vector<T> x;
    return x;
}                      // baaam !

The reference returned from the function is dangling. YOu cannot do anything with it. The correct way would be to return by value and rely on return value optimization:

std::vector<T> foo() {
    std::vector<T> x;
    return x;
}

If you do:

auto y = foo();

No copying is involved, thanks to NRVO.

PS: Compilers should warn you about returning a reference to a local variable.

Upvotes: 5

Related Questions