C++

Question

我正在尝试在 C++ 中创建一个自动解决依赖关系的 IoC 容器。

为此，我创建了一个带有两个可变参数包的函数，声明如下：

template <class T, typename ... TDependencies, typename... TArgs> 
void Register(std::function<std::shared_ptr<T> (std::shared_ptr<TDependencies> ...,
TArgs ...)> && pFactory)

显然，编译器在提供时似乎无法匹配它

Register<Foo, Bar>(std::function<std::shared_ptr<Foo>(std::shared_ptr<Bar>)>(
[](std::shared_ptr<Bar> bar){return std::make_shared<Foo>(bar);}));

编译错误说

note: candidate: 'void Container::Register(std::function<std::shared_ptr<_Tp>
(std::shared_ptr<TDependencies>..., TArgs ...)>&&)
[with T = Foo; TDependencies = {Bar}; TArgs = {std::shared_ptr<Bar>}]'

显然，它匹配 std::shared_ptr<Bar> 两次。我怎样才能让编译器不匹配 TArgs 中的 shared_ptr？

Answer 1

与其尝试直接从 pFactory 参数类型推导出 TDependencies，我会编写一个类型特征来从整个参数包中获取依赖项。随着 boost::mp11:

template <class>
struct is_shared_ptr : std::false_type {};

template <class T>
struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};

namespace mp11 = ::boost::mp11;

template <class... Ts>
using register_traits = mp11::mp_partition<mp11::mp_list<Ts...>, is_shared_ptr>;

template <class T, class F, class... TDependencies, class... TArgs>
void RegisterImpl(F && pFactory,
                  mp11::mp_list<
                      mp11::mp_list<std::shared_ptr<TDependencies>...>,
                      mp11::mp_list<TArgs...>>);

template <class T, class... Ts> 
void Register(std::function<std::shared_ptr<T> (Ts...)> && pFactory)
{
    return RegisterImpl<T>(
        std::forward<std::function<std::shared_ptr<T> (Ts...)>>(pFactory),
        register_traits<Ts...>{});
}

并调用它：

Register(std::function{[] (std::shared_ptr<Bar> bar) {
    return std::make_shared<Foo>(bar);
}});

Try it on godbolt.org.

如果 boost::mp11 不是一个选项，下面是您可以实现自己的 partition 模板元功能的方法：

template <class...>
struct list {};

namespace detail {
template <class L, template <class...> class P, class T, class F, class = void>
struct partition;

template <class Next, class... Ls,
          template <class...> class P, class T, class... Fs>
struct partition<list<Next, Ls...>, P, T, list<Fs...>,
                 std::enable_if_t<!P<Next>::value>> :
       partition<list<Ls...>, P, T, list<Fs..., Next>> {};

template <class Next, class... Ls,
          template <class...> class P, class... Ts, class F>
struct partition<list<Next, Ls...>, P, list<Ts...>, F,
                 std::enable_if_t<P<Next>::value>> :
       partition<list<Ls...>, P, list<Ts..., Next>, F> {};

template <template <class...> class P, class T, class F>
struct partition<list<>, P, T, F> { using type = list<T, F>; };
} // namespace detail

template <class L, template <class...> class P>
using partition = typename detail::partition<L, P, list<>, list<>>::type;

template <class... Ts>
using register_traits = partition<list<Ts...>, is_shared_ptr>;

template <class T, class F, class... TDependencies, class... TArgs>
void RegisterImpl(F && pFactory,
                  list<list<std::shared_ptr<TDependencies>...>, list<TArgs...>>);

Try it on godbolt.org.

其余代码将保持不变。

C++ - 具有多个参数包和一个 std::function 作为参数的函数

C++ - Function with multiple parameter packs and a std::function as argument

variadic-templates

c++17