动态内存寻址和释放

Question

I'm trying to solve a problem for a web tutorial (non-marked) where I'm implementing a dynamic array. However, it fails in two places:

1. Where I try to delete a dynamic array in function ResizeDynamicArray(...)

2. It is outputting incorrect data. I expect to see:

    10 20 30 40 50 10 30 40 50 10 30 50 

   ...but I get this instead:

    8723216 8716480 701955994 201375930 10 8723216 701955994 201375930 10 8723216 701955994 10 

Requirements of the solution are:

• Use pointer to pointer instead of reference to pointer (btw I have successfully implemented a reference to pointer solution, but I am trying to figure out the pointer to pointer solution)
• No use of malloc / free
• No use of vector s
• Must use the declarations as shown

Could someone please suggest what I'm doing wrong?

int* CreateDynamicArray(int capacity, int &size);
void DeleteDynamicArray(int* dynamicArray, int &size);
void InsertElement(int* dynamicArray, int element, int &size, int &capacity);
void DeleteElement(int* dynamicArray, int elementIndex, int &size);
void ResizeDynamicArray(int** dynamicArray, int newCapacity);
void PrintArray(int *ptrArray, int capacity);

#include <iostream>

int main()
{
    int size = 0;
    int capacity = 0;

    int* ptrArray = CreateDynamicArray(capacity, size);

    InsertElement(ptrArray, 10, size, capacity);
    InsertElement(ptrArray, 20, size, capacity);
    InsertElement(ptrArray, 30, size, capacity);
    InsertElement(ptrArray, 40, size, capacity);
    InsertElement(ptrArray, 50, size, capacity);
    PrintArray(ptrArray, size);

    DeleteElement(ptrArray, 1, size);
    PrintArray(ptrArray, size);
    DeleteElement(ptrArray, 2, size);
    PrintArray(ptrArray, size);

    DeleteDynamicArray(ptrArray, size);

    ptrArray = nullptr;

    return 0;
}


int* CreateDynamicArray(int capacity, int &size)
{
    size = 0;
    return new int[capacity];
}


void DeleteDynamicArray(int* dynamicArray, int &size)
{
    if (dynamicArray != nullptr) {
        delete[] dynamicArray;
        dynamicArray = nullptr;
    }
    size = 0;
}


void InsertElement(int* dynamicArray, int element, int &size, int &capacity)
{
    if (size > capacity)
        capacity += 2;
    else
        capacity += 1;
    ResizeDynamicArray(&dynamicArray, capacity);
    dynamicArray[size] = element;
    size++;
}


void DeleteElement(int* dynamicArray, int elementIndex, int &size)
{
    for(int i = elementIndex + 1; i < size; i++)
        dynamicArray[i - 1] = dynamicArray[i];
    size--;
}


void ResizeDynamicArray(int** dynamicArray, int newCapacity)
{
    int *newArray = new int[newCapacity];
    for(int i = 0; i < newCapacity; i++) {
        newArray[i] = (*dynamicArray)[i];
    }
//  if (*dynamicArray != nullptr) {
//      delete [] *dynamicArray;
//  }
    *dynamicArray = newArray;
}


void PrintArray(int *dynamicArray, int size)
{
    for (int i = 0; i < size; i++) {
        std::cout << dynamicArray[i] << " ";
    }
    std::cout << std::endl;
}

Answer 1

Let's look at the problem in InsertElement . You have:

void InsertElement(int* dynamicArray, int element, int &size, int &capacity)
{
    ...
    ResizeDynamicArray(&dynamicArray, capacity);
    ...
}

In this function, you modify what dynamicArray points locally in the function. That does not change what the pointer points to in the calling function. As a consequence, you have the following problems.

1. The variable in the calling function does not point to the newly allocated memory you expected it to have.
2. The calling function uses memory it doesn't have, causing undefined behavior.
3. You have a memory leak. The memory acquired in the function is lost to the program as soon as you return from InsertElement .

The way to fix it would be to pass the pointer by reference.

void InsertElement(int*& dynamicArray, int element, int &size, int &capacity)
{
    ...
    ResizeDynamicArray(&dynamicArray, capacity);
    ...
}

I would recommend changing ResizeDynamicArray to also accept a pointer by reference. Using a int** is C-style, not C++ style. If you did change that, you can use

    ResizeDynamicArray(dynamicArray, capacity);

above.

Here's my suggestion for the function declarations. I take it that you can update the implementations accordingly.

int* CreateDynamicArray(int capacity, int &size);
void DeleteDynamicArray(int*& dynamicArray, int &size);
void InsertElement(int*& dynamicArray, int element, int &size, int &capacity);
void DeleteElement(int* dynamicArray, int elementIndex, int &size);
void ResizeDynamicArray(int*& dynamicArray, int newCapacity);
void PrintArray(int *ptrArray, int capacity);

---

I noticed that you have a bug in ResizeDynamicArray . You are using:

int *newArray = new int[newCapacity];
for(int i = 0; i < newCapacity; i++) {
    newArray[i] = (*dynamicArray)[i];
}

to copy values from the old array to the new array. However, the old array does not have as many elements as the new array. You end up copying values from memory that you are not supposed to access. It will be necessary to pass the old capacity to the function as an argument so you can copy the old values correctly.

Answer 2

I believe I have the solution, thanks to R Sahu.

int* CreateDynamicArray(int capacity, int &size);
void DeleteDynamicArray(int* dynamicArray, int &size);
void InsertElement(int** dynamicArray, int element, int &size, int &capacity);
void DeleteElement(int** dynamicArray, int elementIndex, int &size);
void ResizeDynamicArray(int** dynamicArray, int newCapacity);
void PrintArray(int *ptrArray, int capacity);

#include <iostream>

int main()
{
    int size = 0;
    int capacity = 0;

    int* ptrArray = CreateDynamicArray(capacity, size);

    InsertElement(&ptrArray, 10, size, capacity);
    InsertElement(&ptrArray, 20, size, capacity);
    InsertElement(&ptrArray, 30, size, capacity);
    InsertElement(&ptrArray, 40, size, capacity);
    InsertElement(&ptrArray, 50, size, capacity);
    PrintArray(ptrArray, size);

    DeleteElement(&ptrArray, 1, size);
    PrintArray(ptrArray, size);
    DeleteElement(&ptrArray, 2, size);
    PrintArray(ptrArray, size);

    DeleteDynamicArray(ptrArray, size);

    ptrArray = nullptr;

    return 0;
}


int* CreateDynamicArray(int capacity, int &size)
{
    size = 0;
    return new int[capacity];
}


void DeleteDynamicArray(int* dynamicArray, int &size)
{
    if (dynamicArray != nullptr) {
        delete[] dynamicArray;
        dynamicArray = nullptr;
    }
    size = 0;
}


void InsertElement(int** dynamicArray, int element, int &size, int &capacity)
{
    if (size > capacity)
        capacity += 2;
    else
        capacity += 1;
    ResizeDynamicArray(dynamicArray, capacity);
    (*dynamicArray)[size] = element;
    size++;
}


void DeleteElement(int** dynamicArray, int elementIndex, int &size)
{
    for (int i = elementIndex + 1; i < size; i++)
        (*dynamicArray)[i - 1] = (*dynamicArray)[i];
    size--;
}


void ResizeDynamicArray(int** dynamicArray, int newCapacity)
{
    int *newArray = new int[newCapacity];
    for (int i = 0; i < newCapacity; i++) {
        newArray[i] = (*dynamicArray)[i];
    }
    if (*dynamicArray != nullptr)
        delete[] * dynamicArray;
    *dynamicArray = newArray;
}


void PrintArray(int *dynamicArray, int size)
{
    for (int i = 0; i < size; i++) {
        std::cout << dynamicArray[i] << " ";
    }
    std::cout << std::endl;
}