C++ - Best way to create a non-local variable pointer - c++

Question

I have recently been relearning C++ as I develop a game in the Unreal engine. Its been about 3 years since I have touched C++, and I have been mostly using Java since then.
Due to the differences between java and c++ I can already tell there are different best practices for similar concepts.
I have 2 methods like this.
void UMarchingSquares::Generate(std::map<Vector2, int> automata) {
std::map<Vector2,ControlNode*> controlNodes = getControlNodes(automata);
}
std::map<Vector2,ControlNode*> UMarchingSquares::getControlNodes(std::map<Vector2, int> automata) {
std::map<Vector2,ControlNode*> controlNodes = std::map<Vector2, ControlNode*>();
for(pair<Vector2,int> pair : automata) {
Vector2 pos = pair.first;
ControlNode node = ControlNode(pos,pair.second);
controlNodes[pos] = &node;
}
return controlNodes;
}
I probably am breaking a few different C++ best practices, but there is one that I really want clarifications on one specific area.
I am initializing the ControlNode object in the getControlNodes() method's for loop. I know now that doing it this way is bad, because I am storing a pointer to a local variable, which then goes out of scope every loop iteration. I would prefer to store pointers instead of the actual Control node (though I may be convinced otherwise, since a Control Node holds a position [2 floats], a material [1 integer], and two other objects that both have a position and material of their own.)
What is the best way to create a non-local variable pointer? I know I can just use "new ControlNode()", but from what I know, that ends up being a fairly expensive call, and requires cleanup (which may be expensive as well).
I am going to be calling this part of the code fairly frequently, so I would like it to be efficient.
Thank you!

Answer 1

C++ changed a lot in the last few years to make life easier for those using it.
Looking at your code, it raises a lot of questions:
Why is the value of your map a raw pointer to ControlNode instead of a ControlNode by value or a unique_ptr to it
In your for-loop, why do you write the explicit type of pair (which is different from the iterator), auto could help you here to have fewer copies
As your question is about the first, I'll ignore the second one.
Looking at this, you have 3 ways of fixing the code:
std::map<Vector2,ControlNode> getControlNodes(std::map<Vector2, int> automata) {
auto controlNodes = std::map<Vector2, ControlNode>{};
for(auto &&pair : automata) {
auto &&pos = pair.first;
auto node = ControlNode(pos,pair.second);
controlNodes[pos] = std::move(node);
}
return controlNodes;
}
In this code, you can see that the * has been removed from the map. This implies that that ownership of the ControlNode is moved instead of the map. (Also note the std::move) This would be similar to how you have the int stored in the map that comes in as an argument.
If you however require memory allocation, as you will be moving this around and the address needs to be stable, std::unique_ptr is a good solution.
std::map<Vector2,std::unique_ptr<ControlNode>> getControlNodes(std::map<Vector2, int> automata) {
auto controlNodes = std::map<Vector2, std::unique_ptr<ControlNode>>{};
for(auto &&pair : automata) {
auto &&pos = pair.first;
auto node = std::make_unique<ControlNode>(pos,pair.second);
controlNodes[pos] = std::move(node);
}
return controlNodes;
}
As you can see, this code is very similar to the previous, I've replaced the type in the map and changed the construction of the ControlNode to std::make_unique. Hence, you have a unique_ptr containing the ownership to the allocated memory (and as long as you have the unique_ptr, things are staying valid).
The third solution should only be used if you can't change the signature and is considered bad practice in C++ as it passes ownership via raw pointers. Now your caller is responsible for explicitly cleaning up the memory as C++ doesn't have garbage collection.
std::map<Vector2,ControlNode*> getControlNodes(std::map<Vector2, int> automata) {
auto controlNodes = std::map<Vector2, ControlNode*>{};
for(auto &&pair : automata) {
auto &&pos = pair.first;
auto node = new ControlNode(pos,pair.second);
controlNodes[pos] = node;
}
return controlNodes;
}
PS: I've added some auto to the code to make the changes between the snippets minimal.

Answer 2

Use a vector of control nodes for storage. Whenever you need a new control node, append a one to that vector. Instead of using a pointer, use an iterator to that vector. Make sure you have reserved enough slots in that vector up front, or else your iterators will get invalidated.