Solving munmap_chunk(): invalid pointer error in c++ - c++

Question

I was trying to get used to the dynamic array in class to which I get the result to the output but get a core dump error.I get the output correct but at last of the output after compiling I get this core dump.
Output is
Enter the size of array: 4
Enter the numbers of array: 20
21
22
23
The element of the array is
20
21
22
23
munmap_chunk(): invalid pointer
Aborted (core dumped)
Here is the program I wrote:
class Array
{
private:
int *arr;
int size;
public:
Array(int sizes, int at[])
{
size = sizes;
arr = new int[size];
for (int i = 0; i < size; i++)
{
arr[i] = at[i];
}
}
Array()
{
size = 0;
}
~Array()
{
std::cout << "Destructor worked.";
delete[] arr;
}
void getarray()
{
std::cout << "Enter the size of array: ";
std::cin >> size;
setsize(size);
std::cout << "Enter the numbers of array: ";
for (int i = 0; i < size; i++)
{
std::cin >> arr[i];
}
}
void setsize(int sizes)
{
size = sizes;
}
void output(std::ostream& outs)
{
outs << "The element of the array is " << std::endl;
for (int i = 0; i < size; i++)
{
outs << arr[i] << std::endl;
}
}
};
I am still not good at dynamic array and I thought of using vectors. It will be great if anyone can show me what the problem with this problem is or any easier method for doing the same.

Answer 1

Assuming that your main() is somewhat like:
int main(void) {
Array foo; // or Array foo(bar, baz);
foo.getarray();
foo.output(std::cout);
}
The main problem here is that your constructor gets called before your getarray() method. And since you are already allocating memory inside your constructor,
void getarray() {
...
// Changing size, and iterating over it
...
}
is dangerous. If your newSize > size, the loop will try to access memory that does not belong to your program. If your newSize < size, it will not access all the elements.
How to overcome this?
Resize your array when you ask for size again.
Do not allocate memory inside the constructor, but allocate it inside getarr().
Do not resize your array inside getarray() at all, in which case you should not change your size.
All this really depends on the functionality you want to achieve. Say you want to have a fixed-sized array for the entire duration of your program, using a const qualifier with your size will help restrict un-authorized modifications.
If you want arrays which dynamically grow and shrink during your execution, you are better off using the std::vector container.