模板方法基于构造函数的可访问性在函数之间进行选择 [英] Template method to select between functions based on accessibility of constructor
问题描述
我写了一个类 ptr_scope_manager 来管理给定范围中指针的创建和销毁。我已经研究过这个问题的答案：
私人构造函数禁止使用emplace [_back]（）避免移动
看起来如果我想管理一个对象的创建一个类有一个 private 构造函数，我的内部 std :: vector 可以使用 push_back 但不是 emplace_back 来构造对象。这是因为 emplace_back 使用内部类来构造对象。也就是说， ptr_scope_manager 不足以允许它使用私有构造函数创建对象。
done是两个 create 方法，一个用于具有公共构造函数的对象，另一个用于具有私有构造函数的对象，其中包含 ptr_scope_manager 。
template< typename Type>
class ptr_scope_manager
{
private：
std :: vector< Type> ptrs;
public：
template< typename ... Args>
类型* 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（或其他？）自动选择 create_public（）和 create_private（）根据模板类型参数是否具有公共或私有构造函数？也许使用 std :: is_constructible ？
（）方法，它可以自动选择更有效的 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）...）
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>公共管理
ptr_scope_manager< private_ctor> private_manager;
ptr_scope_manager< non_friendly_private_ctor>非朋友
public_manager.create（3）;
private_manager.create（3）;
// non_friendly_private_manager.create（3）;引发错误
}
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.
#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
}
这篇关于模板方法基于构造函数的可访问性在函数之间进行选择的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
