The type unique_ptr is less general than the phrase “handle”, yes. But why shouldn’t it be? Just one of your “handle” examples (say, the one that is an integer index), is precisely as general as unique_ptr. You can’t compare one specific kind of handle with “all handles ever”. If you want a single, concrete C++ … Read more
There’s no need for wrapper classes for very basic functionality: std::ifstream file(“myfile”, std::ios::binary | std::ios::ate); std::streamsize size = file.tellg(); file.seekg(0, std::ios::beg); std::vector<char> buffer(size); if (file.read(buffer.data(), size)) { /* worked! */ }
I would not do this personally but just come up with unique names. But if you want to do it, one way is to use a combination of if and for: #define FOR_BLOCK(DECL) if(bool _c_ = false) ; else for(DECL;!_c_;_c_=true) You can use it like FOR_BLOCK(GlTranslate t(1.0, 0.0, 0.0)) { FOR_BLOCK(GlTranslate t(1.0, 1.0, 0.0)) { … Read more
Yes, it is guaranteed (provided the exception is caught), down to the order in which the destructors are invoked: C++11 15.2 Constructors and destructors [except.ctor] 1 As control passes from a throw-expression to a handler, destructors are invoked for all automatic objects constructed since the try block was entered. The automatic objects are destroyed in … Read more
I thoroughly endorse all the advice about RAII and smart pointers, but I’d also like to add a slightly higher-level tip: the easiest memory to manage is the memory you never allocated. Unlike languages like C# and Java, where pretty much everything is a reference, in C++ you should put objects on the stack whenever … Read more
I consider this to be an abuse of the using statement. I am aware that I’m in the minority on this position. I consider this to be an abuse for three reasons. First, because I expect that “using” is used to use a resource and dispose of it when you’re done with it. Changing program … Read more
NO This is what RAII is for, let the destructor do its job. There is no harm in closing it manually, but it’s not the C++ way, it’s programming in C with classes. If you want to close the file before the end of a function you can always use a nested scope. In the … Read more
So why isn’t that called “using the stack to trigger cleanup” (UTSTTC:)? RAII is telling you what to do: Acquire your resource in a constructor! I would add: one resource, one constructor. UTSTTC is just one application of that, RAII is much more. Resource Management sucks. Here, resource is anything that needs cleanup after use. … Read more
No, C++ does not support ‘finally’ blocks. The reason is that C++ instead supports RAII: “Resource Acquisition Is Initialization” — a poor name† for a really useful concept. The idea is that an object’s destructor is responsible for freeing resources. When the object has automatic storage duration, the object’s destructor will be called when the … Read more
The C++ Standard says that an STL element must be “copy-constructible” and “assignable.” In other words, an element must be able to be assigned or copied and the two elements are logically independent. std::auto_ptr does not fulfill this requirement. Take for example this code: class X { }; std::vector<std::auto_ptr<X> > vecX; vecX.push_back(new X); std::auto_ptr<X> pX … Read more