Question

Although I wrote this example in C++, this code refactoring question also applies to any language that endorses OO, such as Java.

Basically I have a class A

class A
{
public:
  void f1();
  void f2();
  //..
private:
  m_a;
};

void A::f1()
{
  assert(m_a);
  m_a->h1()->h2()->GetData();
  //..
}

void A::f2()
{
  assert(m_a);
  m_a->h1()->h2()->GetData();
  //..
}

Will you guys create a new private data member m_f holding the pointer m_a->h1()->h2()? The benenif I can see is that it effectively eliminates the multi-level function calls which does simplify the code a lot.

But from another point of view, it creates an “unnecessary” data member which can be deduced from another existing data member m_a, which is kinda redundant?

I just come to a dilemma here. By far, I cannot convince myself to use one over the other.

Which do you guys prefer, any reason?

Answer 1

The fancy word for this technique is caching: you calculate a two-away reference once, and cache it in the object. In general, caching lets you “pay” with computer memory for speed-up of your computations.

If a profiler tells you that your code is spending a significant amount of time in the repeated call of m_a->h1()->h2(), this may be a legitimate optimization, provided that the return values of h1 and h2 never change. However, doing an optimization like that without profiling first is nearly always a bad sign of a premature optimization.

If performance is not the issue, a good rule is to stay away from storing members that can be calculated from other members stored in your object. If you would like to improve clarity, you can introduce a nicely named method (a member function) to calculate the two-away reference without storing it. Storing makes sense only in the rare cases when it is critical for the performance.