Vector holding a class which holds a pointers

I have a template class Position which has a pointer to an Entry object. Can it creates errors if I am creating my Positions on the stack, and then inserting them in the std::vector?

Here is my Position Template:

template <typename K, typename V>
class Position
{
private:
    Entry<K, V> *ptr;
    int index;
public:
    Position(Entry<K,V> &e, int index){
        *ptr = e;
        this->index = index;
    }

And I am inserting like this in the vector:

Entry<int, int> e(20, 20);
//Creates Position with reference to Entry and Index as value.
storage.push_back(Position<K,V> p(e, 10));

I am not fully sure how would memory work for a simple insertion. Even more if I am inserting inside a local function, and the Position is created locally.

So, can I do it, should I use new so it stays on the Heap? Am I doing things wrong?
Thanks for the help in advance.

I am going to address you question at a few different levels: 1) cleanup the code you posted because it is not doing what you think it is, 2) address your intuition about storing a pointer to an object that goes out of scope, and 3) walk through some alternate design options that don't use pointers.

Posted Code

Consider the Position constructor. The first argument is a reference to an Entry. The expression *ptr = e copies the object referenced by e and stores it in the location pointed to by ptr which is uninitialized and could point anywhere, clearly a bug. Based on your verbal explanation, I think the expression should have been ptr = &e, which stores the address of e in ptr.

Storing Pointers

You intuition is correct that storing a pointer to an object that goes out of scope will certainly fail. As you mention, one option is to allocate the object on the heap and store that pointer which will remain valid until you delete the object from the heap. That said, I recommend not working with raw with pointers.

Design Options

I don't know your overall code, so you may have to adapt these strategies to your situation.

1. Store the Entry object directly in the Position. This is clearly the easiest solution assuming it still meets the other requirements of your code, i.e. the Entry's are not somehow shared or changed outside of the Position object.

2. Allocate the Entry object using new but store the result in a smart pointer like std::unique_ptr (or stud::shared_ptr if you need multiple references to it). The smart pointer can be passed around and stored in objects by value similar to an int. I can't overstate how much better this is than working with raw pointers.

Asking Questions

When you post a question, it is really helpful to post enough code to replicate the problem you are experiencing. The code should compile (unless the question is about a compilation error) and run.

This had multiple benefits. For the questioner, often to process of constructing a minimal, reproducible example points them in the right direction. It also turns the question into a reliable specification of the issue. For the answerers, it makes it a lot easier to work on the problem.