When is an empty namespace definition needed?

Question

Namespaces aren't declared and defined like most other things, but the namespace equivalent of a forward declaration would be:

namespace X {}  // empty body

Normally, you define a namespace by placing other declarations inside it. But is there a problem for which this "namespace forward declaration" is the easiest solution? Of what use is an empty namespace?

Answer 1

Here is one which even appears in the Standard: Declaring a using directive to denote a namespace

namespace unique { }
using namespace unique;

Afterwards you can open the namespace other times and add to it, and the using directive makes the stuff visible to the outer namespace.

Answer 2

I use an empty namespace definition to simplify declarations for recursive functions, where one "side" is operator overloads. The operators are placed in their own namespace to allow selective use in scopes as desired, rather than forcing use if the header is included anywhere (and thus forcing errors if resolutions become ambiguous).

Example:

namespace container_inserters {}

template<class Stream, class Iter, class Ch>
void write_sequence(Stream& s, Iter begin, Iter end,
                    Ch const *initial, Ch const *sep, Ch const *final)
{
  using namespace container_inserters;
  if (initial) s << initial;
  if (begin != end) {
    s << *begin;
    ++begin;
    for (; begin != end; ++begin) {
      if (sep) s << sep;
      s << *begin;
    }
  }
  if (final) s << final;
}

namespace container_inserters {
#define G(N) \
template<class Ch, class Tr, class T, class A> \
std::basic_ostream<Ch,Tr>& operator<<(std::basic_ostream<Ch,Tr> &s, \
                                      N<T,A> const &value) \
{ \
  write_sequence(s, value.begin(), value.end(), "[", ", ", "]"); \
  return s; \
}
G(std::deque)
G(std::list)
G(std::vector)
#undef G
}  // container_inserters::

The resolution of s << *begin is delayed until write_sequence is instantiated (because it involves template parameters), by which time the operator has been declared and can be found through the using directive. The call becomes recursive for nested containers:

int main() {
  using namespace std;
  vector<deque<list<int> > > v (3, deque<list<int> >(2, list<int>(1, 42)));

  using namespace container_inserters;
  cout << v << '\n';

  return 0;
}
// output:
//  [[[42], [42]], [[42], [42]], [[42], [42]]]

Boost has a similar output formatting library, but I don't know if they use the same implementation technique.