should C++ class "helper functions" be members, free, or anon-namespace free?

Question

So, I have a class. It's a useful class. I like a lot. Let's call it MyUsefulClass. MyUsefulClass has a public method. Let's call it processUsefulData(std::vector<int>&).

Now suppose processUsefulData really does two things and I want to refactor it from this:

std::vector<int> MyUsefulClass::processUsefulData(std::vector<int>& data)
{
    for (/*...*/)
    {
        for (/*...*/)
        {
            // a bunch of statements...
        }
    }

    for (/*...*/)
    {
        for (/*...*/)
        {
            // a bunch of other statements...
        }
    }
    return data;
}

Now, I want to split these responsibilities and rewrite the code as

std::vector<int> MyUsefulClass::processUsefulData(std::vector<int>& data)
{
    doProcessA(data, dataMember_);
    doProcessB(data, otherDataMember_);
    return data;
}

So, I don't know if I should make the two helper functions free functions or member functions, and when each would be appropriate. I also don't know if it's better to make them in an anonymous namespace or not. Does anyone know good times to do this?

Generalizing like this will not get you a good answer. Each situation is dependant on what you are doing. — Martin York, Jul 17 '09 at 20:53

score 15 · Answer 1 · answered Jul 17 '09 at 20:46

I generally make helper routines "free" routines in an anonomous namespace if possible. That way I don't complicate the interface (off in the *.h file) with stuff clients don't need to worry about.

However, you have to be careful that you don't introduce non-reentrancy by doing that. For instance, by modifying global data objects or static locals rather than class members. If you need to do that, you are better off making it a proper class member.

score 12 · Accepted Answer · answered Jul 17 '09 at 20:47

Free function / member function

I would make them free functions is possible (they do not need access to the internals of the class). If they work on a set of attributes or need access to other members then make it a member function.

Access

If the code only has sense in this scope, and will not be used from other code then make them private: private if it is a member, or implemented in an unnamed namespace if it is a free function.

If other code will benefit from using the code then publish it in the interface. That means making it protected if it is a member or having the free function accessible through a header in a named namespace (or global namespace).

Chap · Answer 3 · 2009-07-17T20:43:44.100

3

I usually make them protected or private member functions. It would depend on whether you plan on deriving the class and overriding the functions.

If they are common enough functions that they are used in other classes, move them to static functions contained in a common class or a separate object that your class uses.

edited Jul 17 '09 at 20:43

answered Jul 17 '09 at 20:24

Chap

2,776
24
31

score 2 · Answer 4 · edited May 23 '17 at 12:32

2

Always prefer free functions over member ones. See my answer here to know why.

edited May 23 '17 at 12:32

Community

1
1

answered Jul 17 '09 at 20:28

Piotr Dobrogost

41,292
40
236
366

Actually your other answer does not contain an explanation directly ;-) – Simson May 13 '14 at 06:57
2

@Simson - Amusingly, it refers the reader to [this blog post](http://www.gotw.ca/publications/mill08.htm), which then refers the reader back to [this previous post](http://www.gotw.ca/publications/mill02.htm). Fortunately for our sanity, that post does not refer us back to this SO post (although it does refer forward to the first blog post). – T.E.D. Dec 09 '14 at 12:47

score 2 · Answer 5 · answered Jul 17 '09 at 20:43

The fact that you mention free functions leads me to believe that the 'bunch of other statements' do not require access to class data. If so, make them free. This reduces complexity of your class header, plus free functions are easier to use in the standard algorithms (maybe std::for_each since you're working with vectors anyway?).

score 0 · Answer 6 · answered Jul 17 '09 at 20:25

0

Think about the scope. Are those functions going to be used in another class, or elsewhere? Should they be publically call-able?

It seems like they should be private member functions to me, but it all depends on your overall scoping structure.

answered Jul 17 '09 at 20:25

Sev

15,401
9
56
75

score 0 · Answer 7 · answered Jul 17 '09 at 20:29

Member functions certainly if the original function made sense as a member function.

Private/protected IMHO depends on how their functionality is used: if the original function's operation is still required and the refactor is solely to make the code cleaner then make them protected or private and call them from the regular function. You get the refactor but keep the class's public interface intact that way.

should C++ class "helper functions" be members, free, or anon-namespace free?

7 Answers7