C++, static vs. namespace vs. singleton

by

As noted, using global variables is generally bad engineering practice, unless absolutely needed of course (mapping hardware for example, but that doesn’t happen THAT often).

Stashing everything in a class is something you would do in a Java-like language, but in C++ you don’t have to, and in fact using namespaces here is a superior alternative, if only:

  • because people won’t suddenly build instances of your objects: to what end ?
  • because no introspection information (RTTI) is generated for namespaces

Here is a typical implementation:

// foo.h
#ifndef MYPROJECT_FOO_H_INCLUDED
#define MYPROJECT_FOO_H_INCLUDED

namespace myproject {
  void foo();
  void foomore();
}

#endif // MYPROJECT_FOO_H_INCLUDED

// foo.cpp
#include "myproject/foo.h"

namespace myproject {

namespace {
  typedef XXXX MyHelperType;

  void bar(MyHelperType& helper);
} // anonymous

void foo() {
  MyHelperType helper = /**/;
  bar(helper);
}

void foomore() {
  MyHelperType helper = /**/;
  bar(helper);
  bar(helper);
}
} // myproject

The anonymous namespace neatly tucked in a source file is an enhanced private section: not only the client cannot use what’s inside, but he does not even see it at all (since it’s in the source file) and thus do not depend on it (which has definite ABI and compile-time advantages!)

More Related Contents:

  1. Superiority of unnamed namespace over static?
  2. C++ singleton vs. global static object
  3. static vs non-static variables in namespace
  4. C++ cannot initialize static data member [duplicate]
  5. Accessing members in same namespace in C++ [closed]
  6. Unnamed/anonymous namespaces vs. static functions
  7. Static constant string (class member)
  8. Why are global and static variables initialized to their default values?
  9. How do you properly use namespaces in C++?
  10. Static variables in member functions
  11. Static variables in C++
  12. What are the pitfalls of ADL?
  13. Global scope vs global namespace
  14. Template static variable
  15. Variable declarations in header files – static or not?
  16. What makes a static variable initialize only once?
  17. scope of using declaration within a namespace
  18. Thread safe lazy construction of a singleton in C++
  19. Uses for anonymous namespaces in header files
  20. Why can’t I forward-declare a class in a namespace using double colons?
  21. error C2065: ‘cout’ : undeclared identifier
  22. How do static variables in lambda function objects work?
  23. Singleton pattern in C++
  24. Advantages of classes with only static methods in C++
  25. Is C++ static member variable initialization thread-safe?
  26. Why does C++ parameter scope affect function lookup within a namespace?
  27. How to execute a piece of code only once?
  28. Why is a C++ bool var true by default?
  29. Scope resolution operator being used twice
  30. Multiple instances of singleton across shared libraries on Linux

Leave a Comment