根据构造函数的可访问性在函数之间进行选择的模板方法

Template method to select between functions based on accessibility of constructor

本文关键字：之间 行选 函数 选择 模板方法 构造函数 访问      更新时间：2023-10-16

我正在编写一个类ptr_scope_manager来管理给定范围内指针的创建和销毁。我已经研究了这个问题的答案:

私有构造函数禁止使用emplace[_back]()来避免移动

并且，如果我想管理一个类具有私有构造函数的对象的创建，我的内部std::vector可以使用push_back而不是emplace_back来构造对象。这是因为emplace_back使用内部类来构造对象。这意味着将ptr_scope_manager归为朋友不足以允许它创建具有私有构造函数的对象。

所以我所做的是创建两个create方法，一个用于具有公共构造函数的对象，另一个用于具有私有构造函数的对象，它们与ptr_scope_manager为友。

template<typename Type>
class ptr_scope_manager
{
private:
    std::vector<Type> ptrs;
public:
    template<typename... Args>
    Type* create_private(Args... args)
    {
        ptrs.push_back(Type(args...));
        return &ptrs.back();
    }
    template<typename... Args>
    Type* create_public(Args... args)
    {
        ptrs.emplace_back(args...);
        return &ptrs.back();
    }
};
class public_ctor
{
    int i;
public:
    public_ctor(int i): i(i) {} // public
};
class private_ctor
{
    friend class ptr_scope_manager<private_ctor>;
    int i;
private:
    private_ctor(int i): i(i) {} // private
};
int main()
{
    ptr_scope_manager<public_ctor> public_manager;
    ptr_scope_manager<private_ctor> private_manager;
    public_manager.create_public(3);
    public_manager.create_private(3);
//  private_manager.create_public(3); // compile error
    private_manager.create_private(3);
}

是否有任何方法我可以使用SFINAE(或其他方式?)根据模板Type参数是否有公共或私有构造函数，自动选择create_public()和create_private() ?也许使用std::is_constructible ?

最好只有一个create()方法，在可能的情况下自动选择更有效的create_public()方法，并在必要时返回到效率稍低的create_private方法。

现场演示链接

#include <type_traits>
#include <utility>
#include <vector>
template <typename Type>
class ptr_scope_manager
{
private:
    std::vector<Type> ptrs;
public:
    template <typename T = Type, typename... Args>
    auto create(Args&&... args) -> typename std::enable_if<!std::is_constructible<T, Args...>::value, T*>::type
    {
        ptrs.push_back(T{ std::forward<Args>(args)... });
        return &ptrs.back();
    }
    template <typename T = Type, typename... Args>
    auto create(Args&&... args) -> typename std::enable_if<std::is_constructible<T, Args...>::value, T*>::type
    {
        ptrs.emplace_back(std::forward<Args>(args)...);
        return &ptrs.back();
    }
};
class public_ctor
{
    int i;
public:
    public_ctor(int i): i(i) {} // public
};
class private_ctor
{
    friend class ptr_scope_manager<private_ctor>;
    int i;
private:
    private_ctor(int i): i(i) {} // private
};
class non_friendly_private_ctor
{
    int i;
private:
    non_friendly_private_ctor(int i): i(i) {} // private
};
int main()
{
    ptr_scope_manager<public_ctor> public_manager;
    ptr_scope_manager<private_ctor> private_manager;
    ptr_scope_manager<non_friendly_private_ctor> non_friendly_private_manager;
    public_manager.create(3);
    private_manager.create(3);
    // non_friendly_private_manager.create(3);  raises error
}

我对SFINAE也很陌生，但我认为它可以这样做

template<typename... Args>
typename std::enable_if<!std::is_constructible<Type, Args...>::value, Type>::type*
create(Args... args)
{
    ptrs.push_back(Type(args...));
    return &ptrs.back();
}
template<typename... Args>
typename std::enable_if<std::is_constructible<Type, Args...>::value, Type>::type*
create(Args... args)
{
    ptrs.emplace_back(args...);
    return &ptrs.back();
}

如果Type是不可构造的，则选择第一个变体，否则选择第二个。

注意:这不是对标题的回答，而是对作者的意图: …这意味着将ptr_scope_manager归为朋友不足以允许它创建具有私有构造函数的对象。…并证明我在评论中的陈述:私有自定义分配器调用管理器的私有(静态)方法不需要SFINAE就能解决问题吗?这将允许放置工作

IdeOne demo here

#include <deque>
#include <memory>
#include <iostream>
template<class T> class manager {
    static void construct(T* p, const T& val) {
        new((void*)p) T(val); }
    template<class U, class... Args>
      static void construct(U* p, Args&&... args) {
        new((void*)p) T(std::forward<Args>(args)...); }
    class allocator: public std::allocator<T> {
    public:
        void construct(T* p, const T& val) {
            manager::construct(p, val); }
        template<class U, class... Args>
          void construct(U* p, Args&&... args) {
              manager::construct(p, std::forward<Args>(args)...); }
    //needed for deque ...dunno why it is using rebind for T
        template<class U> struct rebind {
            typedef typename std::conditional<
              std::is_same<T,U>::value, allocator,
              std::allocator<U>>::type other; };
    };
    std::deque<T, allocator> storage; //deque preserves pointers
public:
    template<class... Args>
      T* create(Args&&... args) {
        storage.emplace_back(std::forward<Args>(args)...);
        return &storage.back();
    }
};
class special {
    friend class manager<special>;
    int i;
    special(int i): i(i) {}
public:
    int get() const { return i; }
};
int main() {
    manager<special> m;
    special* p = m.create(123);
    std::cout << p->get() << std::endl;
}
相关文章：