C++ add local variables to static vector without copying - c++

Question

im trying to archieve the following in c++:
I want to be able to create local variables, add them to a global static vector and only pointers to them should be added to the vector.
In C# i was able to write (example):
public static List<Component> CACHE = new List<Component>(); //Somewere in class
//Now in method:
Component a = new Component();
a.Name = "Noël";
CACHE.Add(a); //Adds reference to CACHE a without copy
in c++ i see 2 solutions:
1.Use dynamic allocations:
static std::vector<Component*> CACHE; //Somewere in class
//Now in method:
Component* a = new Component();
a->Name = L"Noël";
CACHE.push_back(a);
the problem is that i dont want to use dynamic allocation because its slow.
2.My idea:
(Somehow i have to make the new operator private or just say in the documentation never use new on Component)
//somewere hidden:
std::vector<Component*> GLOBAL_CACHE;
//In method dont use new, instead we use a custom global function
Component* a = CREATE_COMPONENT();
static std::vector<Component*> CACHE; //Example
Component& ExampleRef;//Example
a->Name = L"Noël";
CACHE.push_back(a);
ExampleRef = *a;
and now CREATE_COMPONENT():
Component* CREATE_COMPONENT()
{
GLOBAL_CACHE.push_back(Component()); //Add empty component
return &GLOBAL_CACHE[GLOBAL_CACHE.size() - 1]; //return pointer to construct added above. I think we now have everything on the stack and we just send around pointers to the stack object
}
Is my idea worth it or even working? Or should i just use dynamic allocation?

Answer 1

Doing the same in C++ is not possible because of garbage collection. But you can do it similarly by using shared_ptr<Component> as the element type of your vector:
#include <memory>
std::vector<std::shared_ptr<Component>> CACHE;
// ...
auto a = std::make_shared<Component>();
a->Name = "Noël";
CACHE.push_back(a);
The Component will be automatically destroyed when there's no more references to it.
If you don't intend to store copies of the pointers somewhere else, but CACHE is the only place where you put them, then you can use unique_ptr instead:
#include <memory>
std::vector<std::unique_ptr<Component>> CACHE;
// ...
CACHE.push_back(std::make_unique<Component>());
CACHE.back()->Name = "Noël";
Unlike shared_ptr, unique_ptr can not be copied, only moved, meaning there can only ever be 1 reference to it. The Component object will be automatically destroyed when the unique_ptr is destroyed.
This is using memory allocation, but the same it true for C#.
Note that, unlike C#, using new and delete in C++ is a bad idea because they're prone to resource and memory leaks. Use shared_ptr and unique_ptr instead if you want to create objects on the heap.
Finally, you should read up on "C++ move semantics". You don't need to avoid putting things on the stack. You can move objects instead of copy them. Example:
#include <memory>
std::vector<Component> CACHE;
// ...
Component a;
a.Name = "Noël";
CACHE.push_back(std::move(a)); // No copy. The 'a' variable can no longer be used.
Moves are sometimes automatic and they are a big part of C++. But you need to educate yourself about it.