Dlaczego używane są nienazwane przestrzenie nazw i jakie są ich zalety?

Posiadanie czegoś w anonimowej przestrzeni nazw oznacza, że jest ono lokalne dla tejjednostki tłumaczeniowej (.oznacza to, że jeśli inny symbol o tej samej nazwie zostanie zdefiniowany gdzie indziej, nie będzie naruszenia jednej reguły definicji (ODR).

Jest to ten sam sposób, w jaki C ma statyczną zmienną globalną lub statyczną funkcję, ale może być również używany do definicji klas (I powinien być używany zamiast static W C++).

Wszystkie anonimowe przestrzenie nazw w tym samym pliku są traktowane jako ta sama przestrzeń nazw, a wszystkie anonimowe przestrzenie nazw w różnych plikach są różne. Anonimowa przestrzeń nazw jest odpowiednikiem:

namespace __unique_compiler_generated_identifer0x42 {
    ...
}
using namespace __unique_compiler_generated_identifer0x42;

Przykład pokazuje, że ludzie w projekcie, do którego dołączyłeś, nie rozumieją anonimowych przestrzeni nazw:)

namespace {
    const int SIZE_OF_ARRAY_X;
    const int SIZE_OF_ARRAY_Y;

Nie muszą one znajdować się w anonimowej przestrzeni nazw, ponieważ const obiekt ma już statyczne powiązanie i dlatego nie może być w konflikcie z identyfikatorami o tej samej nazwie w innej jednostce tłumaczeniowej.

    bool getState(userType*,otherUserType*);
}

I to jest właściwie pesymizacja: getState() mA zewnętrzne powiązania. Zwykle lepiej jest preferować statyczne połączenie, ponieważ nie zanieczyszcza to tabeli symboli. Lepiej napisać

static bool getState(/*...*/);

Oprócz innych odpowiedzi na to pytanie, korzystanie z anonimowej przestrzeni nazw może również poprawić wydajność. Ponieważ symbole w przestrzeni nazw nie wymagają żadnego zewnętrznego powiązania, kompilator ma większą swobodę w przeprowadzaniu agresywnej optymalizacji kodu w przestrzeni nazw. Na przykład funkcja, która jest wywoływana wielokrotnie raz w pętli, może być inlinowana bez żadnego wpływu na rozmiar kodu.

Na przykład w moim systemie poniższy kod zajmuje około 70% czasu uruchamiania, jeśli używana jest anonimowa przestrzeń nazw (x86-64 gcc-4.6.3 i-O2; zauważ, że dodatkowy kod w add_val sprawia, że kompilator nie chce dołączać go dwa razy).

#include <iostream>

namespace {
  double a;
  void b(double x)
  {
    a -= x;
  }
  void add_val(double x)
  {
    a += x;
    if(x==0.01) b(0);
    if(x==0.02) b(0.6);
    if(x==0.03) b(-0.1);
    if(x==0.04) b(0.4);
  }
}

int main()
{
  a = 0;
  for(int i=0; i<1000000000; ++i)
    {
      add_val(i*1e-10);
    }
  std::cout << a << '\n';
  return 0;
}

Anonimowa przestrzeń nazw tworzy zamknięte zmienne, funkcje, klasy itp. dostępne tylko w tym pliku. W twoim przykładzie jest to sposób na uniknięcie zmiennych globalnych. Nie ma różnicy w wydajności w czasie wykonywania ani kompilacji.

Nie ma tak wiele zalet lub wad poza "czy chcę tę zmienną, funkcję, klasę, itp. być publicznym czy prywatnym?"

Nienazwana przestrzeń nazw ogranicza dostęp klasy, zmiennej, funkcji i obiektów do pliku, w którym jest zdefiniowana. Funkcjonalność nienazwanej przestrzeni nazw jest podobna do słowa kluczowego static w C / C++.
static słowo kluczowe ogranicza dostęp zmiennej globalnej i funkcji do pliku, w którym są zdefiniowane.
Istnieje różnica między nienazwaną przestrzenią nazw a słowem kluczowym static, dzięki czemu nienazwana przestrzeń nazw ma przewagę nad statyczną. static słowo kluczowe może być używane ze zmienną, funkcją i obiektami, ale nie z użytkownikiem zdefiniowana Klasa.
Na przykład:

static int x;  // Correct 

Ale,

static class xyz {/*Body of class*/} //Wrong
static structure {/*Body of structure*/} //Wrong

Ale to samo może być możliwe z nienazwaną przestrzenią nazw. Na przykład,

 namespace {
           class xyz {/*Body of class*/}
           static structure {/*Body of structure*/}
  } //Correct