Язык программирования C++. Вводный курс. С для начинающих
 Скачать 5.41 Mb.
|
|
446 } При первом обращении к format() фактический аргумент расширяется до типа int, так как для представления типа e1 используется char, и, следовательно, вызывается перегруженная функция format(int). При втором обращении тип фактического аргумента e2 представлен типом unsigned int и аргумент расширяется до unsigned int , из-за чего вызывается перегруженная функция format(unsigned int). Поэтому следует помнить, что поведение двух перечислений по отношению к процессу разрешения перегрузки может быть различным и зависеть от значений элементов, определяющих, как происходит расширение типа. 9.3.3. Подробнее о стандартном преобразовании Имеется пять видов стандартных преобразований, а именно: 1. преобразования целых типов: приведение от целого типа или перечисления к любому другому целому типу (исключая трансформации, которые выше были отнесены к категории расширения типов); 2. преобразования типов с плавающей точкой: приведение от любого типа с плавающей точкой к любому другому типу с плавающей точкой (исключая трансформации, которые выше были отнесены к категории расширения типов); 3. преобразования между целым типом и типом с плавающей точкой: приведение от любого типа с плавающей точкой к любому целому типу или наоборот; 4. преобразования указателей: приведение целого значения 0 к типу указателя или трансформация указателя любого типа в тип void*; 5. преобразования в тип bool: приведение от любого целого типа, типа с плавающей точкой, перечислимого типа или указательного типа к типу bool. Вот несколько примеров: #include // i подвергается стандартному преобразованию из int в double print( &i ); // соответствует print( void* ); // &i подвергается стандартному преобразованию // из int* в void* return 0; С++ для начинающих 447 } Преобразования, относящиеся к группам 1, 2 и 3, потенциально опасны, так как целевой тип может и не обеспечивать представления всех значений исходного. Например, с помощью float нельзя адекватно представить все значения типа int. Именно по этой причине трансформации, входящие в эти группы, отнесены к категории стандартных преобразований, а не расширений типов. } При вызове функции calc() применяется стандартное преобразование из целого типа int в тип с плавающей точкой float. В зависимости от значения переменной i может оказаться, что его нельзя сохранить в типе float без потери точности. Предполагается, что все стандартные изменения требуют одного объема работы. Например, преобразование из char в unsigned char не более приоритетно, чем из char в double. Близость типов не принимается во внимание. Если две устоявших функции требуют для установления соответствия стандартной трансформации фактического аргумента, то вызов считается неоднозначным и помечается компилятором как ошибка. Например, если даны две перегруженные функции: extern void manip( float ); то следующий вызов неоднозначен: } Константа 3.14 имеет тип double. С помощью того или иного стандартного преобразования соответствие может быть установлено с любой из перегруженных функций. Поскольку есть две трансформации, приводящие к цели, вызов считается неоднозначным. Ни одно преобразование не имеет преимущества над другим. Программист может разрешить неоднозначность либо путем явного приведения типа: manip ( static_cast // плавающей точкой потенциально опасно в зависимости от // значения i return 0; extern void manip( long ); int main() { manip( 3.14 ); // ошибка: неоднозначность // manip( float ) не лучше, чем manip( int ) return 0; С++ для начинающих 448 manip ( 3.14F ) ); // manip( float ) Вот еще несколько примеров неоднозначных вызовов, которые помечаются как ошибки, поскольку соответствуют нескольким перегруженным функциям: } Стандартные преобразования указателей иногда противоречат интуиции. В частности, значение 0 приводится к указателю на любой тип; полученный таким образом указатель называется нулевым. Значение 0 может быть представлено как константное выражение целого типа: } Константное выражение 0L (значение 0 типа long int) и константное выражение 0x00 (шестнадцатеричное целое значение 0) имеют целый тип и потому могут быть преобразованы в нулевой указатель типа int*. Но поскольку перечисления не относятся к целым типам, элемент, равный 0, не приводим к типу указателя: set( zr ); // ошибка: zr нельзя преобразовать в тип int* Вызов функции set() является ошибкой, так как не существует преобразования между значением zr элемента перечисления и формальным параметром типа int*, хотя zr равно 0. Следует отметить, что константное выражение 0 имеет тип int. Для его приведения к типу указателя требуется стандартное преобразование. Если в множестве перегруженных функций есть функция с формальным параметром типа int, то именно в ее пользу будет разрешена перегрузка в случае, когда фактический аргумент равен 0: extern void farith( unsigned int ); extern void farith( float ); int main() { // каждый из последующих вызовов неоднозначен farith( 'a' ); // аргумент имеет тип char farith( 0 ); // аргумент имеет тип int farith( 2uL ); // аргумент имеет тип unsigned long farith( 3.14159 ); // аргумент имеет тип double farith( true ); // аргумент имеет тип bool void set(int*); int main() { // преобразование указателя из 0 в int* применяется к аргументам // в обоих вызовах set( 0L ); set( 0x00 ); return 0; enum EN { zr = 0 }; С++ для начинающих 449 } При вызове print(int) имеет место точное соответствие, тогда как для вызова print(void*) необходимо приведение значения 0 к типу указателя. Поскольку соответствие лучше преобразования, для разрешения этого вызова выбирается функция print(int) . Обращение к set() неоднозначно, так как 0 соответствует формальным параметрам обеих перегруженных функций за счет применения стандартной трансформации. Раз обе функции одинаково хороши, фиксируется неоднозначность. Последнее из возможных преобразований указателя позволяет привести указатель любого типа к типу void*, поскольку void* – это родовой указатель на любой тип данных. Вот несколько примеров: } Только указатели на типы данных могут быть приведены к типу void* с помощью стандартного преобразования, с указателями на функции так поступать нельзя: } void print( int ); void print( void * ); void set( const char * ); void set( char * ); int main () { print( 0 ); // вызывается print( int ); set( 0 ); // неоднозначность return 0; #include // ... reset( pi ); // преобразование указателя: int* в void* /// ... reset( ps ); // преобразование указателя: string* в void* typedef int (*PFV)(); extern PFV testCases[10]; // массив указателей на функции extern void reset( void * ); int main() { // ... reset( textCases[0] ); // ошибка: нет стандартного преобразования // между int(*)() и void* return 0; С++ для начинающих 450 9.3.4. Ссылки Фактический аргумент или формальный параметр функции могут быть ссылками. Как это влияет на правила преобразования типов? Рассмотрим, что происходит, когда ссылкой является фактический аргумент. Его тип никогда не бывает ссылочным. Аргумент-ссылка трактуется как l-значение, тип которого совпадает с типом соответствующего объекта: } Фактический аргумент в обоих вызовах имеет тип int. Использование ссылки для его передачи во втором вызове не влияет на сам тип аргумента. Стандартные преобразования и расширения типов, рассматриваемые компилятором, одинаковы для случаев, когда фактический аргумент является ссылкой на тип T и когда он сам имеет такой тип. Например: } А как влияет на преобразования, применяемые к фактическому аргументу, формальный параметр-ссылка? Сопоставление дает следующие результаты: • фактический аргумент подходит в качестве инициализатора параметра-ссылки. В таком случае мы говорим, что между ними есть точное соответствие: } int i; int& ri = i; void print( int ); int main() { print( i ); // аргумент - это lvalue типа int print( ri ); // то же самое return 0; int i; int& ri = i; void calc( double ); int main() { calc( i ); // стандартное преобразование между целым типом // и типом с плавающей точкой calc( ri ); // то же самое return 0; void swap( int &, int & ); void manip( int i1, int i2 ) { // ... swap( i1, i2 ); // правильно: вызывается swap( int &, int & ) // ... return 0; С++ для начинающих 451 • фактический аргумент не может инициализировать параметр-ссылку. В такой ситуации точного соответствия нет, и аргумент нельзя использовать для вызова функции. Например: } Вызов функции frd() является ошибкой. Фактический аргумент имеет тип int и должен быть преобразован в тип double, чтобы соответствовать формальному параметру-ссылке. Результатом такой трансформации является временная переменная. Поскольку ссылка не имеет спецификатора const, то для ее инициализации такие переменные использовать нельзя. Вот еще один пример, в котором между формальным параметром-ссылкой и фактическим аргументом нет соответствия: } Вызов функции takeB() – ошибка. Фактический аргумент – это возвращаемое значение, т.е. временная переменная, которая не может быть использована для инициализации ссылки без спецификатора const. В обоих случаях мы видим, что если формальный параметр-ссылка имеет спецификатор const, то между ним и фактическим аргументом может быть установлено точное соответствие. Следует отметить, что и преобразование l-значения в r-значение, и инициализация ссылки считаются точными соответствиями. В данном примере первый вызов функции приводит к ошибке: int obj; void frd( double & ); int main() { frd( obj ); // ошибка: параметр должен иметь иметь тип const double & return 0; class B; void takeB( B& ); B giveB(); int main() { takeB( giveB() ); // ошибка: параметр должен быть типа const B & return 0; void print( int ); void print( int& ); int iobj; int &ri = iobj; int main() { print( iobj ); // ошибка: неоднозначность print( ri ); // ошибка: неоднозначность print( 86 ); // правильно: вызывается print( int ) return 0; С++ для начинающих 452 } Объект iobj – это аргумент, для которого может быть установлено соответствие с обеими функциями print(), то есть вызов неоднозначен. То же относится и к следующей строке, где ссылка ri обозначает объект, соответствующий обеим функциям print(). С третьим вызовом, однако, все в порядке. Для него print(int&) не является устоявшей. Целая константа – это r-значение, так что она не может инициализировать параметр-ссылку. Единственной устоявшей функцией для вызова print(86) является print(int), поэтому она и выбирается при разрешении перегрузки. Короче говоря, если формальный параметр представляет собой ссылку, то для фактического аргумента точное соответствие устанавливается, если он может инициализировать ссылку, и не устанавливается в противном случае. Упражнение 9.6 Назовите два тривиальных преобразования, допустимых при установлении точного соответствия. Упражнение 9.7 Каков ранг каждого из преобразований аргументов в следующих вызовах функций: set( pi ); // вызов функции Упражнение 9.8 Какие из данных вызовов ошибочны из-за того, что не существует преобразования между типом фактического аргумента и формального параметра: (a) void print( int *, int ); int arr[6]; print( arr, 6 ); // вызов функции (b) void manip( int, int ); manip( 'a', 'z' ); // вызов функции (c) int calc( int, int ); double dobj; double = calc( 55.4, dobj ) // вызов функции (d) void set( const int * ); int *pi; С++ для начинающих 453 print( iobj ); // вызов функции 9.4. Детали разрешения перегрузки функций В разделе 9.2 мы уже упоминали, что процесс разрешения перегрузки функций состоит из трех шагов: 1. Установить множество функций-кандидатов для разрешения данного вызова, а также свойства списка фактических аргументов. 2. Отобрать из множества кандидатов устоявшие функции – те, которые могут быть вызваны с данным списком фактических аргументов при учете их числа и типов. 3. Выбрать функцию, лучше всего соответствующую вызову, подвергнув ранжированию преобразования, которые необходимо применить к фактическим аргументам, чтобы привести их в соответствие с формальными параметрами устоявшей функции. Теперь мы готовы к тому, чтобы изучить эти шаги более детально. 9.4.1. Функции-кандидаты Функцией-кандидатом называется функция, имеющая то же имя, что и вызванная. Кандидаты отыскиваются двумя способами: • объявление функции видимо в точке вызова. В следующем примере } (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
(e) void print( const int ); int iobj; void f(); void f( int ); void f( double, double = 3.4 ); void f( char*, char* ); int main() { f( 5.6 ); // для разрешения этого вызова есть четыре кандидата return 0; С++ для начинающих 454 все четыре функции f() удовлетворяют этому условию. Поэтому множество кандидатов содержит четыре элемента; • если тип фактического аргумента объявлен внутри некоторого пространства имен, то функции-члены этого пространства, имеющие то же имя, что и вызванная функция, добавляются в множество кандидатов: } Таким образом, совокупность кандидатов является объединением множества функций, видимых в точке вызова, и множества функций, объявленных в том же пространстве имен, к которому принадлежат типы фактических аргументов. При идентификации множества перегруженных функций, видимых в точке вызова, применимы уже рассмотренные ранее правила. Функция, объявленная во вложенной области видимости, скрывает, а не перегружает одноименную функцию во внешней области. В такой ситуации кандидатами будут только функции из во вложенной области, т.е. такие, которые не скрыты при вызове. В следующем примере функциями-кандидатами, видимыми в точке вызова, являются format(double) и format(char*): } Так как format(int), объявленная в глобальной области видимости, скрыта, она не включается в множество функций-кандидатов. Кандидаты могут быть введены с помощью using-объявлений, видимых в точке вызова: 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 ) С++ для начинающих 455 } Функции max(), определенные в пространстве имен libs_R_us, невидимы в точке вызова. Единственной видимой является функция max() из глобальной области; только она входит в множество функций-кандидатов и вызывается при каждом из трех обращений к func(). Мы можем воспользоваться using-объявлением, чтобы сделать видимыми функции max() из пространства имен libs_R_us. Куда поместить using- объявление? Если включить его в глобальную область видимости: using libs_R_us::max; // using- объявление то функции max() из libs_R_us добавляются в множество перегруженных функций, которое уже содержит max(), объявленную в глобальной области. Теперь все три функции видны внутри func() и становятся кандидатами. В этой ситуации вызовы func() разрешаются следующим образом: } Но что будет, если мы введем using-объявление в локальную область видимости функции func() , как показано в данном примере? } 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, 76.6 ); max( 'J', 'L' ); char max( char, char ); 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 ) void func() { // using- объявление using libs_R_us::max; // те же вызовы функций, что и выше С++ для начинающих 456 Какие из функций max() будут включены в множество кандидатов? Напомним, что using- объявления вкладываются друг в друга. При наличии такого объявления в локальной области глобальная функция max(char, char) оказывается скрытой, так что в точке вызова видны только libs_R_us::max( double, double ); Они и являются кандидатами. Теперь вызовы func() разрешаются следующим образом: } Using-директивы также оказывают влияние на состав множества функций-кандидатов. Предположим, мы решили их использовать, чтобы сделать функции max() из пространства имен libs_R_us видимыми в func(). Если разместить следующую using- директиву в глобальной области видимости, то множество функций-кандидатов будет состоять из глобальной функции max(char, char) и функций max(int, int) и max(double, double) , объявленных в libs_R_us: } Что будет, если поместить using-директиву в локальную область видимости, как в следующем примере? libs_R_us::max( int, int ); void func() { // using- объявление // глобальная функция max( char, char ) скрыта using libs_R_us::max; max( 87, 65 ); // вызывается libs_R_us::max( int, int ) max( 35.5, 76.6 ); // вызывается libs_R_us::max( double, double ) max( 'J', 'L' ); // вызывается libs_R_us::max( int, int ) namespace libs_R_us { int max( int, int ); double max( double, double ); } char max( char, char ); using namespace libs_R_us; // using- директива 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( int, int ) |