Умирают ли указатели после завершения функции?

Question

void add_first(int e) {
        Node* newest = new Node(e, first);
        first = newest;
        n++;
}

В этом коде я объявил указатель узла "самым новым".

list->add_first(4);

Допустим, я вызываю эту функцию во второй раз.

list->add_first(8)

Это все тот же самый * самый новый с первого раза, когда я вызвал функцию, указывающую на новый узел, ИЛИ не выполнил ли предыдущий * самый новый кристалл после функции и при втором вызове функции был сгенерирован новый * самый новый? *

// Полный код, если вам нужна дополнительная информация

template <typename T>
class List {
    struct Node {
        T elem;
        Node* next;

        Node(T elem = 0, Node* next = nullptr) : elem(elem), next(next) {}
    };

    Node* first;
    size_t n;

public:
    List () : n(0), first(nullptr) {}
    ~List () {
        while (first != nullptr) {
            Node* aux = first;
            first = first->next;
            delete aux;
        }
    }

    bool addFirst(T e) {
        Node* newest = new Node(e, first);
        first = newest;
        n++;
        return true;
    }
    bool add(T e, size_t p) {
        if (p > n) return false;
        if (p == 0) return addFirst(e);

        Node* newest = new Node(e);

        Node* aux = first;
        size_t i = 1;
        while (i++ < p) {
            aux = aux->next;
        }
        newest->next = aux->next;
        aux->next = newest;
        n++;
        return true;
    }
    bool addLast(T e) {
        return add(e, n);
    }
};

Answer 1

Указатели - это просто типы, которые содержат адрес памяти экземпляра определенного типа.В вашем примере вы динамически распределяете память для хранения экземпляра Node, используя new, и сохраняете его адрес в указателе (обратите внимание, что new возвращается с указателем, который указывает на выделенную память).Когда функция возвращается, указатель «умирает», но выделенная память остается выделенной.

Answer 2

new Node(e, first)

выделит новую память в куче для объекта типа Node, где она будет оставаться до тех пор, пока вы не освободите ее вручную, используя delete.Если вы не сохраните ссылку на него, вы не сможете освободить ее, и у вас будет утечка памяти.

Node* newest = ...;

создаст указатель типа Node в стеке, пока он не выйдетобласти видимости (в данном случае, когда функция возвращается), инициализируя ее для ссылки на объект, который вы только что создали.

Важно отметить, что newest это , а не объект;на данный момент он просто ссылается на него.

first = newest;

Тип first здесь не указан, но, вероятно, для его компиляции он определен в более высокой области видимости, например, переменная-члени принимает присваивание типа Node* ... так что это, вероятно, само по себе Node*.

В этом случае по умолчанию будет установлено first для ссылки на тот же объект, на который указывает newest, не указывает на newest в этом сценарии, но теперь оба ссылаются на один и тот же объект.

Когда функция вернется, newest (указатель) будет уничтожен, потому что онаопределяется в области вызова функции, но созданный вами объект Node будет жить в куче, а также first, который ссылается на него, поскольку он определен вне этой области.

Если вы немедленно вызоветеснова эту функцию, например, в цикле, вы назначите другой объект типа Node, установите для этого объекта first, а объект, на который ранее указывал first, теперь теряется в куче без ссылки.

РЕДАКТИРОВАТЬ: Я только что заметил, что вы передаете first в конструктор для Node, так что, возможно, вы делаете отдельное соединение в нем.

Answer 3

newest (т.е. указатель) умирает, когда функция возвращается (потому что это локальная переменная). При следующем вызове функции новая переменная newest будет создана и снова уничтожена.

*newest (т.е. объект, на который он указывает) остается живым до тех пор, пока вы явно не delete его (потому что вы создали его с помощью new)