Template method to select between functions based on accessibility of constructor

Question

I am writing a class ptr_scope_manager to manage the creation and destruction of pointers in a given scope. I have studied the answers from this question:

Private constructor inhibits use of emplace[_back]() to avoid a move

And it appears that if I want to manage the creation of an object whose class has a private constructor, my internal std::vector can use push_back but not emplace_back to construct the object. This is because emplace_back uses an internal class to construct the object. That means friending the ptr_scope_manager is not sufficient to allow it to create objects with private constructors.

So what I have done is make two create methods, one for objects with public constructors and one for objects with private constructors that have friended the 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);
}

My question is this:

Is there any way I can use SFINAE (or otherwise?) to automatically select between create_public() and create_private() based on whether or not the template Type parameter has a public or private constructor? Perhaps utilizing std::is_constructible?

It would be nice to have only one create() method that auto-selects the more efficient create_public() method where possible and falling back on the slightly less efficient create_private when necessary.

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
}

Answer 2

I'm pretty new to SFINAE too, but I think it could be done something like

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();
}

If Type is not constructible then the first variant will be selected, otherwise the second should be selected.

Answer 3

Note: This is not an answer to the title but to the intent of the author: ...That means friending the ptr_scope_manager is not sufficient to allow it to create objects with private constructors. ...and a proof of my statement in comment: wouldn't private custom allocator calling private (static) methods of the manager solve the problem without the need for SFINAE? That would allow the emplace to work.

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