R.13.2 Сопоставление параметров

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

функций с этим именем, которые находятся в текущей области видимости, и

для которых существуют преобразования типа, делающие вызов возможным.

Выбирается та функция, которая наиболее соответствует фактическим

параметрам. Она находится в области пересечения множеств

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

фактическому параметру. Операция вызова считается допустимой, если в этом

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

должна более любой другой функции с тем же именем соответствовать

вызову, хотя бы по одному из параметров (необязательно это

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

вызов считается недопустимым.

При сопоставлении параметров рассматривают функцию с числом

стандартных значений параметров ($$R.8.2.6), равным n, как

n+1 функций с различным числом параметров.

При сопоставлении параметров нестатическую функцию-член

рассматривают как функцию, имеющую дополнительный параметр,

указывающий на объект, для которого вызывается функция. Этот

дополнительный формальный параметр должен сопоставляться или

с объектом, или с указателем на объект, заданными в явной операции

вызова функции-члена ($$R.5.2.4), или же с первым операндом

перегруженной функции operator ($$R.13.4). Для этого дополнительного

параметра не используется никаких временных объектов, а для достижения

сопоставления не производится никаких пользовательских преобразований

типа.

Если явно вызывается член класса X, используя указатель и операцию

->, то считается, что дополнительный параметр имеет тип const* X для

членов типа const, volatile* X для членов типа volatile и

X* для всех остальных членов. Если явно вызывается функция-член,

используя объект и операцию ., а также, если вызывается функция

для первого операнда перегруженной функции operator ($$R.9.4),

то считается, что дополнительный параметр имеет тип: const X& для

членов типа const, volatile X& для членов типа volatile и X&

для всех остальных членов. Первый операнд для ->* и .* рассматривается

так же, как и первый операнд для -> и . соответственно.

Эллипсис в списке формальных параметров ($$R.8.2.5) может

сопоставляться с фактическим параметром любого типа.

Для данного фактического параметра допускается только такая

последовательность преобразований типа, которая содержит не более

одного пользовательского преобразования. Ее нельзя сократить,

исключив одно или несколько преобразований, до последовательности,

которая также приводит к типу, сопоставимому с типом рассматриваемого

формального параметра. Такая последовательность преобразований

называется наиболее соответствующей последовательностью.

Например, последовательность int->float->double задает

преобразование int в double, но ее нельзя назвать наиболее

соответствующей последовательностью, поскольку в ней содержится

более короткая последовательность int->double.

Кроме описанных ниже случаев, следующие тривиальные

преобразования типа T не влияют на свойство последовательности

быть наиболее соответствующей:

исходный тип тип результата

T T&

T& T

T[] T*

T(параметры) T(*)(параметры)

T const T

T volatile T

T* const T*

T* volatile T*

Последовательности тривиальных преобразований, которые отличаются

только порядком преобразований, считаются совпадающими. Отметим,

что для функций с формальным параметром типа T, const T, volatile T,

T&, const T& и volatile T& допустим фактический параметр из одно и

того же множества значений. При необходимости для разделения

последовательностей преобразований используются спецификации const и

volatile, как описано в правиле [1] ниже.

Для формального параметра типа T& требуется временная переменная

в случаях, если: фактический параметр не является адресом, или имеет тип,

отличный от T, в том числе тип volatile. Наличие такой переменной

не влияет на сопоставление параметров. Однако, оно может повлиять

на допустимость результата сопоставления, т.к. временную переменную

нельзя использовать для инициализации ссылок, не являющихся

const ($$R.8.4.3).

Последовательности преобразований рассматриваются согласно

следующим правилам:

[1] Точное сопоставление. Последовательности из нуля или более

тривиальных преобразований предпочтительнее любых других

последовательностей. Из более сложных последовательностей

наиболее предпочтительны те, в которых нет преобразований

T* в const T*, T* в volatile T*, T& в const T& или

T& в volatile T&.

[2] Сопоставление со стандартными преобразованиями основных типов.

Из последовательностей, не относящихся к [1], наиболее

предпочтительны те, которые содержат только стандартные

целочисленные преобразования ($$R.4.1),

преобразования float в double и тривиальные преобразования.

[3] Сопоставление с любыми стандартными преобразованиями.

из последовательностей, не относящихся к [2], наиболее

предпочтительны те, которые содержат только любые

стандартные преобразования ($$R.4.1, $$R.4.2, $$R.4.3, $$R.4.4,

$$R.4.5, $$R.4.6, $$R.4.7, $$R.4.8) и тривиальные

преобразования. Для этих последовательностей если A является

прямым или косвенным общим базовым для класса B,

то преобразование B* в A* предпочтительнее преобразования B*

в void* или const void*. Далее, если B является прямым или

косвенным базовым классом для C, то предпочтительнее преобразование

C* в B*, чем C* в A*, и предпочтительнее преобразование C& в B&,

чем C& в A&. Иерархия классов выступает здесь критерий отбора

преобразований указателя в член ($$R.4.8).

[4] Сопоставление с пользовательскими преобразованиями.

Из последовательностей, не относящихся к [3], наиболее

предпочтительны те, которые содержат только

пользовательские ($$R.12.3), стандартные ($$R.4) и тривиальные

преобразования.

[5] Сопоставление с эллипсисом.

Последовательности, которые требуют сопоставления с эллипсисом,

считаются наименее предпочтительными.

Пользовательские преобразования выбирают, исходя из типа

переменной, которая инициализируется или которой присваивается

значение.

class Y {

// ...

public:

operator int();

operator double();

};

void f(Y y)

{

int i = y; // вызов Y::operator int()

double d;

d = y; // вызов Y::operator double()

float f = y; // ошибка: неоднозначность

}

Стандартные преобразования ($$R.4) могут применяться к параметру,

как до пользовательского преобразования, так и после него.

struct S { S(long); operator int(); };

void f(long), f(char*);

void g(S), g(char*);

void h(const S&), h(char*);

void k(S& a)

{

f(a); // f(long(a.operator int()))

g(1); // g(S(long(1)))

h(1); // h(S(long(1)))

}

Если для параметра требуется пользовательское преобразование, то не

учитываются никакие стандартные преобразования, которые могут

затрагивать этот параметр, например:

class x {

public:

x(int);

};

class y {

public:

y(long);

};

void f(x);

void f(y);

void g()

{

f(1); // неоднозначность

}

Здесь вызов f(1) неоднозначен. Несмотря на то, что для вызова

f(y(long(1))) требуется на одно стандартное преобразование больше,

чем для вызова f(x(1)), второй вызов не является предпочтительным.

Преобразования с помощью конструктора ($$R.12.1) и с помощью

функции преобразования ($$R.12.3.2) равноправны.

struct X {

operator int();

};

struct Y {

Y(X);

};

Y operator+(Y,Y);

void f(X a, X b)

{

a+b; // ошибка, неоднозначность:

// operator+(Y(a), Y(b)) или

// a.operator int() + b.operator int()

}