Why it is not just enough to use delete [] to delete the 2D dynamically allocated array?

Question

0.00/5 (No votes)

See more:

I have used the following code to create a 2D dynamically allocated array:

int x,y;
    cout<<"Entre matrix dimensions"<<endl;
    cin>>x>>y;

    //Dynamically Allocating x*y array
    int **myArray = new int*[x];              //reserve x row elements
    for (int i = 0; i < x; ++i) {
        for (int j = 0; j < y; ++j) {
            myArray[i] = new int[j];           //makes each one of the reserved row elements points to an array
        }
    }

    //entreing the values
    cout<<"Entre the values"<<endl;
    for (int i = 0; i < x; ++i) {
        for (int j = 0; j < y; ++j) {
            cin>>myArray[i][j] ;
        }
    }

    //Displaying the values
    cout<<"You entred : "<<endl;
    for (int i = 0; i < x; ++i) {
        for (int j = 0; j < y; ++j) {
            cout<<myArray[i][j]<<" " ;
        }
        cout<<endl;
    }

When i tested the previous code, it worked well.But when i tried the following code to deallocate the 2d array:

 //Memory Deallocation
 for (int i = 0; i < x; ++i) {
         delete [] myArray[i];
     }
delete[] myArray;

An error occured:

Heap corruption detected. CRT detected that the application wrote to memory after end of heap buffer

What I have tried:

I have tried to just use

delete[] myArray;

for memory deallocation and the error message did not appear. But i do not know is that right or wrong?

Posted 15-Feb-18 22:14pm

Ahmed AE

Updated 15-Feb-18 23:05pm

Add a Solution

3 solutions

Solution 1

You have allocated the correct memory for your array, so you get this mess. You the error WHEN accessing invalid memory and NOT when deleting (the correct allocated but misused) memory block.

this code should do the job:

C++

int *myArray = new int[x * y];//allocate array of size (fixed the wrong "+" operator to "*"
delete[] myArray;//cleanup

Tip: use memory view window to see the data and play a bit with it. ;-)

Posted 15-Feb-18 22:34pm

KarstenK

Updated 18-Feb-18 22:23pm

v3

Comments

Richard MacCutchan 16-Feb-18 4:45am

Should be new int[x * y]; // x rows each of y columns

CPallini 16-Feb-18 5:24am

Good catch!

Ahmed AE 16-Feb-18 6:35am

He made me confused

KarstenK 19-Feb-18 4:22am

s bug => I'll fix it

Usman Hunjra 19-Feb-18 6:27am

Actually this type of allocation gives you a chunk of memory but remember in order to access the elements of the array you have to use Row, Column Major Addressing formula.
You cannot use the subscript operator.

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Jochen Arndt · Accepted Answer · 2018-02-15T23:03:00

That is because your delete code does not match the allocation code:

//Dynamically Allocating x*y array
int **myArray = new int*[x];              //reserve x row elements
for (int i = 0; i < x; ++i) {
    for (int j = 0; j < y; ++j) {
        myArray[i] = new int[j];           //makes each one of the reserved row elements points to an array
    }
}
//Memory Deallocation
for (int i = 0; i < x; ++i) {
    delete [] myArray[i];
}
delete[] myArray;

For each x you are allocating y arrays which are all assigned to myArray[i]. So only the last allocated one will be used (and later freed). Also this last one has the size of y-1 which is the reason for the heap corruption because you are accessing one more (not allocated) item.

Just use a single loop for allocation like when deleting:

for (int i = 0; i < x; ++i) {
    myArray[i] = new int[y];
}

CPallini · Accepted Answer · 2018-02-15T23:05:00

Your delete is fine. Your memory allocation is wrong.
Try:

#include <iostream>
#include <cstdlib>
using namespace std;

int main()
{
  int x,y;
  cout<<"Entre matrix dimensions"<<endl;
  cin>>x>>y;
  cout << "x = " << x << ", y = " << y << endl;


  //Dynamically Allocating x*y array
  int **myArray = new int * [x];              //reserve x row elements
  for (int i = 0; i < x; ++i)
    myArray[i] = new int[y];

  cout << "assigning random values"<< endl;
  for (int i = 0; i < x; ++i)
    for (int j = 0; j < y; ++j)
      myArray[i][j] = rand();

  //Displaying the values
  cout<<"the values : "<<endl;
  for (int i = 0; i < x; ++i)
  {
    for (int j = 0; j < y; ++j)
      cout<<myArray[i][j]<<" " ;
    cout << endl;
  }

  //Memory Deallocation
  for (int i = 0; i < x; ++i)
    delete [] myArray[i];

  delete[] myArray;
}

By the way, the standard library gently provides you the vector container, why don't you use it?

Why it is not just enough to use delete [] to delete the 2D dynamically allocated array?

3 solutions

Solution 2

Solution 3

Solution 1

Add your solution here

Preview 0