Automated Object Creation, How to Control/Increment Names? - c++

Question

I've hit a bit of a hurdle with creating objects using user input for variables. Basically the program determines what type of object the user wants, creates it, and then asks if the user wants to add another object. In this example the object is a manager, which is a subclass of employee.
void add_manager()
{
string name;
//Performs a bunch of checks to ensure the input is valid.
name = get_string_input("Please input the name of the employee.");
//Creates a manager object.
manager manager1(name);
//Goes back to previous function, restarts process of finding out employee type.
ask_employee();
}
I will be storing pointers to each object in a dynamic array elsewhere. The point of the array is just to get values out of each object to use in some printouts, so I was expecting to just loop over the array, get the value of each, and print. (Rough example)
The part I'm not sure about is how to change the object constructor call so the objects are made as manager1, manager2 etc. There will be a varied number made due to what the user wants, and I was hoping to keep them in a way to tell the difference.
Since I will be accessing the objects via pointers, do the object names even need to be different? Or can objects and pointers all have the same name?

Answer 1

Since managers objects can be in an infinite number, you can't name them all. C++ is a statically typed language. You strictly need to keep your manager objects in an array-like structure:
std::vector<manager *> vManagers;
void add_manager()
{
string name;
//Performs a bunch of checks to ensure the input is valid.
name = get_string_input("Please input the name of the employee.");
//Creates a manager object.
vManagers.push_back(new manager(name));
//Goes back to previous function, restarts process of finding out employee type.
while(ask_employee()
{
name = get_string_input("Please input the name of the employee.");
vManagers.push_back(new manager(name));
}
}
So that when you need manager object you can call:
vManagers[n]->GetData();
But note that you need to delete manager object pointers in apppriate places to avoid leaks:
delete vManagers[n];
vManagers[n] = NULL;

Answer 2

Do the object names even need to be different?
They don't need to be different, when you store them in the array there is no connection between the objects and their names, e.g. they can be all instantiated using manager11. (Additionally, you can't use their name for search.)
What differentiates the objects are the values of their data members. Thus, if you want to search the objects define an object id or name as data member and then you can use it in your search criterion to find a particular manager.
Edit 1:
One way to create an object counter is by defining a data member:
static int counter = 0;. Then you increment your counter in the constructor to reflect object instantiation and decrement it in the destructor.
Edit 2:
If you want to store objects it would be better to use vector<object_type> container_name (instead of arrays). To do this you need to define a vector outside the object you want to store. In case of storing pointers to type object_type, you can do something like:
vector<object_type*> container_name;
object_type* ObjectInstance = new object_type(parameters);
// store in vector
container_name.emplace_back(ObjectInstance);
1.The names you give variables are available to the program only at compile time, when you turn it from source into an executable file. Afterwards, when you want to create objects , those kinds of information are no longer available. The program only knows about the machine addresses where operands to machine instructions are located.