Язык программирования C++. Пятое издание

Чтобы определить наилучшее соответствие, компилятор ранжирует преобразования, применяемые для приведения типа аргумента к типу соответствующего ему параметра. Преобразования ранжируются в порядке убывания следующим образом.

1. Точное соответствие. Типы аргумента и параметра совпадают в случае, если:

 • типы аргумента и параметра идентичны;

 • аргумент преобразуется из типа массива или функции в соответствующий тип указателя. (Указатели на функции рассматриваются в разделе 6.7);

 • аргумент отличается наличием или отсутствием спецификатора const верхнего уровня.

2. Соответствие в результате преобразования констант (см. раздел 4.11.2).

3. Соответствие в результате преобразования (см. раздел 4.11.1).

4. Соответствие в результате арифметического преобразования (см. раздел 4.11.1) или преобразования указателя (см. раздел 4.11.2).

5. Соответствие в результате преобразования класса (раздел 14.9).

Соответствие, требующее приведения и (или) целочисленного преобразования

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

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

void ff(int);

void ff(short);

ff('a'); // тип char приводится к int, поэтому применяется f(int)

Все целочисленные преобразования считаются эквивалентными друг другу. Преобразование из типа int в unsigned int, например, не имеет преимущества перед преобразованием типа int в double. Рассмотрим конкретный пример.

void manip(long);

void manip(float);

manip(3.14); // ошибка: неоднозначный вызов

Литерал 3.14 имеет тип double. Этот тип может быть преобразован или в тип long, или в тип float. Поскольку возможны два целочисленных преобразования, вызов неоднозначен.

Соответствие функций и константные аргументы

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

Record lookup(Account&);       // функция, получающая ссылку на Account

Record lookup(const Account&); // новая функция, получающая ссылку на

                               // константу

const Account а;

Account b;

lookup(а); // вызов lookup(const Account&)

lookup(b); // вызов lookup(Account&)

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

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

Параметры в виде указателя работают подобным образом. Если две функции отличаются только тем, указывает ли параметр на константу или не константу, компилятор на основании константности аргумента вполне может решить, какую версию функции использовать: если аргумент является указателем на константу, то вызов будет соответствовать версии, получающей тип const*; в противном случае, если аргумент — указатель на не константу, вызывается версия, получающая простой указатель.

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

Упражнение 6.52. Предположим, что существуют следующие объявления:

void manip(int, int);

double dobj;

Каков порядок (см. раздел 6.6.1) преобразований в каждом из следующих обращений?

(a) manip('a', 'z'); (b) manip(55.4, dobj);

Упражнение 6.53. Объясните назначение второго объявления в каждом из следующих наборов. Укажите, какие из них (если они есть) недопустимы.

(a) int calc(int&, int&);

    int calc(const int&, const int&);

(b) int calc(char*, char*);