Por que os namespaces não nomeados são usados ​​e quais são seus benefícios?

Acabei de ingressar em um novo projeto de software C ++ e estou tentando entender o design. O projeto faz uso frequente de namespaces não nomeados. Por exemplo, algo como isto pode ocorrer em um arquivo de definição de classe:

// newusertype.cc
namespace {
  const int SIZE_OF_ARRAY_X;
  const int SIZE_OF_ARRAY_Y;
  bool getState(userType*,otherUserType*);
}

newusertype::newusertype(...) {...

Quais são as considerações de design que podem levar alguém a usar um espaço para nome sem nome? Quais são as vantagens e desvantagens?

Os espaços para nome sem nome são um utilitário para tornar local uma unidade de conversão de identificador. Eles se comportam como se você escolhesse um nome exclusivo por unidade de tradução para um espaço para nome:

namespace unique { /* empty */ }
using namespace unique;
namespace unique { /* namespace body. stuff in here */ }

A etapa extra usando o corpo vazio é importante, portanto, você já pode consultar no corpo do espaço para nome identificadores como ::nameos definidos nesse espaço para nome, pois a diretiva using já ocorreu.

Isso significa que você pode ter funções gratuitas chamadas (por exemplo) helpque podem existir em várias unidades de tradução e elas não entrarão em conflito no momento do link. O efeito é quase idêntico ao uso da staticpalavra - chave usada em C, que você pode inserir na declaração de identificadores. Os namespaces sem nome são uma alternativa superior, podendo até tornar uma unidade de tradução de tipo local.

namespace { int a1; }
static int a2;

Ambos asão unidades de tradução locais e não entrarão em conflito no momento do link. Mas a diferença é que o a1espaço para nome anônimo recebe um nome exclusivo.

Leia o excelente artigo em comeau-computing Por que um espaço para nome sem nome é usado em vez de estático? ( Espelho do Archive.org ).

Ter algo em um espaço de nome anônimo significa que é local para esta unidade de tradução (arquivo .cpp e todas as suas inclusões) significa que se outro símbolo com o mesmo nome for definido em outro lugar, não haverá violação da regra de definição única (ODR).

É o mesmo que o modo C de ter uma variável global estática ou função estática, mas também pode ser usado para definições de classe (e deve ser usado em vez de staticem C ++).

Todos os espaços para nome anônimos no mesmo arquivo são tratados como o mesmo espaço para nome e todos os espaços para nome anônimos em arquivos diferentes são distintos. Um espaço para nome anônimo é equivalente a:

namespace __unique_compiler_generated_identifer0x42 {
    ...
}
using namespace __unique_compiler_generated_identifer0x42;

O espaço para nome sem nome limita o acesso de classe, variável, função e objetos ao arquivo no qual está definido. A funcionalidade de namespace sem nome é semelhante à staticpalavra - chave em C / C ++.
staticA palavra-chave limita o acesso da variável global e da função ao arquivo no qual elas estão definidas.
Há diferença entre o espaço para nome e a staticpalavra - chave sem nome, pois o espaço para nome sem nome tem vantagem sobre a estática. staticA palavra-chave pode ser usada com variáveis, funções e objetos, mas não com a classe definida pelo usuário.
Por exemplo:

static int x;  // Correct 

Mas,

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

Mas o mesmo pode ser possível com espaço para nome sem nome. Por exemplo,

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

Além das outras respostas a esta pergunta, o uso de um espaço para nome anônimo também pode melhorar o desempenho. Como os símbolos no espaço para nome não precisam de nenhuma ligação externa, o compilador é mais livre para executar a otimização agressiva do código dentro do espaço para nome. Por exemplo, uma função chamada várias vezes uma vez em um loop pode ser incorporada sem qualquer impacto no tamanho do código.

Por exemplo, no meu sistema, o código a seguir ocupa cerca de 70% do tempo de execução se o espaço para nome anônimo for usado (x86-64 gcc-4.6.3 e -O2; observe que o código extra em add_val faz com que o compilador não queira incluir duas vezes).

#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;
}

O exemplo mostra que as pessoas no projeto que você ingressou não entendem os namespaces anônimos :)

namespace {
    const int SIZE_OF_ARRAY_X;
    const int SIZE_OF_ARRAY_Y;

Eles não precisam estar em um espaço para nome anônimo, pois o constobjeto já possui ligação estática e, portanto, não pode entrar em conflito com identificadores com o mesmo nome em outra unidade de tradução.

    bool getState(userType*,otherUserType*);
}

E isso é realmente uma pessimização: getState()tem ligação externa. Geralmente é melhor preferir ligação estática, pois isso não polui a tabela de símbolos. É melhor escrever

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

aqui. Eu caí na mesma armadilha (há palavras no padrão que sugerem que a estática dos arquivos é de alguma forma preterida em favor de namespaces anônimos), mas trabalhando em um grande projeto C ++ como o KDE, você recebe muitas pessoas que viram sua cabeça do jeito certo por aí novamente :)

Um espaço de nome anônimo torna as variáveis, funções, classes etc. disponíveis apenas dentro desse arquivo. No seu exemplo, é uma maneira de evitar variáveis ​​globais. Não há diferença de desempenho em tempo de execução ou tempo de compilação.

Não há tanta vantagem ou desvantagem além de "quero que essa variável, função, classe etc. seja pública ou privada?"