Stop heap allocation through make_shared

Question

I want to force my object to be on the stack in order to provide very strict semantics and solve some problems related to life. I read a couple of articles on how to do this, and came up with making operator new private (or remote). This seems to work as expected when new used directly, but make_shared compiles fine.

 #include <boost/smart_ptr.hpp> class A { private: void *operator new( size_t ); void operator delete( void* ); void *operator new[]( size_t ); void operator delete[]( void* ); }; int main() { // A* a = new A; // Correctly produces compile error boost::shared_ptr<A> a2 = boost::make_shared<A>(); } 

Using new A directly gives me this error as expected:

 error: 'static void* A::operator new(size_t)' is private 

I assume that make_shared works because it uses a new placement operator, but I could not find articles that discussed how to prohibit this. The best solution I came up with is to explicitly exclude template specialization for make_shared

 namespace boost { template<> shared_ptr<A> make_shared<A>() = delete; }; 

This is obviously very specific to boost::make_shared . Is this really the best way?

Answer 1

The new placement forms are pretty easy to handle - they just come with extra arguments. For example, a simple form of placement

 void* operator new(std::size_t, void*); 

Note that 18.6.1.3 prohibits overriding them in the global scope; however, there should not be any problems with overriding (or deleting / impossibility) them for your specific type.

Unfortunately, make_shared uses the scope ::new (pv) T(std::forward<Args>(args)...) . And, as I mentioned, you are not allowed to mess around with the global hosting of the new. Thus, you cannot prevent it at compile time, and any runtime trap will crack (check this pointer to see if it is a stack boundary).

Answer 2

You cannot ensure that class objects are always on the stack, making only operators available: any object that can be constructed on the stack can also be embedded as a member in another object. Although your source class may struggle to be allocated on the heap, a class that will not contain. I would think that this happens in the case of boost::make_shared() : inside it, probably, some record is selected that contains both the administration data and the selected object. Alternatively, it can use a distribution function from a sort of allocator that does not match the type operator new() , but uses its own operator new() overload instead.

I'm not sure if it is possible to prevent heap allocation (at least when the object is embedded in another object), but any approach that does this should make inaccessible constructors (most likely private ) and use something like factory functions, maybe combined with moving. On the other hand, if you can move an object, you have an available constructor, and nothing prevents the object from being moved to an object on the heap.

If you specifically want to prevent the use of std::make_shared() for a particular type (or boost::make_shared() , although I cannot quote the rules for specializing the latter), you can specialize std::make_shared() : according to 17.6.4.2. 1 [namespace.std], clause 1, the user can specialize in any template (unless otherwise specified), if it is associated with a custom type. Thus, you can prohibit the use of A with std::make_shared() :

 class A { public: A(); A(int); }; namespace std { template <> std::shared_ptr<A> make_shared<A>() = delete; template <> std::shared_ptr<A> make_shared<A, int>(int&&) = delete; } namespace boost { template <> boost::shared_ptr<A> make_shared<A>() = delete; template <> boost::shared_ptr<A> make_shared<A, int>(int&&) = delete; } 

Obviously, if you have several constructors in A , you may need to add additional specializations .... and if your type is a class template or your constructor as a template, you are out of luck: you cannot partially specialize function templates.

Regarding your question about placing new (which may or may not be used by make_shared() ): The signatures of new (and delete ) are as follows:

 void* operator new(size_t, void*) noexcept; void* operator new[](size_t, void*) noexcept; void operator delete(void*, void*) noexcept; void operator delete[](void*, void*) noexcept; 

(see clause 18.6 [support.dynamic]). I doubt that making them inaccessible will help you.