9.3.1. Подробнее о точном соответствии

9.3.1. Подробнее о точном соответствии

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

int max( int, int );

double max( double, double );

int i1;

void calc( double d1 ) {

max( 56, i1 ); // точно соответствует max( int, int );

max( d1, 66.9 ); // точно соответствует max( double, double );

}

Перечислимый тип точно соответствует только определенным в нем элементам перечисления, а также объектам, которые объявлены как принадлежащие к этому типу:

enum Tokens { INLINE = 128; VIRTUAL = 129; };

Tokens curTok = INLINE;

enum Stat { Fail, Pass };

extern void ff( Tokens );

extern void ff( Stat );

extern void ff( int );

int main() {

ff( Pass ); // точно соответствует ff( Stat )

ff( 0 ); // точно соответствует ff( int )

ff( curTok ); // точно соответствует ff( Tokens )

// ...

}

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

* можно получить адрес объекта;

* можно получить значение объекта;

* это значение легко модифицировать (если только в объявлении объекта нет спецификатора const).

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

int calc( int );

int main() {

int lval, res;

lval = 5; // lvalue: lval; rvalue: 5

res = calc( lval );

// lvalue: res

// rvalue: временный объект для хранения значения,

// возвращаемого функцией calc()

return 0;

}

В первом операторе присваивания переменная lval – это l-значение, а литерал 5 – r-значение. Во втором операторе присваивания res – это l-значение, а временный объект, в котором хранится результат, возвращаемый функцией calc(), – это r-значение.

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

int obj1;

int obj2;

int main() {

// ...

int local = obj1 + obj2;

return 0;

}

Здесь obj1 и obj2 – это l-значения. Однако для выполнения сложения в функции main() из переменных obj1 и obj2 извлекаются их значения. Действие, состоящее в извлечении значения объекта, представленного выражением вида l-значение, называется преобразованием l-значения в r-значение.

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

#include string

string color( "purple" );

void print( string );

int main() {

print( color ); // точное соответствие: преобразование lvalue

// в rvalue

return 0;

}

Так как аргумент в вызове print(color) передается по значению, то производится преобразование l-значения в r-значение для извлечения значения color и передачи его в функцию с прототипом print(string). Однако несмотря на то, что такое приведение имело место, считается, что фактический аргумент color точно соответствует объявлению print(string).

При вызове функций не всегда требуется применять к аргументам подобное преобразование. Ссылка представляет собой l-значение; если у функции есть параметр-ссылка, то при вызове функция получает l-значение. Поэтому к фактическому аргументу, которому соответствует формальный параметр-ссылка, описанное преобразование не применяется. Например, пусть объявлена такая функция:

#include list

void print( listint );

В вызове ниже li – это l-значение, представляющее объект listint, передаваемый функции print():

listint li(20);

int main() {

// ...

print( li ); // точное соответствие: нет преобразования lvalue в

// rvalue

return 0;

}

Сопоставление li с параметром-ссылкой считается точным соответствием.

Второе преобразование, при котором все же фиксируется точное соответствие, – это преобразование массива в указатель. Как уже отмечалось в разделе 7.3, параметр функции никогда не имеет тип массива, трансформируясь вместо этого в указатель на его первый элемент. Аналогично фактический аргумент типа массива из NT (где N – число элементов в массиве, а T – тип каждого элемента) всегда приводится к типу указателя на T. Такое преобразование типа фактического аргумента и называется преобразованием массива в указатель. Несмотря на это, считается, что фактический аргумент точно соответствует формальному параметру типа “указатель на T”. Например:

int ai[3];

void putValues(int *);

int main() {

// ...

putValues(ai); // точное соответствие: преобразование массива в

// указатель

return 0;

}

Перед вызовом функции putValues() массив преобразуется в указатель, в результате чего фактический аргумент ai (массив из трех целых) приводится к указателю на int. Хотя формальным параметром функции putValues() является указатель и фактический аргумент при вызове преобразован, между ними устанавливается точное соответствие.

При установлении точного соответствия допустимо также преобразование функции в указатель. (Оно упоминалось в разделе 7.9.) Как и параметр-массив, параметр-функция становится указателем на функцию. Фактический аргумент типа “функция” также автоматически приводится к типу указателя на функцию. Такое преобразование типа фактического аргумента и называется преобразованием функции в указатель. Хотя трансформация производится, считается, что фактический аргумент точно соответствует формальному параметру. Например:

int lexicoCompare( const string , const string );

typedef int (*PFI)( const string , const string );

void sort( string *, string *, PFI );

string as[10];

int main()

{

// ...

sort( as,

as + sizeof(as)/sizeof(as[0] - 1 ),

lexicoCompare // точное соответствие

// преобразование функции в указатель

);

return 0;

}

Перед вызовом sort() применяется преобразование функции в указатель, которое приводит аргумент lexicoCompare от типа “функция” к типу “указатель на функцию”. Хотя формальным параметром функции является указатель, а фактическим – имя функции и, следовательно, было произведено преобразование функции в указатель, считается, что фактический аргумент точно третьему формальному параметру функции sort().

Последнее из перечисленных выше – это преобразование спецификаторов. Оно относится только к указателям и заключается в добавлении спецификаторов const или volatile (или обоих) к типу, который адресует данный указатель:

int a[5] = { 4454, 7864, 92, 421, 938 };

int *pi = a;

bool is_equal( const int * , const int * );

void func( int *parm ) {

// точное соответствие между pi и parm: преобразование спецификаторов

if ( is_equal( pi, parm ) )

// ...

return 0;

}

Перед вызовом функции is_equal() фактические аргументы pi и parm преобразуются из типа “указатель на int” в тип “указатель на const int”. Эта трансформация заключается в добавлении спецификатора const к адресуемому типу, поэтому относится к категории преобразований спецификаторов. Несмотря на то, что функция ожидает получить два указателя на const int, а фактические аргументы являются указателями на int, считается, что точное соответствие между формальными и фактическими параметрами функции is_equal() установлено.

Преобразование спецификаторов применимо только к типу, который адресует указатель. Оно не употребляется в случае, когда формальный параметр имеет спецификатор const или volatile, а фактический аргумент – нет.

extern void takeCI( const int );

int main() {

int ii = ...;

takeCI(ii); // преобразование спецификаторов не применяется

return 0;

}

Хотя формальный параметр функции takeCI() имеет тип const int, а вызывается она с аргументом ii типа int, преобразование спецификаторов не производится: есть точное соответствие между фактическим аргументом и формальным параметром.

Все сказанное верно и для случая, когда аргумент является указателем, а спецификаторы const или volatile относятся к этому указателю:

extern void init( int *const );

extern int *pi;

int main() {

// ...

init(pi); // преобразование спецификаторов не применяется

return 0;

}

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

Первые три из рассмотренных преобразований (l-значения в r-значение, массива в указатель и функции в указатель) часто называют трансформациями l-значений. (В разделе 9.4 мы увидим, что хотя и трансформации l-значений, и преобразования спецификаторов относятся к категории преобразований, не нарушающих точного соответствия, его степень считается выше в случае, когда необходима лишь первая трансформация. В следующем разделе мы поговорим об этом несколько подробнее.)

Точное соответствие можно установить принудительно, воспользовавшись явным приведением типов. Например, если есть две перегруженные функции:

extern void ff(int);

extern void ff(void *);

то вызов

ff( 0xffbc ); // вызывается ff(int)

будет точно соответствовать ff(int), хотя литерал 0xffbc записан в виде шестнадцатеричной константы. Программист может заставить компилятор вызвать функцию ff(void *), если явно выполнит операцию приведения типа:

ff( reinterpret_castvoid *(0xffbc) ); // вызывается ff(void*)

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