How can I allocate memory on the stack for a pointer to an object?

Question

I am implementing a linked stack of strings in C++, mainly for fun. Every object of the list is a Node instantiation, and the list itself is an instance of StackOfStrings. Right now I instantiate a new Node using new and everything works fine, but I can't seem to figure out how to instantiate a Node on the stack and refer to it at a later point in the code.

I tried changing first = new Node; with first = &Node(); inside the push() method, but then I get a run-time std::bad_alloc error when I call the pop() method. My guess is that this Node gets created on the stack and is destroyed as soon as the program exits the push() method. So my question is: is there a way I can create assign to first a Node created on the stack and retain it for later use?

I am including the bare bones of the code, I added a comment next to the line that is causing me problems.

class StackOfStrings
{
public:
    StackOfStrings() {}; // Could be omitted, default constructor

    void push(std::string item)
    {
        Node* old_first = first;
        first = new Node;         // *** my question revolves around this line ***
                                  // ***    "first = &Node()" does not work    ***
                                  // ***  how can I have a Node on the stack?  ***
        first->setItem(item);
        first->setNext(old_first);
    }

    std::string pop()
    {
        std::string item = first->getItem();
        first = first->getNext();
        return item;
    }

private:
    Node *first = nullptr;
};

For completeness, this is the Node class:

class Node
{
public:
    std::string getItem() { return item; }
    Node* getNext() { return next; }
    void setItem(std::string item) { this->item = item; }
    void setNext(Node *node) { this->next = node; }

private:
    std::string item;
    Node* next = nullptr;
};

edit: by mistake I wrote *Node instead of &Node. I updated the question.

edit 2: a little experiment I tried:

• I called the push() method of StackOfStrings to insert the word "hello" inside the linked list.
• inserted a breakpoint inside the setItem() method of Node to check that the world "hello" was saved in memory. Indeed, at memory address 0x00FFF900 I found the values 68 65 6c 6c 6f, which corresponds to "hello" in ASCII
• I then placed another breakpoint inside the call to getItem() in order to analyze the same memory address again. What I found now a0 fb ff 00 28 which is garbage and certainly not "hello".

Answer 1

First this is a very very bad idea.

Second you shouldn't take address of a temporary because it will be destroyed once the semicolon is reached leaving your pointer pointing to an invalid object . I think this line shouldn't even compile ! Are you using any visual c++ extension ?

first = &Node();

you construct a temporary on the stack by calling Node() then you bind its address to first pointer then the temporary gets destroyed .

Third the exception you get is because of this :

your getItem() method returns by copy rather than by reference so once called in pop() on a dangling pointer first the std::string copy constructor is called to copy the member std::string item which is invalid because it was destroyed from the beginning .

In the copy constructor of std::string it reads the size of the other string which happens to be some random bytes on the stack since the original string was destroyed .

This number is very big that Windows can't allocate memory for it on the heap so an exception of type std::bad_alloc is thrown

If the number was small enough but not smaller than std::string internal stack array , you might get an access violation because the copy constructor will attempt to copy buffer from an invalid memory address . Or even worse ! you might corrupt the heap or read some random bytes if this chunk was related to any other object in the program

Answer 2

How can I allocate memory on the stack for a pointer to an object?

By creating an automatic variable. Like this:

void foo() {
    Node* ptr; // this pointer is allocated on the execution stack

is there a way I can create assign to first a Node created on the stack

Sure. Create an automatic Node, and use the addressof operator:

Node node;
StackOfStrings sos;
sos.first = &node;

This simple example violates access specifiers of your class. You may want to for example pass the pointer to the constructor in order to avoid needing to change the access specifier.

and retain it for later use?

Automatic variables (i.e. all variables allocated on the execution stack) are destroyed at the end of their scope. No exceptions. If later use is within that scope, then there is no problem. If later use is outside of that scope, then wanting to use the execution stack is a mistake.