Рекомендации: использование пространства имен или повторное открытие пространства имен?

Предположим, что я объявил функцию (или класс, не имеет значения) в заголовочном файле, который является частью пространства имен foo:

namespace foo
{
    void bar();
    …
}

Я долгое время открывал пространство имен, когда определял функцию в файле cpp:

namespace foo
{
void bar()
{
    doSomething();
    …
}
}

Это потому, что я узнал его таким образом, и он использовался в проекте, над которым я работал. Я никогда не думал об этом до недавнего времени, когда я наткнулся на проект, в котором вместо этого использовалась директива using:

using namespace foo;

void bar()
{
    doSomething();
    …
}

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

void foo::bar()
{
    doSomething();
    …
}

Итак, мой вопрос в том, какой из них должен быть предпочтительным и почему? Особенно в отношении первых двух опций (с использованием директивы против повторного открытия пространства имен).

Ответ 1

Я думаю, что самый чистый способ - повторное открытие пространства имен, и у меня есть аргументы для его поддержки:

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

Ответ 2

Даже если using namespace является самым ленивым (и, следовательно, самым заманчивым) решением, часто это не очень хорошая идея. Кроме того, что Лучиан говорит о неоднозначности объявлений функций (кто-то новый для проекта не знал бы, является ли это автономной функцией или одной в пространстве имен), и тот факт, что позже вы можете ввести имя в пространство имен, столкнувшись с одним из вас используя теперь, у меня есть еще одна причина, почему я предлагаю использовать третий метод.

Используя третий метод, вы даете вашему коду более последовательность. Если A находится внутри B, вы всегда определяете его с помощью A::B. Если A - класс и B - функция в классе, вы должны написать type A::B(args). Если A - это класс и B статический член, вы снова напишете type A::B = value. Теперь A - пространство имен, но оно по-прежнему остается тем же самым понятием: B определяется внутри A, поэтому более последовательно использовать A::B.

(Существует дополнительный бонус поиска, если ваш редактор, например, ViM)