Question

我创建了一个简单的整数数组类：

#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

现在问题在于resize（）方法。我怎么知道这个？因为在创建对象并使用resize（）方法之前，我对任何对象都没有任何问题。当我运行调试器时，Visual Studio告诉我，一旦它通过使用resize函数的对象的析构函数，并且只有该对象，我会遇到某种指针错误。所有其他对象通过析构函数运行正常。此外，当我在调试器中并深入研究resize方法中发生的事情时，当我在内部删除mArray时，它会做一些时髦的事情。问题是，它在屏幕上显示它应该如何，我只是收到一条错误消息。无论如何，这就是我的resize（）方法，我提出了一些评论来帮助你理解我在实现代码时的想法：

编辑：为要求

的人添加全班

#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];
}

感谢您的帮助。 EDIT2：是的，我知道矢量与我正在做的完全相同。这不是重点。我只是想更好地理解类中的指针和动态内存，这是一本书的练习，只是给了我头文件代码并要求我实现它。

Answer 1

您的resize功能未设置mSize，因此以后的操作可能会遇到麻烦。

这是一个更好的实施

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

试试这个：

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;
}

但是如果有异常，你可能会有内存泄漏。使用矢量更好。

如何在调整大小数组方法中修复此内存泄漏？

2 个答案: