实现或定义在未命名/匿名命名空间内声明的 class 或 function

Question

Is it legal to define the implementation of a function or class members outside the unnamed (anonymous) namespace they've been defined inside. My compiler accepts it but I want to be sure it's legal eg

////////////////
// foo.cpp 

namespace {
 struct X
 {
 void foo(int x);
 };
}

// Is this legal?
void X::foo(int x)
{
}

The reason is I would like to avoid the unnecessary indentation imposed by our uncrustify formatting

Answer 1

It is really no different than the following, which is totally legit:

namespace ns {
    struct s {
        void f();
    };
}

using namespace ns;

void s::f() { }

The names from the named namespace are brought into the global namespace and thus definitions can be provided for them there. The only difference with the unnamed namespace is that it has no name (really, it has some unique, unutterable name) and the using namespace is implicit.

Answer 2

It's legal in your scenario, but in one scenario, it will cause compiler ambiguous error.

In case have another class in Xh:

// X.h
struct X
{
    void foo(int x) { }
};

And in foo.cpp, need to use the X defined in Xh

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

namespace {
    struct X
    {
        void foo(int x);
    };

    // use the X declared in anonymous namespace
    void test()
    {
        X x;
        x.foo(3);
    }
}

// reference to 'X' is ambiguous
void X::foo(int x)
{
}

void otherFunction()
{
    // Use struct X in X.h
    ::X x;
    x.foo(3);
}

if leave the implementation code out of the anonymous namespace, compiler complains ambiguous. If move the implementation code inside anonymous namespace, it works fine.

Answer 3

#include <iostream>
using namespace std;

namespace
{
  struct X
  {
     X(int);
     int x_;
  };
}

X::X(int x) : x_(x) {}

int main()
{
   X x(5);

   cout << x.x_ << "\n";
   return 0;
}

Compiles (and runs) under gcc 4.6.0

Answer 4

Yes. It's perfectly legal. The difference an unnamed namespace makes is that, the content of the namespace is available only within the file it's declared. If it's in .h file then, it will be added to all the subsequent .cpp file and every .cpp file will have a unique copy of the contents of the namespace .

In fact it's a better way to declare a global static variable. Now see, what kind of difference it will make:

namespace {
 struct X
 {
   void foo(int x);
 };
 int i;  // declare this global variable
}

If you put this code inside a header file then, wherever that header file is #include ed, all those .cpp file will have a different copy of int i; inside them. Changing the value of i in one .cpp file doesn't affect the other .cpp file.

Moreover, it will not give linker error for multiple definitions, since it's in unnamed namespace .

Edit : To evaluate it more, define the namespace as following:

// x.h
namespace
{
  struct X
  {
    void foo(int x)
    {
      static int c;  // static inside the function
      cout<<"a = "<<(c++)<<endl;
    }
  };
}

Now #include this header file in 2 different .cpp files. In both of them try to call foo() with object of X . It will print:

a = 0
a = 0

Which means that X::foo() in both the .cpp files are different . If you give the namespace a name and repeat the same thing, it will output

a = 0
a = 1

Thus unnamed namespace creates a different copy for each translation unit.