c++ pass different classes into function - c++

Question

I may be going about this completely the wrong way but it's getting late and its driving me a little mad.
I have a function in my base class that should allow me to create new objects of derived classes. However where it's says Melee I want it to be interchangeable with my other derived classes. I can't figure how to pass in a different class so it will create an object of that class.
void BaseUnit::CreateNewUnit(vector<BaseUnit*>& MyVector)
{
UnitID++;
MyVector.push_back(new Melee());
}

Answer 1

You can use the "prototype design pattern".
Put in a std::map the associations key -> prototype and you're done: when the user press a key, you lookup into the map, extract the prototype and pass it to CreateNewUnit. Inside CreateNewUnit, you will use Prototype::Clone()
class BaseUnit
{
public:
... // your methods
virtual BaseUnit* Clone() = 0;
};
class Melee : public BaseUnit
{
public:
BaseUnit* Clone() { return new Melee(); }
};
void BaseUnit::CreateNewUnit(vector<BaseUnit*>& MyVector, BaseUnit* prototype )
{
UnitID++;
MyVector.push_back( prototype -> Clone() );
}
int main()
{
std::map< char, BaseUnit* > prototypes;
prototypes[ 'a' ] = new Melee();
prototypes[ 'b' ] = new OtherUnit();
...
std::vector< BaseUnit* > units;
char selection = GetKeyPressed();
BaseUnit::CreateNewUnit( units, prototypes[ selection ] );
}
The benefit of this solution is that when you need to add a new Unit type in your application you must just add a new entry in the prototypes map.
And by the way: with a little effort you can even avoid that, if the classes derived from BaseUnit register themselves in a global "prototypes" map.

Answer 2

I would either pass a pointer to the unit:
void BaseUnit::CreateNewUnit(vector<BaseUnit*>& MyVector, BaseUnit* unit)
{
UnitID++;
MyVector.push_back(unit);
}
or pass the key pressed or some other id:
void BaseUnit::CreateNewUnit(vector<BaseUnit*>& MyVector, char type)
{
switch(type) //this would be the key pressed
{
case '1':
MyVector.push_back(new Melee());
UnitID++;
break;//this would be continued for all possible units
}
}

Answer 3

If you want it to be determined at compile time you can either use templates methods or create a method for each class. This is called factory method, it's a design pattern. Note that the 'hint' to the factory here is the template parameter.
If you want it to be determined at runtime, you need to identify the relevant class in some way, a 'hint' for the factory. Most of the times this would be an enum or a string. Again, read about the factory design pattern and factory method.

Answer 4

This probably gives you an idea of how to do it:
1. change the function signature to include the derived object pointer as a second parameter,
void BaseUnit::CreateNewUnit(vector<BaseUnit*>& MyVector, const BaseUnit* derived) {
UnitID++;
MyVector.push_back(derived);
}
Call the above function when you press a key, if a key is pressed, create a new derived object and call ur function:
Melee *m = new Melee();
unit.CreateNewUnit(myVector,m);

Answer 5

If you need that at compile time, you can simply go for a factory template. If different classes have different parameters that need to be passed, you should use a variadic template:
#include <utility>
class Factory {
...
template <typename Derived, typename ...Args>
BaseUnit * create(Args &&... args)
{
return new Derived(std::forward<Args>(args)...);
}
};
Then you can simply create a factory and call factory.create(Melee, optional_arguments) or whatever type, and a template specialization will be created to instantiate that particular type with the supplied arguments.
If you need a "runtime dispatch" creation function, you could have something like an enum Type in BaseUnit or some other id that lists every possible derived type, and have a create(BaseUnit::Type type) method with a switch (type) statement and a case for every object type that creates the appropriate type. Naturally, this can be used in conjunction with the template factory listed above.
A switch statement will be considerably more efficient than a map, and besides, a map will not really make sense if it is populated "statically". A map only makes sense when you want to register a new object creation method during the runtime. In that case you can have a map of a type id and a pointer to a function, returning a new BaseType derived. This way you can for example register extra functions, loaded from a dynamic library, look up the function pointer based on the type id and use it to instantiate object of that type. But that's only in case you need runtime registration. Otherwise stick to the previous solutions. This will only be justified if you have something like "plugins" - dynamic libraries which provide a set of extra types and the appropriate functions to create them, so you can load a library, register its components in the map, and be able to instantiate types which are not present during the implementation of the "core logic" of the game. Naturally, this all has to rely on polymorphic interfaces that the core logic is design around in order to work, otherwise it won't. Also, for this solution you might want the id to be a string rather than an integer, since it offers more flexibility and does not have the restrictions of a switch statement.
Also note I did not include your vector<BaseUnit*>& MyVector - IMO that shouldn't be an argument you pass, but a local member to your game class which you can access directly without needing to have it as an argument.
Also, follow proper coding conventions, do not use member methods or objects or parameters with upper case. It is just confusing.