Do not allow additon of more elements into a vector - c++

Question

I need to reserve x number of elements in a std::vector, say 10. Then I need to write some y number of values into it, say 5 (most of the time y < x). Is there a way to say how many values have been written to it and how may are still available?
Example:
Say I allocate 10 elements
std::vector<int> v(10);
But I only fill 7 of these elements
for (unsigned i = 0; i<7; i++)
v[i] = i;
How can I tell that 7 elements have been filled and I still have 3 available?
I tried running
v.size() and v.capacity() but both return 10.

Answer 1

Do you mean something like this?
std::vector<int> a; // dont allocate anything
// allocate memory for 10 elements,
// but dont actually create them. a.size() is still 0.
a.reserve(10);
for(std::size_t i = 0; i < 7; ++i) {
// copy i to a new element at the back
// of the vector. This will never reallocate
// memory, as long as at most 10 elements
// are pushed:
a.push_back(i);
}
// a.size() is now 7

Answer 2

Edit: I added a method using std::unique_ptr.
If C++17 is available to you, how about replacing v's elements by std::optional<int> as follows ?
#include <iostream>
#include <optional>
#include <vector>
#include <algorithm>
int main()
{
std::vector<std::optional<int>> v(10);
for (std::size_t i = 0; i<7; ++i){
v[i] = i;
}
std::cout
<< (v.size() - std::count(v.cbegin(), v.cend(), std::nullopt))
<< " elements have been filled and I still have "
<< std::count(v.cbegin(), v.cend(), std::nullopt)
<< " available."
<< std::endl << std::endl;
for(const auto v_i : v)
{
if(v_i.has_value()){
std::cout << v_i.value() << " ";
}
}
return 0;
}
But if you are constrained by an older version, I think that std::unique_ptr would be a solution.
DEMO:
#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>
int main()
{
std::vector<std::unique_ptr<int>> v(10);
for (std::size_t i = 0; i<7; ++i){
v[i] = std::make_unique<int>(i);
}
std::cout
<< (v.size() - std::count(v.cbegin(), v.cend(), nullptr))
<< " elements have been filled and I still have "
<< std::count(v.cbegin(), v.cend(), nullptr)
<< " available."
<< std::endl << std::endl;
for(const auto& v_i : v)
{
if(v_i){
std::cout << *v_i << " ";
}
}
return 0;
}
Finally, I found similar approaches here.

Answer 3

I need to reserve x number of elements in a std::vector, say 10.
std::vector has a reserve() method for that exact purpose.
Then I need to write some y number of values into it, say 5 (most of the time y < x). Is there a way to say how many values have been written to it and how may are still available?
The vector's capacity() is the number of elements have been allocated total, whereas its size() is the number of allocated elements that have been populated with values. So, capacity() - size() is the number of available elements that have been allocated but not assigned.
I tried running v.size() and v.capacity() but both return 10.
That is because you are calling the vector constructor that allocates AND populates elements at the same time. You are creating a vector named v that has 10 elements populated with 0. That is why size() and capacity() are both 10. None of the constructors will do what you want. You need to use the default constructor and then call reserve() separately, eg:
std::vector<int> v;
v.reserve(10); // capacity = 10
for (int i = 0; i < 7; ++i)
v.push_back(i);
size_t filled = v.size(); // size = 7
size_t available = v.capacity() - v.size(); // available = 3