Try/finally cleaner than multiple gotos with label?

gistfile1.m

void myfunc() {
    void *thing1 = NULL;
    void *thing2 = NULL;
    
    @try {
        thing1 = allocThing1();
        if (!thing1) return;

        // …use thing1 maybe

        if (somethingWentWrongWithThing1) return;

        // …use thing1 more maybe
        
        thing2 = allocThing2();
        if (!thing2) return;
        
        // …use thing2 and maybe thing1

        if (somethingWentWrongWithThing2) return;

        // …use thing2 more and maybe thing1 more

    } @finally {
        if (thing1) deallocThing1(thing1);
        if (thing2) deallocThing2(thing2);
    }
}

One might even argue that try/finally is less awkward than gotos with a label...

void myfunc() {
    void *thing1 = NULL;
    void *thing2 = NULL;

    thing1 = allocThing1();
    if (!thing1) goto cleanup;

    // …use thing1 maybe

    if (somethingWentWrongWithThing1) goto cleanup;

    // …use thing1 more maybe

    thing2 = allocThing2();
    if (!thing2) goto cleanup;

    // …use thing2 and maybe thing1

    if (somethingWentWrongWithThing2) goto cleanup;

    // …use thing2 more and maybe thing1 more

cleanup:
    if (thing1) deallocThing1(thing1);
    if (thing2) deallocThing2(thing2);
}

I think this is more standard, cleaner, and portable. Also, there is no runtime overhead cost associated with this.

I was responding only to a claim that goto was less awkward than try/finally. Which I think is not true. Neither of us made any claims about runtime overhead or cost of any kind :)

And I honestly think reasonable people can disagree on which looks "cleaner" or less "awkward". I'd say the try/finally wins there. It's certainly more structured. But then, I'm used to seeing this in Java.