動態陣列-記憶體管理問題-有解無憂

我正在研究動態陣列。陣列類的相關代碼部分：

#pragma once
#include <iostream>

template <class T>
class Darray
{

private:
    T* dataArray;
    int a_size = 0;
    int a_capacity = 0;
    double expandFactor = 1.5;

private:
    void memLoc(int n_capacity)
    {
        T* newArray = new T[n_capacity];

        for (int i = 0; i < a_size; i  )
        {
            newArray[i] = dataArray[i];
        }

        
        dataArray = newArray; 
        delete[] newArray; //<-- **************problem occurs here**************
        a_capacity = n_capacity;
        
        
    }

public:
    Darray()
    {
        T* dataArray = new T[a_size];
        memLoc(2);
    }

    void addLast(T data) 
    {
        if (a_size < a_capacity)
        {
            dataArray[a_size] = data;
            a_size  ;
        }
        else
        {
            memLoc(a_capacity * expandFactor);
            dataArray[a_size] = data;
            a_size  ;
        }
    }

當我在不洗掉 newArray 的情況下運行代碼時，我得到了預期的結果：

Values
Index 0: 10
Index 1: 9
Index 2: 8
Index 3: 7
Index 4: 6
Index 5: 5
Index 6: 4
Index 7: 3
Index 8: 2
Index 9: 1

這是我的問題！當我洗掉 newArray （在代碼中標記）時，我的結果遠非準確：

Values
Index 0: -572662307
Index 1: -572662307
Index 2: 100663302
Index 3: 31812
Index 4: 17648624
Index 5: 17649832
Index 6: -572662307
Index 7: -572662307
Index 8: -572662307
Index 9: -572662307

我不知道為什么會發生這種情況，因為乍一看一切似乎都是正確的。任何建議或提示將不勝感激。我希望有人能夠提供幫助;)

uj5u.com熱心網友回復：

您的代碼中有幾個錯誤。

在中memLoc()，您正在銷毀剛剛創建的新陣列。您需要銷毀正在被替換的舊陣列。該陳述句dataArray = newArray;只是將一個指標分配給另一個指標。dataArray指向前一個陣列，并newArray指向新陣列。當您執行dataArray = newArray;，您泄漏了前一陣，現在都dataArray和newArray在同一陣列指向，然后delete[] newArray;破壞了陣列，留下dataArray一個懸空指標無效的記憶體。
在默認建構式中，您正在創建一個新陣列并將其指標分配給名為的區域變數dataArray，該變數隱藏了同樣名為的類資料成員dataArray。然后，您將呼叫memLoc()為dataArray要指向的類資料成員創建另一個陣列。第一個陣列是無用的，會被泄露。您應該將類??資料成員初始化為nullptr，然后呼叫memLoc()以創建唯一的陣列。

此外，雖然這些不是每個人所說的錯誤，但值得注意的是：

我假設您沒有顯示的其余代碼符合3/5/0 規則，即您有一個解構式、復制/移動建構式和復制/移動賦值運算子。如果沒有，請確保您解決了這個問題，否則您以后會遇到其他問題。
中的代碼addLast()是重復的，可以簡化。

話雖如此，試試這個：

#pragma once
#include <iostream>
#include <utility>

template <class T>
class Darray
{
private:
    T* dataArray = nullptr;
    int a_size = 0;
    int a_capacity = 0;
    static const double expandFactor = 1.5;

private:
    void memLoc(int n_capacity)
    {
        T* newArray = new T[n_capacity];

        for (int i = 0; i < a_size;   i)
        {
            newArray[i] = dataArray[i];
        }

        delete[] dataArray;
        dataArray = newArray; 
        a_capacity = n_capacity;
    }

public:
    Darray()
    {
        memLoc(2);
    }

    Darray(const Darray &src)
    {
        memLoc(src.a_capacity);
        for (int i = 0; i < src.a_size;   i)
        {
            dataArray[i] = src.dataArray[i];
              a_size;
        }
    }

    Darray(Darray &&src)
    {
        std::swap(dataArray, src.dataArray);
        std::swap(a_capacity, src.a_capacity);
        std::swap(a_size, src.a_size);
    }

    ~Darray()
    {
        delete[] dataArray;
    }

    Darray& operator=(Darray rhs)
    {
        std::swap(dataArray, rhs.dataArray);
        std::swap(a_capacity, rhs.a_capacity);
        std::swap(a_size, rhs.a_size);
        return *this;
    }

    void addLast(const T &data) 
    {
        if (a_size >= a_capacity)
            memLoc(a_capacity * expandFactor);
        dataArray[a_size] = data;
          a_size;
    }

    ...
};

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/324132.html

標籤：C 数组记忆动态的

上一篇：有沒有比使用np.vectorize在不同形狀的ndarray的ndarray上使用函式更好的方法？

下一篇：連接具有不同第一維的二維陣列