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.
Destructors and copy constructors cannot be templates. If a template constructor is declared which could be instantiated with the type signature of a copy constructor, the implicitly-declared copy constructor is used instead.
For normal code, you would use a class template when you want to create a class that is parameterised by a type, and a function template when you want to create a function that can operate on many different types.
What is the correct syntax of defining function template/template functions? Explanation: Starts with keyword template and then <class VAR>, then use VAR as type anywhere in the function below. 7.
There is no difference between using <typename T> OR <class T> ; i.e. it is a convention used by C++ programmers.
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
}
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.
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;
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With