how to delete the unused space in a dynamic array in C++ - c++

Question

i want to take a simple array of string from the user in a dynamic array. If i made the size of the array 1000 for example. how to delete the unused space in the array so that it fits just for the size the user entered without deleting the whole array?

Answer 1

Memory allocators do not typically allow for deallocating parts of allocated memory, and the allocation facilities specified in C++ certainly do not provide any interface to such functionality.
There is a standard function 'realloc' which may allow an allocated block of memory to be, apparently, expanded. However the way this typically works is that the underlying allocator checks to see if previously allocated block of memory is already large enough. That is, when you allocate, say, 1000 bytes, the allocator may provide a chunk of memory that is larger than 1000 bytes.
That hidden 'extra' memory is valid to access just as if you had asked for it, but since you didn't ask for it and don't know how much, if any, extra memory is there, you are limited to only accessing the bytes you actually requested.
realloc will provide to you allocated memory of the new size, with the same contents as the memory pointed to by the parameter you pass to it. It may do this by discovering that the existing block of memory is large enough for the requested new size, in which case it simply returns the same pointer you pass to it. In this case you know there was extra memory and now you can access up to the size you requested.
If there's not enough 'extra' memory, or if the realloc implementation is simple, then realloc will allocate a new block, copy the data into the new block, free the old block, and return the new pointer.
Reducing the amount of memory for an array will pretty much always mean allocating a new, smaller array, copying the content into the new array, and then freeing the old, larger array. For example vector::shrink_to_fit and the old 'swap with empty' trick do this.
If you want to avoid having too much memory allocated, then you should simply avoid allocating too much in the first place. You should just allocate the correct amount to start with.
One side benefit if this approach is that it means you won't engage in the bad practice of, for example, allocating an array of some fixed size which you think is larger than you will ever need:
#include <iostream>
#include <string>
int main() {
std::string user_input[10000]; // should be enough for anyone
int count = 0;
for (std::string s; std::cin >> s;) {
user_input[count] = s;
++count;
}
magic_array_size_reducing_function(user_input, count);
}
The above code is wrong, because the user might exceed the fixed limit and cause the program to break. In fact, any time you see such fixed limits you should be suspicious, and the code probably needs to be fixed. You should also be suspicious of any beginning programming book or course that asks you to do this.
The right way to write this is to not have fixed limits, and instead dynamically increase resource usage as necessary.
#include <iostream>
#include <string>
#include <vector>
int main() {
std::vector<std::string user_input;
for (std::string s; std::cin >> s;) {
user_input.push_back(s);
}
//...
}
Doing this by hand simply means doing the allocation/copy/deallocation dance as necessary. Below is an example where I implement just the bare minimum.
#include <iostream>
#include <string>
struct dynamic_string_array {
int capacity, size;
std::string *user_input;
dynamic_string_array() {
capacity = 0;
size = 0;
user_input = nullptr;
}
~dynamic_string_array() {
delete [] user_input;
}
void push_back(std::string const &s) {
if (size == capacity) {
int new_capacity = capacity ? 16 : capacity * 1.5;
std::string *new_user_input = new std::string[new_capacity];
for (int i = 0; i < size; ++i) {
new_user_input[i] = user_input[i];
}
// ---
delete [] user_input;
user_input = new_user_input;
capacity = new_capacity;
}
user_input[size] = s;
++size;
}
};
int main() {
dynamic_string_array user_input;
for (std::string s; std::cin >> s;) {
user_input.push_back(s);
}
//...
}