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?

Answer 1

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).