5 ms·

In theory you have every single leakable resource wrapped up in a RAII container or a smart pointer. In reality you're almost always dealing with raw pointers c

• ajross 15y ago
  Sure. And using deep-thrown (i.e. thrown across module/library boundaries -- often exceptions are local tricks used within tightly coupled code) exceptions in an application where you're dealing with such pointers would be bad design.
• evincarofautumn 15y ago
  Typically what I do in that situation is lightly wrap the API. For instance: Image* image = allocate_image(…); … deallocate_image(image); ↓ struct ImageDeleter { void operator()(void* image) const { deallocate_image(image); } }; unique_ptr<Image, ImageDeleter> image(allocate_image(…)); That certainly can’t work everywhere, but I have yet to be failed by it.
  • jongraehl 15y ago
    People who don't do this are just asking for it.
    • malkia 15y ago
      That's a lot of boilerplate code. Okay there are macros to wrap such things, but I guess it's things like this that would make the future reader of the code puzzled.
      • cbsmith 15y ago
        jmq & basman provide examples of how to do it succinctly.
  • jmq 15y ago
    You can reduce verbosity of the code by passing destructor function directly to unique_ptr constructor: std::unique_ptr<Image, void (*)(Image *)>(image, deallocate_image);
    • evincarofautumn 15y ago
      Cool, thanks for the tip. I meant to offer an example for the general case.
  • basman 15y ago
    Or, perhaps easier: scoped_ptr<Image> image(allocate_image(...));