'Helper' functions in C++

Question

While refactoring some old code I have stripped out a number of public methods that should actually of been statics as they a) don't operate on any member data or call any other member functions and b) because they might prove useful elsewhere.

This led me to think about the best way to group 'helper' functions together. The Java/C# way would be to use a class of static functions with a private constructor, e.g.:

class Helper   {   private:     Helper() { } public:     static int HelperFunc1();     static int HelperFunc2();   }; 

However, being C++ you could also use a namespace:

namespace Helper   {     int HelperFunc1();     int HelperFunc2();   } 

In most cases I think I would prefer the namespace approach but I wanted to know what the pros and cons of each approach are. If used the class approach for example, would there be any overheads?

Answer 1

Overhead is not an issue, namespaces have some advantages though

• You can reopen a namespace in another header, grouping things more logically while keeping compile dependencies low

• You can use namespace aliasing to your advantage (debug/release, platform specific helpers, ....)

  e.g. I've done stuff like

  namespace LittleEndianHelper {    void Function(); } namespace BigEndianHelper {    void Function(); }  #if powerpc    namespace Helper = BigEndianHelper; #elif intel    namespace Helper = LittleEndianHelper; #endif 

Answer 2

A case where one might use class (or struct) over namespace is when one needs a type, for example:

struct C {   static int f() { return 33; } };  namespace N {   int f() { return 9; } }  template<typename T> int foo() {   return T::f(); }  int main() {   int ret = foo<C>(); //ret += foo<N>(); // compile error: N is a namespace   return ret; }