“未分配被釋放的指針”如何找到對 memory 的錯誤訪問？

Question

首先，我必須打印參數為 Stack 的函數“Ranking”的值！
但是我的編譯器說 我認為我刪除了未分配的 memory 。 但是，當我刪除 memory 時我找不到......請幫我指出我錯誤地訪問 memory。

PS我想制作一個接收整數或字符串的程序，並將整數或字符串放入堆棧。 並使用排名 function 作為堆棧，結果將是，
對於整數，堆棧中有多少數字超過了堆棧的第一個數字。
對於字符串，堆棧中有多少個字符串比堆棧的第一個字符串的順序晚。（字符串對象的順序按字典順序確定。）
例如，如果輸入是 4 1 +2 5 3 -1 6，結果是 2（因為 5 和 6 比前 4 大）
例如，如果輸入是“to be or not to be”，則結果為 0（因為沒有比“to”更晚的訂單字符串）

#include <iostream>
#include <sstream>
#include <string>
#include <cctype>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <algorithm>

const size_t SIZE = 100;

using namespace std;

template <class T>
class Stack
{
public:
    Stack(size_t size = SIZE);
    Stack(const Stack<T>& s);
    const Stack<T>& operator = (const Stack<T>& s); ~Stack();
    bool isfull();
    bool isEmpty();
    void push(T d);
    T pop();
    T Elem(size_t i);
//  int Ranking(T obj);
private:
    T *_data;
    size_t _top, _size;
};

template <class T>
Stack<T>::Stack(size_t size) : _top(0), _size(size)
{
    _data = new T[size];
}

template <class T>
Stack<T>::Stack(const Stack<T>& s) : _top(s._top), _size(s._size)
{
    if (_data) delete[] _data;
    _size = s._size;
    _top = s._top;
    _data = new T[_size];
    for (int i = 0; i < _size; ++i)
        _data[i] = s._data[i];
}

template <class T>
Stack<T>::~Stack()
{
    delete [] _data;
}

template <class T>
bool Stack<T>::isfull()
{
    return _top == _size;
}

template <class T>
bool Stack<T>::isEmpty()
{
    return _top == 0;
}

template <class T>
void Stack<T>::push(T d)
{
    if (! isfull())
        _data[_top++] = d;
}

template <class T>
T Stack<T>::pop()
{
    if (! isEmpty())
        return _data[--_top];
    throw -1;
}


template <class T>
T Stack<T>::Elem(size_t i)
{
    return _data[i];
}

template <class T>
int Ranking(T obj)
{
    int k = 0;
    while(!obj.isEmpty())
    {
        if(obj.Elem(0).compare(obj.pop()) < 0 )
            k++;
    }
    return k;
}

int main(void)
{
    int k = 0;
    int value = 0;
    int num;
    string s;
    string line;
    Stack<string> strs;
    Stack<string> temps;
    vector<int> nums;

    while (getline(cin, line))
    {
        istringstream ins(line);
        while (ins >> s)
        {
            strs.push(s);
        }
        nums.push_back(Ranking(strs));
    }
}

Answer 1

在復制構造函數的主體中， _data最初是未初始化的。 if (_data)具有未定義的行為，您已將其觀察為delete[]任意指針值。

新的 object 中從來沒有以前的分配，所以你不需要delete[]任何東西。 您聲明（以非傳統方式）但未定義復制賦值運算符。

我還實現了一個移動構造函數，它可以減少您需要的副本數量。

大多數構造函數的主體可以是 go，或者被移動到成員初始化器中。 最好使用預定義的算法，而不是自己做。

#include <algorithm>
#include <utility>

template <class T>
Stack<T>::Stack(size_t size) : _data(new T[size]), _top(0), _size(size)
{}

template <class T>
Stack<T>::Stack(const Stack<T>& s) : _data(new T[s._size]), _top(s._top), _size(s._size)
{
    std::copy_n(s._data, s._size, _data);
}

template <class T>
Stack<T>::Stack(Stack<T>&& s) : _data(std::exchange(s._data, nullptr)), _top(s._top), _size(s._size)
{
}

template <class T>
Stack<T>& Stack<T>::operator=(Stack<T> s) // nb: by-value argument, copies or moves
{
    std::swap(_data, s._data);
    _size = s._size;
    _top = s._top;
    return *this;
}