Поиск имени в зависимости от аргумента - Argument-dependent name lookup

в C ++ язык программирования, поиск, зависящий от аргументов (ADL), или же поиск имени в зависимости от аргумента,[1] относится к искать неквалифицированного функция имя в зависимости от типы из аргументы дано вызов функции. Это поведение также известно как Поиск по Кенигу, как это часто приписывают Эндрю Кениг, хотя он не является его изобретателем.[2]

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

Пример

Пример ADL выглядит так:

пространство имен NS {учебный класс А {};пустота ж(А& а, int я) {}}  // пространство имен NSint главный() {   NS::А а;   ж(а, 0);  // Вызывает NS :: f.}

Хотя главный функция не находится в пространстве имен NS, и пространство имен не входит в область видимости, функция NS: f (A &, целое) находится из-за объявленных типов фактических параметров в операторе вызова функции.

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

#включают <iostream>#включают <string>int главный() {  стандартное::нить ул = "Привет, мир";  стандартное::cout << ул;}

С помощью << эквивалентно вызову оператор << без std :: квалификатор. Однако в этом случае перегрузка оператора <<, который работает для нить находится в стандартное пространство имен, поэтому для его использования требуется ADL.

Следующий код будет работать без ADL (который в любом случае применяется к нему):

#включают <iostream>int главный() {  стандартное::cout << 5;}

Это работает, потому что оператор вывода для целых чисел является функцией-членом std :: ostream класс, который является типом cout. Таким образом, компилятор интерпретирует этот оператор как

стандартное::cout.оператор<<(5);

который он может разрешить во время обычного поиска. Однако учтите, что, например, то const char * перегружен оператор << не является функцией-членом в стандартное пространство имен и, следовательно, требует ADL для правильного поиска:

/ * будет печатать предоставленную строку char, как ожидалось, используя ADL, полученный из типа аргумента std :: cout * /оператор<<(стандартное::cout, "Всем привет")/ * вызывает функцию-член ostream оператора <<, принимая void const *, который напечатает адрес предоставленной строки char вместо содержимого строки char * / стандартное::cout.оператор<<("Всем привет")

В стандартное пространство имен перегружено, не член оператор << Еще один пример - функция для обработки строк:

/ * эквивалент operator << (std :: cout, str). Компилятор ищет пространство имен std с помощью ADL из-за типа std :: string параметра str и std :: cout * /стандартное::cout << ул;

Как отмечает Кениг в личной заметке,[2] без ADL компилятор укажет на ошибку, заявив, что не может найти оператор << поскольку в заявлении явно не указано, что он находится в стандартное пространство имен.

Интерфейсы

Функции, найденные ADL, считаются частью интерфейса класса. В стандартной библиотеке C ++ несколько алгоритмов используют неквалифицированные вызовы замена изнутри стандартное пространство имен. В результате общий std :: swap функция используется, если больше ничего не найдено, но если эти алгоритмы используются со сторонним классом, Фу, находится в другом пространстве имен, которое также содержит своп (Foo &, Foo &), эта перегрузка замена будет использован.

Критика

Хотя ADL позволяет функциям, определенным вне класса, вести себя так, как если бы они были частью интерфейса этого класса, он делает пространства имен менее строгими и поэтому может потребовать использования полностью определенных имен, когда в противном случае они не понадобились бы. Например, стандартная библиотека C ++ широко использует неквалифицированные вызовы std :: swap чтобы поменять местами два значения. Идея состоит в том, что затем можно определить собственную версию std :: swap в собственном пространстве имен, и она будет использоваться в алгоритмах стандартной библиотеки. Другими словами, поведение

пространство имен N {структура А {};}  // пространство имен NА а;А б;стандартное::замена(а, б);

может или не может быть таким же, как поведение

с помощью стандартное::замена;замена(а, б);

(куда а и б относятся к типу N :: A) потому что, если N :: своп (N :: A &, N :: A &) существует, второй из приведенных выше примеров вызовет его, а первый - нет. Более того, если по какой-то причине оба N :: своп (N :: A &, N :: A &) и std :: swap (N :: A &, N :: A &) определены, то первый пример вызовет std :: swap (N :: A &, N :: A &) но второй не будет компилироваться, потому что своп (а, б) было бы неоднозначно.

В общем, чрезмерная зависимость от ADL может привести к семантический проблемы. Если одна библиотека, L1, ожидает неквалифицированных звонков на оплачивать) иметь одно значение и другую библиотеку, L2 ожидает, что у него будет другой, тогда пространства имен потеряют свою полезность. Если, однако, L1 ожидает L1 :: foo (Т) иметь одно значение и L2 делает то же самое, тогда конфликта нет, но призывает оплачивать) должны быть полностью квалифицированы (т.е. L1 :: foo (х) в отличие от используя L1 :: foo; foo (x);), чтобы ADL не мешал.

Рекомендации

  1. ^ «Рабочий проект стандарта языка программирования C ++» (PDF). JTC1 / SC22 / WG21. 19 октября 2005 г. Глава 3.4.2 - Поиск имени в зависимости от аргумента - п. 2. Архивировано из оригинал (PDF) 14 декабря 2005 г.. Получено 13 марта 2012.
  2. ^ а б «Личное примечание о поиске, зависящем от аргумента». 3 мая 2012. Архивировано с оригинал 17 марта 2018 г.. Получено 7 февраля 2014.

внешняя ссылка