如何在我的大小调整数组方法中解决此内存泄漏？

Question

I've created a simple integer array class:

#ifndef INTARRAY_H
#define INTARRAY_H

class IntArray
{
public:
    // Constructors / Destructor
    IntArray();
    IntArray(int size);
    IntArray(const IntArray& rhs);
    ~IntArray();

    // Methods
    int size();
    void resize(int newSize);
    void print();

    //Operator Overloads
    IntArray& operator=(const IntArray& rhs);
    int& operator[](int i);

private:
    // Data Members
    int* mArray;
    int mSize;
};

#endif

Now the issue is in the resize() method. How do I know this? Because I don't have any issues with any object until I create an object and use the resize() method. When I run through the debugger, Visual Studio tells me I have some kind of pointer error once it goes through the destructor for the object that uses the resize function, and that object only. All other objects run through the destructor fine. Also, when I'm in the debugger and I delve into what's going on in the resize method, when I delete mArray inside, it does some funky stuff. The thing is, it displays on the screen exactly how it should, I just get an error message. Anyways, this is what my resize() method is and I put in some comments to help you understand what I was thinking I was doing as I implemented the code:

EDIT: Added whole class for people who were asking

#include <iostream>
#include "IntArray.h"
using namespace std;

// Constructors / Destructor
IntArray::IntArray()
{
    mArray = 0;
    mSize = 0;
}

IntArray::IntArray(int size)
{
    mSize = size;
    if (mSize == 0)
        mArray = 0;
    else
        mArray = new int[mSize];
}

IntArray::IntArray(const IntArray& rhs)
{
    mArray = 0;
    *this = rhs;
}

IntArray::~IntArray()
{
    delete[] mArray;
    mArray = 0;
}

// Methods
int IntArray::size()
{
    return mSize;
}

void IntArray::resize(int size, int newSize)
{

    int* temp = new int[mSize];  //Create temp dynamic array to store the values

    for (int i = 0; i < mSize; i++)  //Copy values from mArray into the temp array
    {
        temp[i] = mArray[i];
    }
    delete[] mArray; //Delete the old array
    mArray = 0;
    mArray = new int(newSize);  //Create a new array with the new size

    if (mSize <= newSize)  //Copy the values from the temp array into the new array
    {
        for (int i = 0; i < mSize; i++)
        {
            mArray[i] = temp[i];
        }
    }
    else
    {
        for (int i = 0; i < newSize; i++)
        {
            mArray[i] = temp[i];
        }
    }
    delete[] temp;  //Delete the temp array
}  //Doesn't work :(

void IntArray::print()
{
    //cout << 
}

// Operator Overloads
IntArray& IntArray::operator=(const IntArray& rhs)
{
    if (this == &rhs)
        return *this;

    delete[] mArray;

    mSize = rhs.mSize;

    mArray = new int[mSize];

    for (int i = 0; i < mSize; i++)
    {
        mArray[i] = rhs.mArray[i];
    }

    return *this;
}

int& IntArray::operator[](int i)
{
    return mArray[i];
}

Thanks for any help. EDIT2: Yes, I know a vector is the exact same thing that I'm doing. That's not the point. I'm simply trying to understand pointers and dynamic memory inside of classes better and this is an exercise out of a book that simply gave me the header file code and asked me to implement it.

Answer 1

Your resize function doesn't set mSize , so later operations probably run into trouble.

Here's a better implementation

void IntArray::resize(int newSize)
{

    if (newSize == 0)
    {
        mSize = 0;
        delete[] mArray;
        mArray = 0;
    }
    else
    {
        int *newArray = new int [newSize]:
        for (int i = 0; (i < newSize) && (i < mSize); ++i)
            newArray[i] = mArray [i];
        delete[] mArray;
        mArray = newArray;
        mSize = newSize;
    }
}

Answer 2

Try this:

void IntArray::resize(int newSize)
{
    int* temp = new int[newSize];  //Create temp dynamic array to store the values
    memcpy(temp, mArray, sizeof(int)*(mSize > newSize ? newSize : mSize));
    delete[] mArray;
    mSize = newSize;
    mArray = temp;
}

But you can have memory leaks if there will be exceptions. Using vector is better.