Почему используются безымянные пространства имен и каковы их преимущества?

Наличие чего-либо в анонимном пространстве имен означает, что оно является локальным для этого единица перевода (файла .cpp и всех его включений), это означает, что если другой символ с тем же именем определен в другом месте, не будет нарушения Одно правило определения (ODR).

Это то же самое, что и способ C иметь статическую глобальную переменную или статическую функцию, но он также может использоваться для определений классов (и должен использоваться, а не static в C++).

Все анонимные пространства имен в одном файле рассматриваются как одно и то же пространство имен, и все анонимные пространства имен в разных файлах различны. Анонимное пространство имен эквивалентно:

namespace __unique_compiler_generated_identifer0x42 {
    ...
}
using namespace __unique_compiler_generated_identifer0x42;

Анонимное пространство имен делает вложенные переменные, функции, классы и т. д. Доступными только внутри этого файла. В вашем примере это способ избежать глобальных переменных. Нет разницы в производительности во время выполнения или времени компиляции.

Нет особых преимуществ или недостатков, кроме «хочу ли я, чтобы эта переменная, функция, класс и т. д. Были общедоступными или частными?»

Неназванные пространства имен - это утилита, позволяющая сделать локальную единицу преобразования идентификатора. Они ведут себя так, как если бы вы выбрали уникальное имя для каждой единицы перевода для пространства имен:

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

Дополнительный шаг с использованием пустого тела важен, поэтому вы уже можете ссылаться в теле пространства имен на идентификаторы, такие как ::name, которые определены в этом пространстве имен, поскольку директива using уже имела место.

Это означает, что у вас могут быть бесплатные функции, называемые (например) help, которые могут существовать в нескольких единицах перевода, и они не будут конфликтовать во время связывания. Эффект почти идентичен использованию ключевого слова static, используемого в C, которое вы можете вставить в объявление идентификаторов. Неназванные пространства имен являются превосходной альтернативой, поскольку они могут даже сделать локальную единицу преобразования типов.

namespace { int a1; }
static int a2;

Оба a являются локальными единицами перевода и не будут конфликтовать во время компоновки. Но разница в том, что a1 в анонимном пространстве имен получает уникальное имя.

Прочтите отличную статью на сайте comeau-computing Почему вместо статического используется безымянное пространство имен? (Зеркало Archive.org).

Пример показывает, что люди в проекте, к которому вы присоединились, не понимают анонимных пространств имен :)

namespace {
    const int SIZE_OF_ARRAY_X;
    const int SIZE_OF_ARRAY_Y;

Они не обязательно должны находиться в анонимном пространстве имен, поскольку объект const уже имеет статическую связь и, следовательно, не может конфликтовать с идентификаторами того же имени в другой единице перевода.

    bool getState(userType*,otherUserType*);
}

И это на самом деле пессимизация: getState() имеет внешнюю связь. Обычно лучше предпочесть статическую привязку, так как это не загрязняет таблицу символов. Лучше написать

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

здесь. Я попал в ту же ловушку (в стандарте есть формулировка, предполагающая, что статика файлов почему-то устарела в пользу анонимных пространств имен), но работая в большом проекте C++, таком как KDE, вы получаете множество людей, которые повернут вашу голову в правильном направлении. снова вокруг :)

Помимо других ответов на этот вопрос, использование анонимного пространства имен также может повысить производительность. Поскольку символы в пространстве имен не нуждаются в какой-либо внешней связи, компилятор свободнее выполнять агрессивную оптимизацию кода в пространстве имен. Например, функция, которая вызывается несколько раз в цикле, может быть встроена без какого-либо влияния на размер кода.

Например, в моей системе следующий код занимает около 70% времени выполнения, если используется анонимное пространство имен (x86-64 gcc-4.6.3 и -O2; обратите внимание, что дополнительный код в add_val заставляет компилятор не включать это дважды).

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

Безымянное пространство имен ограничивает доступ класса, переменной, функции и объектов к файлу, в котором оно определено. Функциональность безымянного пространства имен аналогична ключевому слову static в C / C++.
Ключевое слово static ограничивает доступ к глобальной переменной и функции к файлу, в котором они определены. Существует разница между безымянным пространством имен и ключевым словом static, из-за которой безымянное пространство имен имеет преимущество перед статическим. Ключевое слово static может использоваться с переменной, функцией и объектами, но не с пользовательским классом. Например:

static int x;  // Correct 

Но,

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

Но то же самое может быть возможно и с безымянным пространством имен. Например,

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