raii

I'm working on a section of code that has many possible failure points which cause it to exit the function early. The libraries I'm interacting with require that C-style arrays be passed to the functions. So, instead of calling delete on the arrays at every exit point, I'm doing this: void SomeFunction(int arrayLength) { shared_ptr<char> raiiArray(new char[arrayLength]); pArray = raiiArray.get(); if(SomeFunctionThatRequiresCArray(pArray) == FAILED) { return; } //etc. } I wanted to use unique_ptr , but my current compiler doesn't support it and the reference count overhead doesn't really matter

In a program I recently wrote, I wanted to log when my "business logic" code triggered an exception in third-party or project APIs. ( To clarify, I want to log when use of an an API causes an exception. This can be many frames above the actual throw , and may be many frames below the actual catch ( where logging of the exception payload can occur. ) ) I did the following: void former_function() { /* some code here */ try { /* some specific code that I know may throw, and want to log about */ } catch( ... ) { log( "an exception occurred when doing something with some other data" ); throw; } /*

I have read through many questions on SO on custom deleter for shared_ptr and unique_ptr , and the difference between the two. But, I still haven't found any clear answer to this question: How can one best go about creating a type that acts as a shared_ptr with a custom deleter, similar to how unique_ptr has the deleter as part of the type definition? For unique_ptr usage, I use a deleter class, that handles deletion of individual types (limiting it to just two types, for brevity): struct SDL_Deleter { void operator()( SDL_Surface* ptr ) { if (ptr) SDL_FreeSurface( ptr );} void operator()( SDL

Here's an article that talks about an idiom named Rule of Zero . Here's an excerpt: class module { public: explicit module(std::wstring const& name) : handle { ::LoadLibrary(name.c_str()), &::FreeLibrary } {} // other module related functions go here private: using module_handle = std::unique_ptr<void, decltype(&::FreeLibrary)>; module_handle handle; }; It reuses unique_ptr RAII features so you don't need to care about implementing a daunting and verbose Rule of Five wrapper. Presented this way (managing handle based resources with unique_ptr , that way), it looks as a hack for me, not a best

I tried looking through source but I cant navigate that much of a template code. Basically: this is what documentation says (for close() ): Remarks For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. I can do that manually, but if possible it would be nice to rely on RAII. So if I have socket going out of scope do I need to call shutdown() and close() on it, or it will be done automatically? One can rely on the socket performing proper cleanup with RAII. When an IO object, such as socket, is destroyed, its destructor will

Traditionally, in C++, you would create any dependencies in the constructor and delete them in the destructor. class A { public: A() { m_b = new B(); } ~A() { delete m_b; } private: B* m_b; }; This technique/pattern of resource acquisition, does it have a common name? I'm quite sure I've read it somewhere but can't find it now. Edit: As many has pointed out, this class is incomplete and should really implement a copy constructor and assignment operator. Originally, I intentionally left it out since it wasn't relevant to the actual question: the name of the pattern. However, for completeness