(a) enum Stat { Fail, Pass }; void test( Stat );

text( 0 ); вызов функции

(b) void reset( void *);

reset( 0 ); вызов функции

(c) void set( void * ); int *pi;

set( pi ); вызов функции

(d) #include <list>

list<int> oper();

void print( oper() ); вызов функции

const int );

(e) void print( int iobj;

print( iobj ); вызов функции

9.4. Детали разрешения перегрузки функций

В разделе 9.2 м1 уже упоминали, что процесс разрешения перегрузки функций состоит из трех шагов:

1. Установить множество функций-кандидатов для разрешения данного вызова, а также свойства списка фактических аргументов.

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

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

Теперь мы готовы к тому, чтобы изучить эти шаги более детально.

9.4.1. Функции-кандидаты

Функцией-кандидатом называется функция, имеющая то же имя, что и вызванная. Кандидаты отыскиваются двумя способами:

void f(); void f( int );

void f( double, double = 3.4 ); void f( char*, char* );

int main() {

f( 5.6 ); для разрешения этого вызова есть чете кандидата return 0;

объявление функции видимо в точке вызова. В следующем примере

namespace NS {

class C { /* ... */ };

void takeC( C& );

тип cobj - это класс C, объявленн в пространстве имен NS

NS::C obj;

int main() {

в точке вызова не видна ни одна из функций takeC() takeC( cobj); правильно: вызывается NS::takeC( C& ),

потому что аргумент имеет тип NS::C, следовательно,

принимается во внимание функция takeC(), объявленная в пространстве имен NS

функция, добавляются в множество кандидатов:

return 0;

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

При идентификации множества перегруженных функций, видимых в точке вызова, применимы уже рассмотренные ранее правила.

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

char* format( int );

void g() {

char *format( double );

char* format( char*

format(3); вызывается format( double ) format(double) и format(char*) :

Так как format(int) , объявленная в глобальной области видимости, скрыта, она не включается в множество функций-кандидатов.

Кандидаты могут быть введены с помощью using-объявлений, видим1х в точке вызова:

все четыре функции f() удовлетворяют этому условию. Поэтому множество кандидатов содержит четыре элемента;

если тин фактического аргумента объявлен внутри некоторого пространства имен, то функции-члены этого пространства, имеющие то же имя, что и вызванная

namespace libs R us { int max( int, int ); double max( double, double );

char max( char, char );

void func()

функции из пространства имен невидимы

все три вызова разрешаются в пользу глобальной функции max( char,

char )

max( 87, 65 ); max( 35.5, 7 6.6 ); max( J, L );

Функции max() , определенные в пространстве имен libs R us, невидимы в точке вызова. Единственной видимой является функция miax() из глобальной области; только она входит в множество функций-кандидатов и вызывается при каждом из трех обращений к func(). М1 можем воспользоваться using-объявлением, чтобы сделать видим1ми функции miax() из пространства имен libs R us. Куда поместить using-

char max( char, char );

объявление? Если включить его в глобальную область видимости:

using libs R us::max; using-объявление

то функции max() из libs R us добавляются в множество перегруженных функций, которое уже содержит max() , объявленную в глобальной области. Теперь все три функции видны внутри func() и становятся кандидатами. В этой ситуации вызовы

void func() {

max( 87, 65 ); вызывается libs R us::max( int, int )

max( 35.5, 76.6 ); вызывается libs R us::max( double, double )

max( J, L ); вызывается ::max( char, char )

func() разрешаются следующим образом:

Но что будет, если мы введем using-объявление в локальную область видимости функции

void func() {

using-объявление using libs R us::max;

те же вызовы функций, что и выше

func() , как показано в данном примере?