在 C++ 上创建指针时如何删除错误？ 在这种情况下，我必须使用原始指针

Question

I'm trying to make a linked list with a pointer to a template class called Node:

template <typename T>
class llnode

{
public:
    T key;
    llnode<T> *prev, *next;

    llnode()
    {

    };

    llnode(const T &k, llnode<T> *w = NULL, llnode<T> *y = NULL) : key(k), prev(w), next(y){};

    ~llnode()
    {
        delete this;
    }
};

But, when I run the program this code in the main function

llnode<int> *node;
node->key = 6;
llnode<int> *node1;
node->key = 2;

I get the error message:

403 cygwin_exception::open_stackdumpfile: Dumping stack trace to "NAME OF MY EXE".exe.stackdump

How can I create more nodes without getting the error? It happens when I have 2 nodes created, but when I have 1 it does it right.

Answer 1

First, for

llnode<int> *node;
node->key = 6;
llnode<int> *node1;
node->key = 2;

your problem is that node is an uninitialized pointer. You should always initialize your pointers (or better, use smart pointers like unique_ptr ). Try:

std::unique_ptr<llnode<int>> node = std::make_unique<llnode<int>>();
node->key = 6;
std::unique_ptr<llnode<int>> node1 = std::make_unique<llnode<int>>();
node->key = 2;

or better:

auto node = std::make_unique<llnode<int>>(6);
auto node1 = std::make_unique<llnode<int>>(2);

In general, this is very C-like C++. Raw pointers are hard to use correctly, particularly when it comes to exception safety. For that reason, I make an effort to never write new or delete ever. (There are places, but really, you want to avoid them.)

You can use std::unique_ptr to do cleanup (and initialization) for you. You can also default raw pointers to nullptr .

In C++11 and beyond, don't use NULL , use nullptr , it's safer.

Consider something like this:

#include <memory>

template <typename T>
class llnode
{
public:
    T key;
    llnode<T>* prev = nullptr; // Raw pointer back
    std::unique_ptr<llnode<T>> next; // List owns it tail.

    llnode(const T &k = {}, 
           llnode<T> *w = nullptr,
           std::unique_ptr<llnode<T>> y = nullptr)
    : key(k), prev(w), next(std::move(y)) {}
};

When this node is deleted, the node pointed to by next (if next != nullptr ) will also be deleted for you.

Often a doubly-linked linked list will have a separate type that hides the nodes from the user, maintaining access to the front and back. Then you can provide standard operations such as list<T>.push_back(const T&) .

Answer 2

When you use them in main your pointers are not initializated. This ends in Undefined Behavior.

Do this:

llnode<int> *node = new llnode<int>;
node->key = 6;
llnode<int> *node1 = new llnode<int>;
node->key = 2;

Also note that calling delete this; in the destructor causes an infinite loop (More info here ). Remove the destructor and free the space manually or better use a Smart Pointers or RAII approach.