在 C++ 中放置与类方法有关的辅助函数的位置

Question

Suppose I have a class Foo like this:

foo.h :

namespace mine {

class Foo {
  Widget widget_;
public:
  void bar();
  // some other members...
};

} // namespace mine

foo.cpp :

#include "foo.h"
namespace mine {

void Foo::bar() {
  // Some very long code
}

} // namespace mine

where I want to split bar() into multiple functions for readability reasons. The functions themselves don't have any particular meaning to Foo (or any other entity than Foo::bar() ) and are only used to split up bar() , so according to this discussion I would do the following in the source file:

foo.cpp (refactored):

#include "foo.h"

// anonymous namespace to put all helper functions
namespace {

void computeResult() { ... }
void modifyWidget(Widget& w) { ... }
void doThis() { ... }
void doThat(Widget& w) { 
  // ... 
  modifyWidget(w);
}

} // <anonymous> namespace

// actual methods are defined here    
namespace mine {

void Foo::bar() {
  ::doThis();
  ::doThat(widget_);
  ::computeResult();
}

} // namespace mine

So I am defining an anonymous namespace in the source file in order to define the helper functions, such that I have static linkage and the helper functions are not visible from outside the source file. One thing that looks odd to me is that class methods depend on functions that are not part of the class, but then we would not be able to use even the standard library if this was an issue.

• Is this approach sensible? Do you have better suggestions?
• Is there a problem with passing the private member Foo::widget_ to some freestanding function that modifies it ( doThat() )? I'm assuming here that in the narrow context of a static linkage helper function, the callers/callees know what they are doing.

Answer 1

1. Yes, it's sensible. It's also not uncommon, and it's my impression that it's gaining popularity.
2. Linkage has no effect whatsoever on how functions work, and a private member variable works exactly like all other variables (except you can't access its name from the outside).
   That is, it's exactly like passing any variable to any function.