In C++'s STL you can reserve() a specific capacity for the std::vector to use, and at the end of your operation you can trim off the remaining memory using shrink_to_fit():
std::vector<int> elems;
elems.reserve(max_bound_num_of_elems);
// do some push_back()'s
elems.shrink_to_fit();
That can do almost anything (including reallocating), so you can’t really rely on it:
“Requests the container to reduce its capacity to fit its size.
“The request is non-binding, and the container implementation is free to optimize otherwise and leave the vector with a capacity greater than its size.
“This may cause a reallocation, but has no effect on the vector size and cannot alter its elements.”
Yes. You can make a slice with zero length but the required capacity and append to it as you go. You can also make a slice of the estimated length and then reslice to the actual length.
In the append case, since the underlying slice has capacity, then each append will just extend the length. If estimated length was too small, then reallocation would occur.
In the reslice case, the new slice is a value type that points to the original underlying memory, with a length that is shorter. So no reallocation.
Interesting idea. I am not sure that such is available in Go. In Go, with slices, once the backing array has been allocated, I don’t think you can deallocate some at the end of it. But I might be wrong.
There is a difference in Go’s slices between length and capacity. Length is the number of elements in the slice, and capacity is the number of elements that can fit in the backing array (so len <= cap).
