Fuite de mémoire Suppression d'un nœud C++

Question

Je essaie de supprimer un nœud dans une liste liée en c ++ mais il continue de dire que _pending_tx n'est pas nullptr après la suppression de la transaction. De plus, valgrind dit que j'ai une fuite de mémoire et je ne peux pas le résoudre

bool BankData::void_transaction(const size_t& customer_id, const size_t& timestamp) { 

bool var8 = false;

if (transaction_exists(customer_id, timestamp) == true)
{
    int blah3 = customerVector.size();
    for (int i = 0; i < blah3; i++)
    {
        if (customerVector.at(i)._customer_id == customer_id)
        {
            if (customerVector.at(i)._pending_txs != nullptr)
            {
                CSE250::dTransactionNode *temp = customerVector.at(i)._pending_txs;
                while (temp->_tx._timestamp != timestamp)
                {
                    temp = temp->_next;
                    if ((temp->_next == nullptr) && (temp->_tx._timestamp != timestamp))
                    {
                        var8 = false;
                    }
                }
                if (temp->_tx._timestamp == timestamp)
                {
                    if ((temp->_prev == nullptr) && (temp->_next == nullptr))         //head and only node
                    {
                        delete  customerVector.at(i)._pending_txs;
                        customerVector.at(i)._pending_txs = nullptr; //after i delete the head and only node i reset it to a nullptr
                        var8 = true;
                    }
                    else if ((temp->_prev == nullptr) && (temp->_next != nullptr))     //head
                    {
                        temp = customerVector.at(i)._pending_txs->_next;
                        delete  customerVector.at(i)._pending_txs;
                        customerVector.at(i)._pending_txs = temp;
                        customerVector.at(i)._pending_txs->_prev = nullptr;
                        var8 = true;
                    }
                    else if ((temp->_prev != nullptr) && (temp->_next == nullptr))    //tail
                    {
                        temp = customerVector.at(i)._pending_txs->_prev;
                        delete  customerVector.at(i)._pending_txs;
                        customerVector.at(i)._pending_txs = temp;
                        customerVector.at(i)._pending_txs->_next = nullptr;
                        var8 = true;
                    }
                    else                                                              //middle node
                    {
                        temp = customerVector.at(i)._pending_txs->_next;
                        customerVector.at(i)._pending_txs->_next->_prev = customerVector.at(i)._pending_txs->_prev;
                        delete  customerVector.at(i)._pending_txs;
                        customerVector.at(i)._pending_txs = temp;
                        //temp->_prev->_next = temp->_next;
                        //temp->_next->_prev = temp->_prev;
                        //temp = nullptr;
                        //delete temp;
                        var8 = true;
                    }
                }
            }
        }
    }
}
return var8;

C'est la structure de nœud que j'essaie de supprimer:

namespace CSE250 {
struct dTransactionNode;}

struct CSE250::dTransactionNode {
Transaction _tx;

dTransactionNode* _prev;

dTransactionNode* _next;

dTransactionNode(size_t time, double amount) : _tx(time, amount), _prev(nullptr), _next(nullptr) { }};

Je ne peux pas non plus comprendre pourquoi lorsque j'essaie de le supprimer, il ne supprimera que le timestamp et non le timestamp et le montant. donc lorsque je lance ma fonction transaction_exists, il dit toujours qu'une partie de la transaction existe.

C'est le message valgrind

Et voici les messages d'erreur que je reçois qui disent qu'il ne pointe pas vers un nullptr après que la transaction ait été annulée même si je l'ai défini manuellement sur un pointeur nul

Answer 1

Lorsque vous supprimez quelque chose, le pointeur n'est pas automatiquement défini sur nullptr. C'est le devoir des programmeurs de le faire. Lisez-en plus dans Pourquoi delete ne définit-il pas le pointeur sur NULL?

Lorsque vous définissez un pointeur sur null, cela ne supprime pas la mémoire. Si vous le faites, avant d'appeler delete, alors vous créerez une fuite de mémoire, si vous ne supprimez pas la mémoire avec un autre pointeur qui y fait référence.

Des pointeurs intelligents peuvent être utilisés, ce qui fait le travail pour vous.