18.2.3. Классы, пространства имен и области видимости

Поиск имен, используемых в пространстве имен, происходит согласно обычным правилам поиска в языке С++: сначала во внутренней, а затем во внешней области видимости. Имя, используемое в пространстве имен, может быть определено в одном из окружающих пространств имен, включая глобальное пространство имен. Однако учитываются только те имена, которые были объявлены перед точкой использования в блоках, которые все еще открыты.

namespace A {

 int i;

 namespace В {

  int i; // скрывает A::i в В

  int j;

  int f1() {

   int j;    // j локальна для f1() и скрывает A::B::j

   return i; // возвращает B::i

  }

 } // пространство имен В закрыто, и его имена больше не видимы

 int f2() {

  return j; // ошибка: j не определена

 }

 int j = i; // инициализируется значением A::i

}

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

namespace A {

 int i;

 int k;

 class C1 {

 public:

  C1(): i(0), j(0) { }   // ok: инициализирует C1::i и C1::j

  int f1() { return k; } // возвращает A::k

  int f2() { return h; } // ошибка: h не определена

  int f3();

 private:

  int i; // скрывает A::i в C1

  int j;

 };

 int h = i; // инициализируется значением A::i

}

// член f3() определен вне класса C1 и вне пространства имен A

int A::C1::f3() { return h; } // ok: возвращает A::h

За исключением определений функций-членов, расположенных в теле класса (см. раздел 7.4.1), области видимости всегда просматриваются снизу вверх: имя должно быть объявлено прежде его применения. Следовательно, оператор return функции f2() не будет откомпилирован. Он попытается обратиться к имени h из пространства имен А, но там оно еще не определено. Если бы это имя h было определено в пространстве имен А прежде определения класса C1, его использование было бы вполне допустимо. Аналогично использование имени h в функции f3() вполне допустимо, поскольку функция f3() определена уже после определения А::h.

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

Спецификаторы A::C1::f3() указывают обратный порядок, в котором просматриваются области видимости класса и пространств имен. Первая область видимости — это функция f3(). Далее следует область видимости ее класса C1. Область видимости пространства имен А просматривается в последнюю очередь, перед переходом к области видимости, содержащей определение функции f3().

Зависимый от аргумента поиск и параметры типа класса

Рассмотрим простую программу:

std::string s;

std::cin >> s;

Как известно, этот вызов эквивалентен следующему (см. раздел 14.1):

operator>>(std::cin, s);

Функция operator>> определена библиотекой string, которая в свою очередь определяется в пространстве имен std. Но все же оператор >> можно вызвать без спецификатора std:: и без объявления using.

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

В этом примере, когда компилятор встречает "вызов" оператора operator>>, он ищет соответствующую функцию в текущей области видимости, включая области видимости, окружающие оператор вывода. Кроме того, поскольку выражение вывода имеет параметры типа класса, компилятор ищет также в пространствах имен, в которых определяются типы cin и s. Таким образом, для этого вызова компилятор просмотрит пространство имен std, определяющее типы istream и string. При поиске в пространстве имен std компилятор находит функцию вывода класса string.

Это исключение из правил поиска позволяет функции, не являющейся членом класса, быть концептуально частью интерфейса к классу и использоваться без отдельного объявления using. Без этого исключения из правил поиска для оператора вывода всегда пришлось бы предоставлять соответствующее объявление using:

using std::operator>>; // чтобы позволить cin >> s

Либо пришлось бы использовать форму записи вызова функции, включающую спецификатор пространства имен:

std::operator>>(std::cin, s); // ok: явное использование std::>>

He было бы никакого способа использовать синтаксис оператора. Любое из этих объявлений выглядит неуклюже и существенно затруднило бы использование библиотеки ввода-вывода.

Поиск и функции std::move() и std::forward()

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

Теперь рассмотрите библиотечные функции move() и forward(). Обе являются шаблонами функций, и библиотека определяет их версии с одним параметром функции в виде ссылки на r-значение. Как уже упоминалось, параметру ссылки на r-значение в шаблоне функции может соответствовать любой тип (см. раздел 16.2.6). Если приложение определяет функцию по имени move(), получающую один параметр, то (вне зависимости от типа параметра) версия функции move() из приложения вступит в конфликт с библиотечной версией. Это справедливо и для функции forward().

В результате конфликты имен для функций move() (и forward()) более вероятны, чем для других библиотечных функций. Кроме того, поскольку функции move() и forward() осуществляют весьма специфические для типа манипуляции, вероятность того, что в приложении специально необходимо переопределить поведение этих функций, довольно мала.

Тот факт, что конфликты имен с этими функциями более вероятны (и менее вероятно, что намеренными), объясняет, почему их имена всегда следует использовать полностью квалифицированными (см. раздел 12.1.5). Форма записи std::move(), а не просто move() гарантирует применение версии из стандартной библиотеки.

Дружественные объявления и зависимый от аргумента поиск

Напомним, что на момент, когда класс объявляет функцию дружественной (см. раздел 7.2.1), объявление функции необязательно должно быть видимым. Если объявление функции еще не видимо, результатом объявления ее дружественной окажется помещение объявления данной функции или класса в окружающую область видимости. Комбинация этого правила и зависимого от аргумента поиска может привести к неожиданным результатам:

namespace A {

 class С {

  // два друга; ничего не объявлено кроме дружественных отношений

  // эти функции неявно являются членами пространства имен A

  friend void f2(); // не будет найдено, если не объявлено иное

  friend void f(const C&); // найдено зависимым от аргумента

                           // поиском

 };

}

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

int main() {

 A::C cobj;

 f(cobj); // ok: находит A::f() по объявлению дружественным в A::C

 f2();    // ошибка: A::f2() не объявлена

}

Поскольку функция f() получает аргумент типа класса и неявно объявляется в том же пространстве имен, что и C, при вызове она будет найдена. Так как у функции f2() никакого параметра нет, она не будет найдена.

Упражнения раздела 18.2.3

Упражнение 18.18. С учетом следующего типичного определения функции swap() в разделе 13.3 определите, какая ее версия используется, если mem1 имеет тип string. Что, если mem1 имеет тип int? Объясните, как будет проходить поиск имен в обоих случаях.

void swap(T v1, T v2) {

 using std::swap;

 swap(v1.mem1, v2.mem1);

 // обмен остальных членов типа Т

}

Упражнение 18.19. Что, если бы вызов функции swap() был бы таким

std::swap(v1.mem1, v2.mem1)?