Abstract Factory Improvements - c++

Question

Edited: I decided to edit this post for future readers. Put simply, it shows an acceptable way to call constructors of template types within the template list. For example, the following:
int main()
{
unique_ptr<factory> real_widget_factory(new widget_factory(5.0, 6.0));
}
Instead of just being limited to:
unique_ptr<factory> real_widget_factory(new widget_factory()); // empty

Answer 1

The Standard provides all the necessary infrastructure you need. You can delete all of that code.
template<typename T, typename... Args> std::unique_ptr<T> make_unique(Args&&... args) {
return std::unique_ptr<T>(std::forward<Args>(args)...);
}
struct train_factory {
train_factory(std::function<std::unique_ptr<locomotive>()> ml,
std::function<std::unique_ptr<freight_car>()> mc)
: make_locomotive(std::move(ml)),
, make_car(std::move(mc)) {}
std::function<std::unique_ptr<locomotive>()> make_locomotive;
std::function<std::unique_ptr<freight_car>()> make_car;
};
train_factory make_concrete_factory(double x1, double x2) {
return train_factory(
[=] { return make_unique<real_locomotive>(x1); },
[=] { return make_unique<real_car>(x2); }
);
}
int main() {
auto fact = make_concrete_factory(1.0);
auto loc = fact.make_locomotive();
}
This appears to meet all of your requirements. In this case, the functions have the arguments to the factory bound in (and this binding is arbitrary). You can of course also modify the functions to take the arguments if you like, or use both in arbitrary ways and combinations.
struct train_factory {
std::function<std::unique_ptr<locomotive>(double)> make_locomotive;
std::function<std::unique_ptr<freight_car>(double)> make_car;
};
train_factory make_concrete_factory() {
return train_factory {
[](double x1) { return make_unique<real_locomotive>(x1); },
[](double x2) { return make_unique<real_car>(x2); }
};
}
int main() {
auto fact = make_concrete_factory();
auto loc = fact.make_locomotive(1.0);
}