Initialize object from unknown derived class of known base class - c++

Question

So, I'm making a library for a little D2D Engine; but that's not the point, the thing is, I have this class which will be the base class the user's class will inherit. My main idea would be something like this:
struct BaseEngine {
// I have two pure virtual functions so the user has to define them.
virtual bool onLoad() = 0;
virtual bool onFrame() = 0;
};
Now, if it all were to be in the same project, I could do something like this right after that:
struct Derived : public BaseEngine {
bool onLoad() override;
bool onFrame() override;
};
const std::unique_ptr<BaseEngine> app = std::make_unique<Derived>();
But my idea is, in fact, to not hold the derived class in my header files, and build the library without any possible definition of a derived class, thus, the user can just name it whatever they want in their project.
Of course it won't let me compile it, because I can't construct BaseEngine because it has pure virtual functions.
Then I though of somehow using templates to maybe solve this issue? Now I'm not very familiar with templates, but my idea was to make something like:
std::unique_ptr<BaseEngine> app;
template<class T : public BaseEngine>
void instantiator() {
app = std::make_unique<T>();
}
Knowing that T holds an implementation for onLoad() and onFrame().
But of course, when I need a feature such as templates of explicitly derived classes, no feature exists (not that I know of, at least).
My main question being: is there a way for me to initialize an object from an "unknown" derived class of my known base class?
Edit: forgot to mention that the main function (WinMain in this case) will be on the engine side, as it takes care of window class registration and all those nasty messages.

Answer 1

It sounds like you'd like to compile your code as a shared library, that you can link to in another project that will become the main executable. Unfortunately, there can be issues sharing class types between libraries and executables due to differences in how they might be compiled--I wouldn't recommend going down that route.
If you can compile it all at once, though (i.e. the user has access to uncompiled source and header files) you won't have to deal with that. Just provide a function that takes an instance of BaseEngine.
// BaseEngine.h
class BaseEngine { /* ... */ }
void startGame(std::unique_ptr<BaseEngine> engine) { /* ... */ }
// main.cpp (user edits this file)
#include "BaseEngine.h"
class DerivedEngine : public BaseEngine {
// override methods here
}
int main() {
return startGame(std::make_unique<DerivedEngine>());
}

Answer 2

The usual answer to this would be to have a function in your engine that takes a caller-created BaseEngine derived object as an argument.
// Engine side function
bool InitializeEngine(BaseEngine * pEngine);
An alternative answer (depending on how the user-supplied code is bundled) would be to have an exported function with a set name and have that function return a created BaseEngine derived object.
// User side code
BaseEngine * CreateEngine();
And then use dlopen/dlsym (or LoadLibrary/GetProcAddress on windows) to obtain the function pointer for CreateEngine. In either case it is the user's code where the object type is known that is responsible for creating the object.

Answer 3

Static polymorphism: the Curiously Recurring Template Pattern (CRTP)
You may want to consider using the Curiously Recurring Template Pattern (CRTP):
#include <ios>
#include <iostream>
#include <memory>
#include <type_traits>
template <class T> struct BaseEngine {
bool onLoad() const { return static_cast<T const *>(this)->onLoad(); }
bool onFrame() { return static_cast<T *>(this)->onLoad(); }
};
// API exposed to library users.
template <typename T,
typename = std::enable_if_t<std::is_base_of<BaseEngine<T>, T>::value>>
auto createEngine() {
return std::make_unique<T>();
}
template <typename T> bool foo(const BaseEngine<T> &engine) {
return engine.onLoad();
}
// Stub for your own testing etc.
struct StubEngine : BaseEngine<StubEngine> {
bool onLoad() const {
std::cout << "stub onLoad()\n";
return true;
}
bool onFrame() {
std::cout << "stub onFrame()\n";
return false;
}
};
struct BadEngine {};
int main() {
auto engine = createEngine<StubEngine>();
// auto bad_engine = createEngine<BadEngine>();
// error: no matching function for call to 'createEngine'
const bool f = foo(*engine); // stub onLoad()
std::cout << std::boolalpha << f; // true
return 0;
}
By implementing static polymorphism using templates, you can work within you lib with a type template parameter T in the context of BaseEngine without having to know what T is (as it will be up to the library user to implement particular concrete "statically derived" classes, i.e., specific T's); possibly placing, however, restrictions on T using type traits and SFINAE.