In the previous articles on automated instance construction (first and second) I showed how you can use constructor-argument deduction to automatically do dependency injection. While that approach worked nicely in general, one little detail was still nagging me: Since construction of the actual objects happens at the end of a recursion, the stack depth in some of those construction could get quite deep. In fact there are an additional Max–actual number of c’tor parameters functions on the stack before the c’tor is called. This effect is even worse when resolving long dependency chains, were those functions are there for each of the dependencies currently being resolved.
The previous code uses an std::index_sequence of the exactly the right length to inject the same number of mimic parameters that are then used to locate dependencies. If we knew the right length, there wouldn’t have to be any recursion around the construction. And that’s actually easy to refactor out, we can just figure out the std::index_sequence first and return, and then use it outside of the recursion:
template <class T, std::size_t Head, std::size_t... Rest>
constexpr auto
injection_parameter_sequence(std::index_sequence<Head, Rest...>,
decltype(T{ mimic<T>{ Head }, mimic<T>{ Rest }... })* = nullptr)
{
return std::index_sequence<Head, Rest...>{};
}
template <class T>
constexpr auto injection_parameter_sequence(std::index_sequence<>)
{
return std::index_sequence<>{};
}
template <class T, std::size_t... Rest>
constexpr auto
injection_parameter_sequence(std::index_sequence<Rest...>)
{
return injection_parameter_sequence<T>(std::make_index_sequence<sizeof...(Rest) - 1>{});
}Starting with a “long” index sequence, this overload set returns the smaller index sequence for the construction. We can use a small tool function to actually create the instance:
template <class T, std::size_t... Params>
constexpr auto make_unique_injected_with_sequence(service_provider const& p, std::index_sequence<Params...>)
{
return std::make_unique<T>(mimic<T>(p, Params)...);
}Which can be called like this:
template <class T, std::size_t Max = 16> auto make_unique_injected(service_provider const& p)
{
return make_unique_injected_with_sequence<T>(p,
injection_parameter_sequence<T>(std::make_index_sequence<Max>{}));
}Only these last two function will be added to the call stack for each constructor call, which is not a whole lot. This construction has the additional advantage that only these two need to be changed to support different kinds construction, e.g. using std::make_shared instead of std::make_unique.
Schneide Blog 