Uses for anonymous namespaces in header files

Question

Someone asserted on SO today that you should never use anonymous namespaces in header files. Normally this is correct, but I seem to remember once someone told me that one of the standard libraries uses anonymous namespaces in header files to perform some sort of initialization.

Am I remembering correctly? Can someone fill in the details?

Answer 1

The only situation in which a nameless namespace in header can be useful is when you want to distribute code as header files only. For example, a large standalone subset of Boost is purely headers.

The token ignore for tuples, mentioned in another answer is one example, the _1, _2 etc. bind placeholders are others.

Answer 2

I don't see any point in putting an anonymous namespace into a header file. I've grepped the standard and the libstdc++ headers, found no anonymous namespaces apart of one in the tuple header (C++1x stuff):

  // A class (and instance) which can be used in 'tie' when an element   // of a tuple is not required   struct _Swallow_assign   {     template<class _Tp>       _Swallow_assign&       operator=(const _Tp&)       { return *this; }   };    // TODO: Put this in some kind of shared file.   namespace   {     _Swallow_assign ignore;   }; // anonymous namespace 

This is so you can do

std::tie(a, std::ignore, b) = some_tuple; 

elements of the some_tuple are assigned the variables at the left side (see here), a similar technique is used for this iterator. The second element is ignored.

But as they say, it should be put into a .cpp file and the one instance should be shared by all users. They would put a declaration of it into the header like this then:

extern _Swallow_assign ignore;