基于构造函数可访问性选择函数的模板方法

Question

我正在编写一个名为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()。

- Galik

---

使用std::is_constructible和std::enable_if，您应该能够选择要使用的方法。 - Some programmer dude

@Joachim 鼓舞人心，但我对 SFINAE 类型技巧还很陌生，不知道该如何继续。 - Galik

只是一个问题：如果私有自定义分配器调用管理器的私有（静态）方法，是否可以解决问题而无需使用SFINAE？这将允许emplace正常工作。 - firda

Answer 1

Live demo link.

#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
}

- Piotr Skotnicki

---

抱歉这么晚才接受。我担心std::is_constructible在检测公共/私有方面是依赖于实现的，所以一直在尝试实现自己的is_instantiable<> SFINAE技巧，但到目前为止还没有弄清楚如何让它工作。不过我相信这是可能的。 - Galik

Answer 2

注意：这不是针对标题的答案，而是针对作者意图的回答：这意味着将ptr_scope_manager添加为好友不足以允许其创建具有私有构造函数的对象。...并且我在评论中的声明得到了证明：使用调用管理器的私有（静态）方法的私有自定义分配器可以解决问题，而无需使用SFINAE？那样可以使emplace工作。这里是IdeOne演示。

#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;
}

- firda

---

谢谢您提供的解决方案。目前它超出了我的理解能力，但我会尽力去理解它是如何工作的！ - Galik

诀窍是将构造函数转发到您可以使其成为友元的类 - manager中的那两种静态construct方法。这只是从std :: allocator :: construct中简单复制粘贴。稍后的rebind只是我在Cygwin中实现deque的解决方法（实际上可能很糟糕，不遵循标准，让我感到惊讶，但重新绑定修复了它）。 - firda

Answer 3

我对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 无法构造，则应选择第一个变体，否则应选择第二个变体。

- Some programmer dude

---

无论是OR还是SFINAE都没有考虑到可访问性。至少在我上次检查时是这样的。 - Puppy

@PiotrS.：这并不意味着必须进行构建。它可能只是在该编译器和标准库上构建。 - Puppy

@Puppy：SFINAE并不检查manager是否是friend，而是检查emplace能否被使用（是否存在公共构造函数）。友谊关系随后需要在push_back中进行构建（如果它不是公共的）。...但对于当前情况：我认为指针必须在SFINAE内部，而不是外部。 - firda