Question

I have a class that contains a private typedef and several member
functions:

class Foo
{
private:
  typedef std::blahblah FooPart;
  FooPart m_fooPart;
  ...
public:
  int someFn1();
  int someFn2();
};

Several member functions need to use m_fooPart in a similar way, so I
want to put that in a function. I put helper functions in the anonymous
namespace whenever I can, but in this case, they need to know what
FooPart is. So, I’ve done this:

namespace
{
  template <typename T>
  int helperFn(const T& foopart, int index)
  {
    ...
    return foopart.fn(index);
  }
}

int Foo::someFn1()
{
  ...
  return helperFn(m_fooPart, ix);       
}

By forcing the compiler to produce the FooPart type, am I still in the
land of well-defined behavior? Is there a more elegant way of
accomplishing this that doesn’t increase the size of Foo or make public
what is now private?

Answer 1

Yes, that approach produces well-defined, standards-compliant behavior.

That said, adding member functions to a class does not increase the size of a class (assuming you mean the result of the sizeof operator), so I’m not sure what drawback you perceive in just making the helper function a private member of Foo.