НА ГЛАВНУЮ
Меню сайта
Категория
Ghost++ [1]
С++ [55]
Развлечение
ON - LINE
Опрос
Часто ли вы сталкиваетесь в игре с Noob'ami?
Всего ответов: 269
Оbserver Ward

Онлайн всего: 1
Гостей: 1
Пользователей: 0


Друзья сайта
Заведи себе Бота
Hаша кнопка
Для обмена банерами , наша кнопка для размещения у вас на сайте

Клансайт USSR


Главная » Статьи » Программирование » С++

9. Перегруженные функции (2)
9.3.2. Подробнее о расширении типов

Под расширением типа понимается одно из следующих преобразований:

    * фактический аргумент типа 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). Поэтому следует помнить, что поведение двух перечислений по отношению к процессу разрешения перегрузки может быть различным и зависеть от значений элементов, определяющих, как происходит расширение типа.
9.3.3. Подробнее о стандартном преобразовании

Имеется пять видов стандартных преобразований, а именно:

   1. преобразования целых типов: приведение от целого типа или перечисления к любому другому целому типу (исключая трансформации, которые выше были отнесены к категории расширения типов);
   2. преобразования типов с плавающей точкой: приведение от любого типа с плавающей точкой к любому другому типу с плавающей точкой (исключая трансформации, которые выше были отнесены к категории расширения типов);
   3. преобразования между целым типом и типом с плавающей точкой: приведение от любого типа с плавающей точкой к любому целому типу или наоборот;
   4. преобразования указателей: приведение целого значения 0 к типу указателя или трансформация указателя любого типа в тип void*;
   5. преобразования в тип bool: приведение от любого целого типа, типа с плавающей точкой, перечислимого типа или указательного типа к типу bool.

Вот несколько примеров:

extern void print( void* );
extern void print( double );

int main() {
  int i;
  print( i ); // соответствует print( double );
  // i подвергается стандартному преобразованию из int в double
  print( &i ); // соответствует print( void* );
  // &i подвергается стандартному преобразованию
  // из int* в void*
  return 0;
}

Преобразования, относящиеся к группам 1, 2 и 3, потенциально опасны, так как целевой тип может и не обеспечивать представления всех значений исходного. Например, с помощью float нельзя адекватно представить все значения типа int. Именно по этой причине трансформации, входящие в эти группы, отнесены к категории стандартных преобразований, а не расширений типов.

int i;
void calc( float );
int main() {
   calc( i ); // стандартное преобразование между целым типом и типом с
   // плавающей точкой потенциально опасно в зависимости от
   // значения i
   return 0;
}

При вызове функции calc() применяется стандартное преобразование из целого типа int в тип с плавающей точкой float. В зависимости от значения переменной i может оказаться, что его нельзя сохранить в типе float без потери точности.
Предполагается, что все стандартные изменения требуют одного объема работы. Например, преобразование из char в unsigned char не более приоритетно, чем из char в double. Близость типов не принимается во внимание. Если две устоявших функции требуют для установления соответствия стандартной трансформации фактического аргумента, то вызов считается неоднозначным и помечается компилятором как ошибка. Например, если даны две перегруженные функции:

extern void manip( long );
extern void manip( float );

то следующий вызов неоднозначен:

int main() {
   manip( 3.14 ); // ошибка: неоднозначность
   // manip( float ) не лучше, чем manip( int )
   return 0;
}

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

manip ( static_cast<long>( 3.14 ) ); // manip( long )

либо используя суффикс, обозначающий, что константа принадлежит к типу float:

manip ( 3.14F ) ); // manip( float )

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

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
}

Стандартные преобразования указателей иногда противоречат интуиции. В частности, значение 0 приводится к указателю на любой тип; полученный таким образом указатель называется нулевым. Значение 0 может быть представлено как константное выражение целого типа:

void set(int*);

int main() {
  // преобразование указателя из 0 в int* применяется к аргументам
  // в обоих вызовах
  set( 0L );
  set( 0x00 );
  return 0;
}

Константное выражение 0L (значение 0 типа long int) и константное выражение 0x00 (шестнадцатеричное целое значение 0) имеют целый тип и потому могут быть преобразованы в нулевой указатель типа int*.
Но поскольку перечисления не относятся к целым типам, элемент, равный 0, не приводим к типу указателя:

enum EN { zr = 0 };
set( zr ); // ошибка: zr нельзя преобразовать в тип int*

Вызов функции set() является ошибкой, так как не существует преобразования между значением zr элемента перечисления и формальным параметром типа int*, хотя zr равно 0.
Следует отметить, что константное выражение 0 имеет тип int. Для его приведения к типу указателя требуется стандартное преобразование. Если в множестве перегруженных функций есть функция с формальным параметром типа int, то именно в ее пользу будет разрешена перегрузка в случае, когда фактический аргумент равен 0:

void print( int );
void print( void * );
void set( const char * );
void set( char * );
int main () {
  print( 0 ); // вызывается print( int );
  set( 0 ); // неоднозначность
  return 0;
}

При вызове print(int) имеет место точное соответствие, тогда как для вызова print(void*) необходимо приведение значения 0 к типу указателя. Поскольку соответствие лучше преобразования, для разрешения этого вызова выбирается функция print(int). Обращение к set() неоднозначно, так как 0 соответствует формальным параметрам обеих перегруженных функций за счет применения стандартной трансформации. Раз обе функции одинаково хороши, фиксируется неоднозначность.
Последнее из возможных преобразований указателя позволяет привести указатель любого типа к типу void*, поскольку void* – это родовой указатель на любой тип данных. Вот несколько примеров:

#include <string>
extern void reset( void * );

void func( int *pi, string *ps ) {
  // ...
  reset( pi ); // преобразование указателя: int* в void*
  /// ...
  reset( ps ); // преобразование указателя: string* в void*
}

Только указатели на типы данных могут быть приведены к типу void* с помощью стандартного преобразования, с указателями на функции так поступать нельзя:

typedef int (*PFV)();
extern PFV testCases[10]; // массив указателей на функции

extern void reset( void * );

int main() {
  // ...
  reset( textCases[0] ); // ошибка: нет стандартного преобразования
  // между int(*)() и void*
  return 0;
}

9.3.4. Ссылки

Фактический аргумент или формальный параметр функции могут быть ссылками. Как это влияет на правила преобразования типов?
Рассмотрим, что происходит, когда ссылкой является фактический аргумент. Его тип никогда не бывает ссылочным. Аргумент-ссылка трактуется как l-значение, тип которого совпадает с типом соответствующего объекта:

int i;
int& ri = i;
void print( int );

int main() {
  print( i ); // аргумент - это lvalue типа int
  print( ri ); // то же самое
  return 0;
}

Фактический аргумент в обоих вызовах имеет тип int. Использование ссылки для его передачи во втором вызове не влияет на сам тип аргумента.
Стандартные преобразования и расширения типов, рассматриваемые компилятором, одинаковы для случаев, когда фактический аргумент является ссылкой на тип T и когда он сам имеет такой тип. Например:

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;
      }

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

      int obj;
      void frd( double & );
      int main() {
           frd( obj ); // ошибка: параметр должен иметь иметь тип const double &
           return 0;
      }

    * Вызов функции frd() является ошибкой. Фактический аргумент имеет тип int и должен быть преобразован в тип double, чтобы соответствовать формальному параметру-ссылке. Результатом такой трансформации является временная переменная. Поскольку ссылка не имеет спецификатора const, то для ее инициализации такие переменные использовать нельзя.
      Вот еще один пример, в котором между формальным параметром-ссылкой и фактическим аргументом нет соответствия:
    *

      class B;
      void takeB( B& );
      B giveB();
      int main() {
          takeB( giveB() ); // ошибка: параметр должен быть типа const B &
          return 0;
      }

      Вызов функции takeB() – ошибка. Фактический аргумент – это возвращаемое значение, т.е. временная переменная, которая не может быть использована для инициализации ссылки без спецификатора const.
      В обоих случаях мы видим, что если формальный параметр-ссылка имеет спецификатор const, то между ним и фактическим аргументом может быть установлено точное соответствие.

Следует отметить, что и преобразование l-значения в r-значение, и инициализация ссылки считаются точными соответствиями. В данном примере первый вызов функции приводит к ошибке:

void print( int );
void print( int& );

int iobj;
int &ri = iobj;

int main() {
  print( iobj ); // ошибка: неоднозначность
  print( ri ); // ошибка: неоднозначность
  print( 86 ); // правильно: вызывается print( int )
  return 0;
}

Объект iobj – это аргумент, для которого может быть установлено соответствие с обеими функциями print(), то есть вызов неоднозначен. То же относится и к следующей строке, где ссылка ri обозначает объект, соответствующий обеим функциям print(). С третьим вызовом, однако, все в порядке. Для него print(int&) не является устоявшей. Целая константа – это r-значение, так что она не может инициализировать параметр-ссылку. Единственной устоявшей функцией для вызова print(86) является print(int), поэтому она и выбирается при разрешении перегрузки.
Короче говоря, если формальный параметр представляет собой ссылку, то для фактического аргумента точное соответствие устанавливается, если он может инициализировать ссылку, и не устанавливается в противном случае.
Упражнение 9.6

Назовите два тривиальных преобразования, допустимых при установлении точного соответствия.
Упражнение 9.7

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

(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;
   set( pi ); // вызов функции

Упражнение 9.8

Какие из данных вызовов ошибочны из-за того, что не существует преобразования между типом фактического аргумента и формального параметра:

(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 <list>
   list<int> oper();
   void print( oper() ); // вызов функции

(e) void print( const int );
   int iobj;
   print( iobj ); // вызов функции

9.4. Детали разрешения перегрузки функций

В разделе 9.2 мы уже упоминали, что процесс разрешения перегрузки функций состоит из трех шагов:

   1. Установить множество функций-кандидатов для разрешения данного вызова, а также свойства списка фактических аргументов.
   2. Отобрать из множества кандидатов устоявшие функции – те, которые могут быть вызваны с данным списком фактических аргументов при учете их числа и типов.
   3. Выбрать функцию, лучше всего соответствующую вызову, подвергнув ранжированию преобразования, которые необходимо применить к фактическим аргументам, чтобы привести их в соответствие с формальными параметрами устоявшей функции.

Теперь мы готовы к тому, чтобы изучить эти шаги более детально.
9.4.1. Функции-кандидаты

Функцией-кандидатом называется функция, имеющая то же имя, что и вызванная. Кандидаты отыскиваются двумя способами:

    * объявление функции видимо в точке вызова. В следующем примере

      void f();
      void f( int );
      void f( double, double = 3.4 );
      void f( char*, char* );
      int main() {
          f( 5.6 ); // для разрешения этого вызова есть четыре кандидата
          return 0;
      }

    * все четыре функции f() удовлетворяют этому условию. Поэтому множество кандидатов содержит четыре элемента; если тип фактического аргумента объявлен внутри некоторого пространства имен, то функции-члены этого пространства, имеющие то же имя, что и вызванная функция, добавляются в множество кандидатов:

      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;
      }

Таким образом, совокупность кандидатов является объединением множества функций, видимых в точке вызова, и множества функций, объявленных в том же пространстве имен, к которому принадлежат типы фактических аргументов.
При идентификации множества перегруженных функций, видимых в точке вызова, применимы уже рассмотренные ранее правила.
Функция, объявленная во вложенной области видимости, скрывает, а не перегружает одноименную функцию во внешней области. В такой ситуации кандидатами будут только функции из во вложенной области, т.е. такие, которые не скрыты при вызове. В следующем примере функциями-кандидатами, видимыми в точке вызова, являются format(double) и format(char*):

char* format( int );
void g() {
   char *format( double );
   char* format( char* );
   format(3); // вызывается format( double )
}

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

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' );
}

Функции max(), определенные в пространстве имен libs_R_us, невидимы в точке вызова. Единственной видимой является функция max() из глобальной области; только она входит в множество функций-кандидатов и вызывается при каждом из трех обращений к func(). Мы можем воспользоваться using-объявлением, чтобы сделать видимыми функции max() из пространства имен libs_R_us. Куда поместить using-объявление? Если включить его в глобальную область видимости:

char max( char, char );
using libs_R_us::max; // using-объявление

то функции max() из libs_R_us добавляются в множество перегруженных функций, которое уже содержит max(), объявленную в глобальной области. Теперь все три функции видны внутри func() и становятся кандидатами. В этой ситуации вызовы func() разрешаются следующим образом:

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 )
}

Но что будет, если мы введем using-объявление в локальную область видимости функции func(), как показано в данном примере?

void func()
{
   // using-объявление
   using libs_R_us::max;

   // те же вызовы функций, что и выше
}

Какие из функций max() будут включены в множество кандидатов? Напомним, что using-объявления вкладываются друг в друга. При наличии такого объявления в локальной области глобальная функция max(char, char) оказывается скрытой, так что в точке вызова видны только

libs_R_us::max( int, int );
libs_R_us::max( double, double );

Они и являются кандидатами. Теперь вызовы func() разрешаются следующим образом:

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 )
}

Using-директивы также оказывают влияние на состав множества функций-кандидатов. Предположим, мы решили их использовать, чтобы сделать функции max() из пространства имен libs_R_us видимыми в func(). Если разместить следующую using-директиву в глобальной области видимости, то множество функций-кандидатов будет состоять из глобальной функции max(char, char) и функций max(int, int) и max(double, double), объявленных в libs_R_us:

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 )
}

Что будет, если поместить using-директиву в локальную область видимости, как в следующем примере?

void func()
{
   // using-директива
   using namespace libs_R_us;

   // те же вызовы функций, что и выше
}

Какие из функций max() окажутся среди кандидатов? Напомним, что using-директива делает члены пространства имен видимыми, словно они были объявлены вне этого пространства, в той точке, где такая директива помещается. В нашем примере члены libs_R_us видимы в локальной области функции func(), как будто они объявлены вне пространства – в глобальной области. Отсюда следует, что множество перегруженных функций, видимых внутри func(), то же, что и раньше, т.е. включает в себя

max( char, char );
libs_R_us::max( int, int );
libs_R_us::max( double, double );

В локальной или глобальной области видимости появляется using-директива, на разрешение вызовов функции func() не влияет:

void func()
{
   using namespace libs_R_us;
   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 )
}

Итак, множество кандидатов состоит из функций, видимых в точке вызова, включая и те, которые введены using-объявлениями и using-директивами, а также из функций, объявленных в пространствах имен, ассоциированных с типами фактических аргументов. Например:

namespace basicLib {
   int print( int );
   double print( double );
}
namespace matrixLib {
   class matrix { /* ... */ };
   void print( const maxtrix & );
}
void display()
{
   using basicLib::print;

   matrixLib::matrix mObj;
   print( mObj ); // вызывается maxtrixLib::print( const maxtrix & )
   print( 87 ); // вызывается basicLib::print( const maxtrix & )
}

Кандидатами для print(mObj) являются введенные using-объявлением внутри display() функции basicLib::print(int) и basicLib::print(double), поскольку они видимы в точке вызова. Так как фактический аргумент функции имеет тип matrixLib::matrix, то функция print(), объявленная в пространстве имен matrixLib, также будет кандидатом. Каковы функции-кандидаты для print(87)? Только basicLib::print(int) и basicLib::print(double), видимые в точке вызова. Поскольку аргумент имеет тип int, дополнительное пространство имен в поисках других кандидатов не рассматривается.
9.4.2. Устоявшие функции

Устоявшая функция относится к числу кандидатов. В списке ее формальных параметров либо то же самое число элементов, что и в списке фактических аргументов вызванной функции, либо больше. В последнем случае для дополнительных параметров задаются значения по умолчанию, иначе функцию нельзя будет вызвать с данным числом аргументов. Чтобы функция считалась устоявшей, должно существовать преобразование каждого фактического аргумента в тип соответствующего формального параметра. (Такие преобразования были рассмотрены в разделе 9.3.)
В следующем примере для вызова f(5.6) есть две устоявшие функции: f(int) и f(double).

void f();
void f( int );
void f( double );
void f( char*, char* );

int main() {
  f( 5.6 ); // 2 устоявшие функции: f( int ) и f( double )
  return 0;
}

Функция f(int) устояла, так как она имеет всего один формальный параметр, что соответствует числу фактических аргументов в вызове. Кроме того, существует стандартное преобразование аргумента типа double в int. Функция f(double) также устояла; она тоже имеет один параметр типа double, и он точно соответствует фактическому аргументу. Функции-кандидаты f() и f(char*, char*) исключены из списка устоявших, так как они не могут быть вызваны с одним аргументом.
В следующем примере единственной устоявшей функцией для вызова format(3) является format(double). Хотя кандидата format(char*) можно вызывать с одним аргументом, не существует преобразования из типа фактического аргумента int в тип формального параметра char*, а следовательно, функция не может считаться устоявшей.

char* format( int );
void g() {
   // глобальная функция format( int ) скрыта
   char* format( double );
   char* format( char* );
   format(3); // есть только одна устоявшая функция: format( double )
}

В следующем примере все три функции-кандидата оказываются устоявшими для вызова max() внутри func(). Все они могут быть вызваны с двумя аргументами. Поскольку фактические аргументы имеют тип int, они точно соответствуют формальным параметрам функции libs_R_us::max(int, int) и могут быть приведены к типам параметров функции libs_R_us::max(double, double) с помощью трансформации целых в плавающие, а также к типам параметров функции libs_R_us::max(char, char) посредством преобразования целых типов.

namespace libs_R_us {
   int max( int, int );
   double max( double, double );
}

// using-объявление
using libs_R_us::max;

char max( char, char );
void func()
{
  // все три функции max() являются устоявшими
  max( 87, 65 ); // вызывается using libs_R_us::max( int, int )
}

Обратите внимание, что функция-кандидат с несколькими параметрами исключается из числа устоявших, как только выясняется, что один из фактических аргументов не может быть приведен к типу соответствующего формального параметра, пусть даже для всех остальных аргументов такое преобразование существует. В следующем примере функция min(char *, int) исключается из множества устоявших, поскольку нет возможности трансформации типа первого аргумента int в тип соответствующего параметра char *. И это происходит несмотря на то, что второй аргумент точно соответствует второму параметру.

extern double min( double, double );
extern double min( char*, int );

void func()
{
  // одна функция-кандидат min( double, double )
  min( 87, 65 ); // вызывается min( double, double )
}

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

void print( unsigned int );
void print( char* );
void print( char );

int *ip;
class SmallInt { /* ... */ };
SmallInt si;

int main() {
  print( ip ); // ошибка: нет устоявших функций: соответствие не найдено
  print( si ); // ошибка: нет устоявших функций: соответствие не найдено
  return 0;
}

9.4.3. Наилучшая из устоявших функция

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

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

Может оказаться так, что для приведения фактического аргумента к типу соответствующего формального параметра нужно выполнить несколько преобразований. Так, в следующем примере

int arr[3];
void putValues(const int *);

int main() {
  putValues(arr); // необходимо 2 преобразования
  // массив в указатель + преобразование спецификатора
  return 0;
}

для приведения аргумента arr от типа "массив из трех int” к типу "указатель на const int” применяется последовательность преобразований:

   1. Преобразование массива в указатель, которое трансформирует массив из трех int в указатель на int.
   2. Преобразование спецификатора, которое трансформирует указатель на int в указатель на const int.

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

преобразование l-значения ->
   расширение типа или стандартное преобразование ->
      преобразование спецификаторов

Термин преобразование l-значения относится к первым трем трансформациям из категории точных соответствий, рассмотренных в разделе 9.2: преобразование l-значения в r-значение, преобразование массива в указатель и преобразование функции в указатель. Последовательность трансформаций состоит из нуля или одного преобразования l-значения, за которым следует нуль или одно расширение типа или стандартное преобразование, и наконец нуль или одно преобразование спецификаторов. Для приведения фактического аргумента к типу формального параметра может быть применено только одна трансформация каждого вида.

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

Каковы последовательности изменений фактических аргументов в следующем примере?

namespace libs_R_us {
   int max( int, int );
   double max( double, double );
}

// using-объявление
using libs_R_us::max;

void func()
{
  char c1, c2;
  max( c1, c2 ); // вызывается libs_R_us::max( int, int )
}

Аргументы в вызове функции max() имеют тип char. Последовательность преобразований аргументов при вызове функции libs_R_us::max(int,int) следующая:

1a. Так как аргументы передаются по значению, то с помощью преобразования l-значения в r-значение извлекаются значения аргументов c1 и c2.

2a. С помощью расширения типа аргументы трансформируются из char в int.
Последовательность преобразований аргументов при вызове функции libs_R_us::max(double,double) следующая:
1b. С помощью преобразования l-значения в r-значение извлекаются значения аргументов c1 и c2.

2b. Стандартное преобразование между целым и плавающим типом приводит аргументы от типа char к типу double.

Ранг первой последовательности – расширение типа (самое худшее из примененных изменений), тогда как ранг второй – стандартное преобразование. Так как расширение типа лучше, чем преобразование, то в качестве наилучшей из устоявших для данного вызова выбирается функция libs_R_us::max(int,int).
Если ранжирование последовательностей преобразований аргументов не может выявить единственной устоявшей функции, то вызов считается неоднозначным. В данном примере для обоих вызовов calc() требуется такая последовательность:

   1. Преобразование l-значения в r-значение для извлечения значений аргументов i и j.
   2. Стандартное преобразование для приведения типов фактических аргументов к типам соответствующих формальных параметров.

Поскольку нельзя сказать, какая из этих последовательностей лучше другой, вызов неоднозначен:

int i, j;
extern long calc( long, long );
extern double calc( double, double );

void jj() {
  // ошибка: неоднозначность, нет наилучшего соответствия
  calc( i, j );
}

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

void reset( int * );
void reset( const int * );

int* pi;

int main() {
  reset( pi ); // без преобразования спецификаторов лучше:
  // выбирается reset( int * )
  return 0;
}

Последовательность стандартных преобразований, примененная к фактическому аргументу для первой функции-кандидата reset(int*), – это точное соответствие, требуется лишь переход от l-значения к r-значению, чтобы извлечь значение аргумента. Для второй функции-кандидата reset(const int *) также применяется трансформация l-значения в r-значение, но за ней следует еще и преобразование спецификаторов для приведения результирующего значения от типа "указатель на int” к типу "указатель на const int”. Обе последовательности представляют собой точное соответствие, но неоднозначности при этом не возникает. Так как вторая последовательность отличается от первой наличием трансформации спецификаторов в конце, то последовательность без такого преобразования считается лучшей. Поэтому наилучшей из устоявших функций будет reset(int*).
Вот еще пример, в котором приведение спецификаторов влияет на то, какая последовательность будет выбрана:

int extract( void * );
int extract( const void * );

int* pi;

int main() {
extract( pi ); // выбирается extract( void * )
return 0;
}

Здесь для вызова есть две устоявших функции: extract(void*) и extract(const void*). Последовательность преобразований для функции extract(void*) состоит из трансформации l-значения в r-значение для извлечения значения аргумента, сопровождаемого стандартным преобразованием указателя: из указателя на int в указатель на void. Для функции extract(const void*) такая последовательность отличается от первой дополнительным преобразованием спецификаторов для приведения типа результата от указателя на void к указателю на const void. Поскольку последовательности различаются лишь этой трансформацией, то первая выбирается как более подходящая и, следовательно, наилучшей из устоявших будет функция extract(const void*).
Спецификаторы const и volatile влияют также на ранжирование инициализации параметров-ссылок. Если две такие инициализации отличаются только добавлением спецификатора const и volatile, то инициализация без дополнительной спецификации считается лучшей при разрешении перегрузки:

#include <vector>
void manip( vector<int> & );
void manip( const vector<int> & );

vector<int> f();
extern vector<int> vec;

int main() {
  manip( vec ); // выбирается manip( vector<int> & )
  manip( f() ); // выбирается manip( const vector<int> & )
  return 0;
}

В первом вызове инициализация ссылок для вызова любой функции является точным соответствием. Но этот вызов все же не будет неоднозначным. Так как обе инициализации одинаковы во всем, кроме наличия дополнительной спецификации const во втором случае, то инициализация без такой спецификации считается лучше, поэтому перегрузка будет разрешена в пользу устоявшей функции manip(vector<int>&).
Для второго вызова существует только одна устоявшая функция manip(const vector<int>&). Поскольку фактический аргумент является временной переменной, содержащей результат, возвращенный f(), то такой аргумент представляет собой r-значение, которое нельзя использовать для инициализации неконстантного формального параметра-ссылки функции manip(vector<int>&). Поэтому наилучшей является единственная устоявшая manip(const vector<int>&).
Разумеется, у функций может быть несколько фактических аргументов. Выбор наилучшей из устоявших должен производиться с учетом ранжирования последовательностей преобразований всех аргументов. Рассмотрим пример:

extern int ff( char*, int );
extern int ff( int, int );

int main() {
  ff( 0, 'a' ); // ff( int, int )
  return 0;
}

Функция ff(), принимающая два аргумента типа int, выбирается в качестве наилучшей из устоявших по следующим причинам:

   1. ее первый аргумент лучше. 0 дает точное соответствие с формальным параметром типа int, тогда как для установления соответствия с параметром типа char * требуется стандартное преобразование указателя;
   2. ее второй аргумент имеет тот же ранг. К аргументу 'a' типа char для установления соответствия со вторым формальным параметром любой из двух функций должна быть применена последовательность преобразований, имеющая ранг расширения типа.

Вот еще один пример:

int compute( const int&, short );
int compute( int&, double );

extern int iobj;
int main() {
  compute( iobj, 'c' ); // compute( int&, double )
  return 0;
}

Обе функции compute( const int&, short ) и compute( int&, double ) устояли. Вторая выбирается в качестве наилучшей по следующим причинам:

   1. ее первый аргумент лучше. Инициализация ссылки для первой устоявшей функции хуже потому, что она требует добавления спецификатора const, не нужного для второй функции;
   2. ее второй аргумент имеет тот же ранг. К аргументу 'c' типа char для установления соответствия со вторым формальным параметром любой из двух функций должна быть применена последовательность трансформаций, имеющая ранг стандартного преобразования.

9.4.4. Аргументы со значениями по умолчанию

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

extern void ff( int );
extern void ff( long, int = 0 );

int main() {
  ff( 2L ); // соответствует ff( long, 0 );

  ff( 0, 0 ); // соответствует ff( long, int );
  ff( 0 ); // соответствует ff( int );
  ff( 3.14 ); // ошибка: неоднозначность
}

Для первого и третьего вызовов функция ff() является устоявшей, хотя передан всего один фактический аргумент. Это обусловлено следующими причинами:

   1. для второго формального параметра есть значение по умолчанию;
   2. первый параметр типа long точно соответствует фактическому аргументу в первом вызове и может быть приведен к типу аргумента в третьем вызове за счет последовательности, имеющей ранг стандартного преобразования.

Последний вызов является неоднозначным, поскольку обе устоявших функции могут быть выбраны, если применить стандартное преобразование к первому аргументу. Функции ff(int) не отдается предпочтение только потому, что у нее один параметр.
Упражнение 9.9

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

namespace primerLib {
   void compute();
   void compute( const void * );
}

using primerLib::compute;
void compute( int );
void compute( double, double = 3.4 );
void compute( char*, char* = 0 );

int main() {
  compute( 0 );
  return 0;
}

Что будет, если using-объявление поместить внутрь main() перед вызовом compute()? Ответьте на те же вопросы.
Категория: С++ | Добавил: r2d2 (29.09.2011)
Просмотров: 633 | Рейтинг: 0.0/0
Всего комментариев: 0
Добавлять комментарии могут только зарегистрированные пользователи.
[ Регистрация | Вход ]
Born in Ussr
Залогиниться
Турниры

/j clan ussr /j clan cccp