Why RAII rocks - Hackdot

Re:Why RAII rocks by falcolas on Thursday April 23, 2015 @06:52PM (#9430419)

What do you mean when you say 'as you can't "allocate" anything further down the call stack'? Do you mean you can't allocate something in c to be cleaned up in 'a', in the call tree:

    a(b(c()))

because just returning an object, then dropping the reference at the end of 'a' would do just that. You could also write your own context manager to wrap up a parameter.

    class Shadow(object):
        def __init__(self):
            self.value = None
        def __enter__(self):
            return self
        def set(self, v):
            self.value = v
        def __exit__(self, *args):
            if self.value is not None:
                self.value.cleanup()
        
    with Newdb() as db, Shadow() as d:
        a(b(c(db, d)))

[ Parent | on HN ]

Re:Why RAII rocks by czinck on Friday April 24, 2015 @08:49AM (#9432944)

you can do something like

    with a(b(c)) as f:

but then you risk any of those functions throwing an exception and screwing up the whole thing. You can move the resource allocation from __init__ to __enter__, but now you split your initialization code over 2 constructors. You can just hope and pray that a and b don't throw an exception, but someone is gonna accidentally break that assumption. And even if they don't, you've now spent more time worrying about that then if you just did manual memory allocation.

Or, in C++ you write

    class Foo {
    public:
        Foo() {/*get handle*/}
        ~Foo() {/*release resource*/}
    };

and you never have to worry again.

[ Parent | on HN ]

Re:Why RAII rocks by falcolas on Friday April 24, 2015 @09:40AM (#9433180)

> You can move the resource allocation from __init__ to __enter__, but now you split your initialization code over 2 constructors

After giving it some thought, I've come up with a better example which more closely maps to C++ RAII constructs, which shows that you don't need to split anything. Consider:

    class Shadow(object):
        def __init__(self):
            # Initialization code
        @classmethod
        def __enter__(cls, *args, **kwargs):
            return cls(*args, **kwargs)
        def __exit__(self, *args, **kwargs):
            # De-initialize

`__enter__` becomes three lines of boilerplate, which you could abstract out into an inheritable class, should you so desire.

As for "In C++ you write", it's the same as saying "in Python you write __enter__ and __exit__", but instead of instantiating via `std::unique_ptr` you use `with`.

[ Parent | on HN ]

Re:Why RAII rocks by czinck on Friday April 24, 2015 @11:50AM (#9434136)

Huh, neat. I'd seen @classmethod a few times but wasn't sure what it did. I need to see if I can refactor some code now.

[ Parent | on HN ]