Refactoring this code to optimize

Question

bool FunctionA (const ObjectA& a)
{
    // ... some code ...
    const ObcjectB& b = getObjectBFromSomewhere(...);
    // ... code heavily reliant on b ...
    return boolean_val;
}

bool FunctionB (const ObjectA& a)
{
    bool boolean_val = FunctionA(a);

    // ... some code ...
    const ObcjectB& b = getObjectBFromSomewhere(...);
    // ... code that only needs one tiny bit of b ...
    return boolean_val;
}

FunctionA gets called just once. FunctionB also only gets called once. Both get called in different flows.

The code that "getObjectBFromSomewhere" is memory heavy so I want to only call it once.

What's the best way to refactor this code?

Its legacy code with millions of lines of code that are reliant on ObjectA and ObjectB, can't make changes. — solarflare, Jun 20 '18 at 01:24
i dont think making it static will affect anything but will just solve your problem. you are wanting `getObjectBFromSomewhere` to be only called once, that sounds like that the object returned from that function will always be the same no matter how many times u call it. — Lorence Hernandez, Jun 20 '18 at 01:30
mybad, do you mean that u only want to call the `getObjectBFromSomewhere` once and then both function will use the returned obj from it? — Lorence Hernandez, Jun 20 '18 at 01:34
No because that object is dynamic, it can change between flows. — solarflare, Jun 20 '18 at 01:38
that doesnt even match up your code, the object is a constant reference. — Lorence Hernandez, Jun 20 '18 at 01:43
If you only call `getObjectBFromSomewhere()` once then how are changes going to be reflected? — Galik, Jun 20 '18 at 01:44
Its a constant reference within the function yes but from the time one flow executes to the time the next flow executes it may have changed the contents. So there's no guarantee they'll be looking at the same thing — solarflare, Jun 20 '18 at 01:46
@Galik I edited. The function only really uses one tiny part of the object. — solarflare, Jun 20 '18 at 01:48
Are you saying the function returns a reference to a different object or the returned object's value gets changed? — Galik, Jun 20 '18 at 01:48
Oops sorry thats just a bool returning - question edited again — solarflare, Jun 20 '18 at 01:49
Why not call `getObjectBFromSomewhere()` once and pass the returned reference as a parameter to both your other functions that use it? — Galik, Jun 20 '18 at 01:51
@Galik FunctionB calls FunctionA at the beginning so a third function calling the object will still get called twice — solarflare, Jun 20 '18 at 01:52
@LorenceHernandez any chance you could add it here as a reply? I cant access that website — solarflare, Jun 20 '18 at 02:12
`const ObcjectB& FunctionC() { static const ObcjectB& b = getObjectBFromSomewhere(...); return b; } const ObcjectB& b = FunctionC(); // FunctionA implementation const ObcjectB& b = FunctionC(); // FunctionB implementation ` — Lorence Hernandez, Jun 20 '18 at 02:16
@LorenceHernandez, you mistakenly posted your answer in the comment box. — Joseph D., Jun 20 '18 at 03:51
@codekaizer mybad. i thought i should just put it here. thanks. — Lorence Hernandez, Jun 21 '18 at 01:18

solarflare · Answer 1 · 2018-06-20T06:02:38.987

0

Thanks for the ideas, this is how I solved my problem:

bool FunctionA (const ObjectA& a, bool& bSomeLittleBit = false)
{
    // ... some code ...
    const ObcjectB& b = getObjectBFromSomewhere(...);
    bSomeLittleBit = b.getSomeLittleBit();
    // ... code heavily reliant on b ...
    return boolean_val;
}

bool FunctionB (const ObjectA& a)
{
    bool bSomeLittleBit = false;
    bool boolean_val = FunctionA(a, bSomeLittleBit);

    // ... rest of the code as normal ...

    return boolean_val;
}

edited Jun 20 '18 at 06:02

answered Jun 20 '18 at 04:29

solarflare

423
3
14

1

you may want to make `bSomeLittleBit` parameter a reference – Lorence Hernandez Jun 20 '18 at 05:50
@LorenceHernandez it is. I edited. Making it a reference actually also caused other problems - you cant have a default value parameter for a reference. So I introduced a dummy static bool and assigned it as the default value. Works well now. – solarflare Jun 20 '18 at 06:03

score 0 · Answer 2 · answered Jun 20 '18 at 04:37

your question seems to imply that there is one canonical objectB which doesn't move in memory however for whatever reason getObjectBFromSomewhere() is hard on memory but will always return a reference to this same object?

perhaps you're looking something like this:

//static means only available in this compilation unit
static const ObcjectB *obj = nullptr;

bool FunctionA (const ObjectA& a)
{
    // ... some code ...
    if(!obj)
       obj = &getObjectBFromSomewhere(...);
    const ObcjectB& b = *obj;
    // ... code heavily reliant on b ...
    return boolean_val;
}

bool FunctionB (const ObjectA& a)
{
    bool boolean_val = FunctionA(a);

    // ... some code ...
    if(!obj)
       obj = &getObjectBFromSomewhere(...);
    const ObcjectB& b = *obj;
    // ... code that only needs one tiny bit of b ...
    return boolean_val;
}

if you're referring to the fact that functionA is called by functionB and therefore performs redundant work by calling getObjectBFromSomewhere() you could change the signature of functionA to accept a pointer to the object which it will use instead of calling getObjectFromSomewhere by itself i.e.

FunctionA(const ObjectA& a, ObcjectB *obj = nullptr)
{
   if(!obj)
      obj = &getObjectBFromSomewhere(...);
   const ObcjectB& b = *obj;
}

and then change functionB to pass this param:

FunctionB (const ObjectA& a)
{
    //move the expensive call up to the start of the method
    const ObcjectB& b = getObjectBFromSomewhere(...);
    bool boolean_val = FunctionA(a, &b);

    // ... some code ...

    // ... code that only needs one tiny bit of b ...
    return boolean_val;
}

This looks like an odd implementation of [the singleton pattern](https://stackoverflow.com/questions/43292897/is-implementation-of-double-checked-singleton-thread-safe), including all its race conditions for threaded code. — Bo Persson, Jun 20 '18 at 09:20
The first sample is the singleton pattern straight up. The second isn't really, I don't think an optional variable really counts as a design pattern at all. Either way, OP didn't ask for threadsafe, but you could just bang a mutex on it, no? — 5Volt, Jun 21 '18 at 23:38

Refactoring this code to optimize

2 Answers2