在返回值和“回调”之间做出决定时的样式与一致性

Question

The code I'm currently re-working works something like this (pre-C++11):

FOO.CPP

if (CONDITION)
{
    SyncThing thing;
}
else
{
    AysncThing thing;
}

complete(bool isSuccess)
{
    // parses status and clears up
}

where SyncThing and AsyncThing are as follows:

SYNCTHING.CPP

SyncThing::SyncThing()
{
    // some complex synchronous stuff that calls Foo::complete() when done.
}

ASYNCTHING.CPP

AsyncThing::AsyncThing()
{
    // some complex asynchronous stuff that calls Foo::complete() when done.
}

In the interest of not having constructors do complicated stuff and avoiding the non-obvious code path of the constructors calling Foo::complete() when done, I want to remove the complex stuff from SyncThing's constructor and put it in a separate function that's called from Foo.cpp's logic, as follows:

FOO.CPP

if (CONDITION)
{
    SyncThing thing;
    bool didTheThing = thing.doSomeComplexSyncStuff();       
    complete(didTheThing);
}
else
{
    AysncThing thing;
}

complete(bool isSuccess)
{
    // parses status and clears up
}

I think that makes the code path easier to follow.

My questions as as follows:

1. Ignoring AsyncThing, is my bool-return version of the SyncThing better and simpler than having the constructor of SyncThing or SyncThing::doSomeComplexSyncStuff() calling Foo::Complete() when done?

2. Overall, given that the 'callback' style returning is necessary when it comes to AsyncThing, is it better to keep the consistency and do the same for SyncThing, even if the answer to 1. is positive?

Thanks very much!

Answer 1

In my opinion the best Thing would be when you do something like SyncThing.setCompletedFunction(&complete) for SyncThing and AsyncThing . This makes it clear for both