Подробнее о расширении типов
Под расширением типа понимается одно из следующих преобразований:
·
фактический аргумент типа char, unsigned char или short
расширяется до типа int. Фактический аргумент типа unsigned short
расширяется до типа int, если машинный размер int
больше, чем размер short, и до типа unsigned int в противном случае;
· аргумент типа float
расширяется до типа double;
· аргумент перечислимого типа расширяется до первого из следующих типов, который способен представить все значения элементов перечисления: int, unsigned int, long, unsigned long;
· аргумент типа bool
расширяется до типа int.
Подобное расширение применяется, когда тип фактического аргумента совпадает с одним из только что перечисленных типов, а формальный параметр относится к соответствующему расширенному типу:
|
extern void manip( int ); int main() { manip( 'a' ); // тип char расширяется до int return 0; |
}
Символьный литерал имеет тип char. Он расширяется до int. Поскольку расширенный тип соответствует типу формального параметра функции manip(), мы говорим, что ее вызов требует расширения типа аргумента.
Рассмотрим следующий пример:
|
extern void print( unsigned int ); extern void print( int ); extern void print( char ); unsigned char uc; |
print( uc ); // print( int ); для uc требуется только расширение типа
Для аппаратной платформы, на которой unsigned char
занимает один байт памяти, а int – четыре байта, расширение преобразует unsigned char в int, так как с его помощью можно представить все значения типа unsigned char. Для такой машинной архитектуры из приведенного в примере множества перегруженных функций наилучшее соответствие аргументу типа unsigned char
обеспечивает print(int). Для двух других функций установление соответствия требует стандартного приведения.
Следующий пример иллюстрирует расширение фактического аргумента перечислимого типа:
enum Stat ( Fail, Pass ); extern void ff( int ); extern void ff( char ); int main() { // правильно: элемент перечисления Pass расширяется до типа int ff( Pass ); // ff( int ) ff( 0 ); // ff( int ) |
Иногда расширение перечислений преподносит сюрпризы. Компиляторы часто выбирают представление перечисления в зависимости от значений его элементов. Предположим, что в вышеупомянутой архитектуре (один байт для char и четыре байта для int) определено такое перечисление:
enum e1 { a1, b1, c1 };
Поскольку есть всего три элемента: a1, b1 и c1 со значениями 0, 1 и 2
соответственно – и поскольку все эти значения можно представить типом
char, то компилятор, как правило, и выбирает char для представления типа e1. Рассмотрим, однако, перечисление e2 со следующим множеством элементов:
enum e2 { a2, b2, c2=0x80000000 };
Так как одна из констант имеет значение 0x80000000, то компилятор обязан выбрать для представления e2
такой тип, который достаточен для хранения значения 0x80000000, то есть unsigned int.
Итак, хотя и e1, и e2
являются перечислениями, их представления различаются. Из-за этого e1 и e2
расширяются до разных типов:
#include <string> string format( int ); string format( unsigned int ); int main() { format(a1); // вызывается format( int ) format(a2); // вызывается format( unsigned int ) return 0; |
При первом обращении к format()
фактический аргумент расширяется до типа int, так как для представления типа e1
используется char, и, следовательно, вызывается перегруженная функция format(int). При втором обращении тип фактического аргумента e2
представлен типом unsigned int и аргумент расширяется до unsigned int, из-за чего вызывается перегруженная функция format(unsigned int). Поэтому следует помнить, что поведение двух перечислений по отношению к процессу разрешения перегрузки может быть различным и зависеть от значений элементов, определяющих, как происходит расширение типа.
