Question

假设我有两个工厂函数，一个返回std::unique_ptr，另一个返回std::shared_ptr：

template<class T, class... Args>
std::shared_ptr<T> createObjectS (Args... args)
{
  // running some code
  return std::make_shared<T>(args...);
}
template<class T, class... Args>
std::unique_ptr<T> createObjectU (Args... args)
{
  // running some code
  return std::make_unique<T>(args...);
}

是否可以使用模板元编程将这两个功能组合为一个功能？

Answer 1

您可以使用SFINAE，但是后来我真的看不到将其包含在函数中的意义。这很多余。

#include <memory>
#include <type_traits>

template <class T, class... Args>
typename std::enable_if<
    std::is_same<T, std::shared_ptr<typename T::element_type>>::value, T>::type
createObject(Args&&... args) {
    // running some code
    return std::make_shared<typename T::element_type>(std::forward<Args>(args)...);
}
template <class T, class... Args>
typename std::enable_if<
    std::is_same<T, std::unique_ptr<typename T::element_type>>::value, T>::type
createObject(Args&&... args) {
    // running some code
    return std::make_unique<typename T::element_type>(std::forward<Args>(args)...);
}

int main() {
    auto s = createObject<std::shared_ptr<int>>(1);
    auto u = createObject<std::unique_ptr<int>>(1);
}

紧凑一些，但本质上是相同的，只是带有范围内的枚举

#include <memory>

enum class ptr_t { shared, unique };

template <ptr_t P, class T, class... Args>
typename std::enable_if<P == ptr_t::shared, std::shared_ptr<T>>::type
createObject(Args&&... args) {
    // running some code
    return std::make_shared<T>(std::forward<Args>(args)...);
}
template <ptr_t P, class T, class... Args>
typename std::enable_if<P == ptr_t::unique, std::unique_ptr<T>>::type
createObject(Args&&... args) {
    // running some code
    return std::make_unique<T>(std::forward<Args>(args)...);
}

int main() {
    auto s = createObject<ptr_t::shared, int>(1);
    auto u = createObject<ptr_t::unique, int>(1);
}

在C ++ 17中，您当然在两种情况下都使用if constexpr而不是SFINAE。

#include <memory>

enum class ptr_t { shared, unique };

template <ptr_t P, class T, class... Args>
decltype(auto) createObject(Args &&... args) {
    // running some code
    if constexpr (P == ptr_t::shared) {
        return std::make_shared<T>(std::forward<Args>(args)...);
    } else if (P == ptr_t::unique) {
        return std::make_unique<T>(std::forward<Args>(args)...);
    }
}

Answer 2

通过专业化，您可以：

template <typename T> struct FactoryImpl;

template <typename T> struct FactoryImpl<std::unique_ptr<T>>
{
    template <typename ... Ts>
    auto operator ()(Ts&&... args) const
    {
        return std::make_unique<T>(std::forward<Ts>(args)...);
    }
};

template <typename T> struct FactoryImpl<std::shared_ptr<T>>
{
    template <typename ... Ts>
    auto operator ()(Ts&&... args) const
    {
        return std::make_shared<T>(std::forward<Ts>(args)...);
    }
};

template<class T, class... Ts>
auto createObjectS (Ts&&... args)
{
    return FactoryImpl<T>{}(std::forward<Ts>(args)...);
}

用法：

auto s = createObject<std::shared_ptr<MyObject>>(42);
auto u = createObject<std::unique_ptr<MyObject>>(42);

结合两种在C ++中将unique_ptr和shared_ptr返回到一个的工厂方法？

2 个答案: