Writing a get component method in c++ with templates - c++

Question

I'm trying to write a Unity-style get component method. This is my code so far. It compiles but will return the first component it finds rather than the correct one. I think I'm using static_cast wrong. What is a better way to do this? Note I don't want to hard code component types, I want to be able to compile this engine and use anything that inherits from Component to be able to use this system. Also note that each component needs to return as itself, not a component *, as this would hide child functionality.
compStruct.components is a vector of component *s.
template <typename CompType>
inline CompType getComponent()
{
for(Component * currComp : compStruct.components)
{
if (static_cast<CompType>(currComp)!= nullptr)
{
return static_cast<CompType>(currComp);
}
}
return nullptr;
}
Here is an example of a generic component
#pragma once
#include "Component.h"
#include "Animation2D.h"
class AnimationComponent : public Component
{
public:
AnimationComponent(GameObject*x) :Component(x) {}
~AnimationComponent() {}
void stepAnimation(double delta);
//add overload for 3d animations
int addAnimation(Animation2D);
void setAnimation(int);
private:
};
And the component base class:
#pragma once
class GameObject;
class Component
{
public:
Component(GameObject * h) { host = h; }
virtual ~Component() {}
GameObject* getHost() { return host; }
protected:
GameObject * host = nullptr;
};

Answer 1

There's some fundamental misunderstanding about static_cast: it will just do the cast, and it is your responsibility to assure the pointer casted actually points to an object of the target type. static_cast will only return a null pointer if the source pointer already was itself, but never on type mismatch!
class B { /*...*/ };
class D1 : public B { };
class D2 : public B { };
D1 d1;
B* b = &d1;
D2* d2 = static_cast<D2*>(b);
d2 will be a pointer to d1 (in some cases involving multiple inheritance there can be an offset), but interpret the latter's data totally differently (unless D1 and D2 are layout compatible) and you might end up in hell!
Now first off, I personally prefer a modified signature:
template <typename CompType>
inline CompType* getComponent();
// ^
It allows calling your function like getComponent<SomeType>() instead of getComponent<SomeType*>(), additionally it allows using pointers inside the function body, which is way clearer, see my my appropriately adjusted code below.
Then what you actually need is a dynamic_cast (adjusting your code a little to my personal preferences...):
CompType* result = nullptr; // pointer: see above!
for(Component * currComp : compStruct.components)
{
result = dynamic_cast<CompType*>(currComp);
if(result)
break;
}
return result;
Edit: Catching up Nshant Singh's comment:
dynamic_cast actually is quite expensive.
An alternative could be an unordered_map, replacing your vector (example how to set up can be found at type_index documentation; of course, you'd place your objects instead of strings...). Then your lookup might look like:
auto i = map.find(std::type_index(typeid(CompType));
return i == map.end() ? nullptr : static_cast<CompType*>(i->second);
// now, you CAN use static cast, as the map lookup provided you the
// necessary guarantee that the type of the pointee is correct!

Answer 2

static_cast is definitely not what you want: it's static (compile time), so it cannot determine any runtime information.
What you want is dynamic_cast instead. Note that this has several requirements, all of which are fulfilled by your code:
The classes must be polymorphic. That's covered, because Component has a virtual destructor.
The classes must be defined (not just declared) at the point of the cast. That's covered as well, because getComponent is a template and the type in the cast depends on its template parameters (it is one, in fact). Therefore, the definition only needs to be visible where the template is instantiated (i.e. where getComponent is called). Since you're presumably doing the casting to access the concrete component's members, you must have its definition visible, so all is well.