bigpo.ru
добавить свой файл
  1 ... 4 5 6 7 8
if (n<=0) throw n;

p = new int [size = n];

/* если оператор new выполняется ошибочно, стандарт предписывает ему возбуждать исключение bad_alloc. Однако старые компиляторы просто возвращают NULL. Поэтому стандарт также рекомендует это делать в целях совместимости. */

if (!p) throw “Свободная память исчерпана”;

}

int &Vect::operator[] (int i){

if (i<0 || i>=size) throwошибочный индекс”;

return p[i];

}

void g (int k){

try {

Vect x(k);

int l, i;

l = x[10]; x[i] = 100;}

catch (int n){ cout<<”Неверный размер ”<throw;}

catch (const char *str) {cout<

}


Спецификация исключений

Мы не всегда пишем код с нуля. В библиотечных классах тоже есть исключения.

void f() throw (X,int) { ... }

Такое об’явление означает, что функция может вызывать throw X, throw int

void f() throw (X,int) { ... }

А это значит, что функция не должна возбуждать исключений совсем.

По умолчанию функция может возбуждать любое исключение. Если функция попытается возбудить исключение, которого не должна, вызывается функция unexpected(), прекращающая выполнение программы. Её также можно переопределить:

set_unexpected(handle);

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

Перегрузка функций.

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

Проблема поиска подходящей перегруженной функции (best matching) – нетривиальная задача. Для начала опишем этот алгоритм для функции одного аргумента.

  1. Поиск функции, точно совпадающей по типу параметра (точное отождествление). Если функция вызывается от параметра типа T, то может быть вызвано описание с прототипом от T, T&, const T, const T&, переопределения этих типов с помощью typedef, T[] эквивалентно T*, функция эквивалентна указателю на функцию.

  2. Если не найдено точное соответствие, то пробуем применить стандартные преобразования. На втором шаге могут сработать безопасные преобразования – целочисленное или вещественное расширение (integral/floating promotion). Тут bool, char, short, enum (знаковые или беззнаковые) преобразуются к int или unsigned, float преобразуется к double.

  3. Если не получилось выполнить шаг 2, пробуем все остальные стандартные преобразования: оставшиеся арифметические преобразования и преобразования указателей и ссылок (указатель на производный класс приводится к указателю на однозначный доступный базовый класс, любой указатель приводится к void*, 0 воспринимается как NULL).

  4. Пользовательские преобразования - рассматриваются конструкторы, которые могут быть вызваны с одним параметром. Также рассматриваются специальные функции преобразования типов.

  5. Если ничего не помогло, придётся вызывать функцию с ‘…’.

Особенности четвёртого шага:

1. Отсутствие транзитивности пользовательских преобразований. То есть, за один раз не может выполниться более одного преобразования типа.

class X { public: operator int(); ... };

class Y { public: operator X(); ... };

void f(){ Y a; int b; ...

b = a; // нельзя

}

Можно явно указать b = a.operator X().operator int();.

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

class B {

public: B (int i);

operator int();

B operator+ (int B);

};

void f(){

B l(1); ... l+1 ...

}

Возникает неоднозначность: то ли l стоит преобразовать к int с помощью определённого преобразования и складывать числа, то ли вызвать конструктор от int и складывать об’екты типа B.

3. Конструктор должен быть описан так, чтобы он допускал неявный вызов. То есть, конструктор не может быть описан как explicit.

class X { public: X(int); };

X a(1); X b = 2; // так можно

Теперь изменим обявление:

class X { public: explicit X(int); };

X a(1); // так можно

X b = 2; // так нельзя!

X с = X(2); // так можно

Зачем же нужна такая конструкция? Вспомним наш класс String.

class String { String (int n); ... };

String s1 = 10;

String s2 = ‘a’;

Этого нам не запрещает так делать. Но, если мы допишем explicit к конструктору, то такая нелогичная запись не прокатит и придётся вызывать через скобочки.

Алгоритм поиска наилучшего соответствия для вызова функции с произвольным числом параметров N:

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

  2. Ищем пересечение этих множеств. Если оно пусто, то нет подходящей функции. Если пересечение содержит 2 или более элемента, то неоднозначность. Но если там одна функция, она и обслужит вызов.

Пример.


class X { public: X (int); ... };

class Y { ... };

void f (X, int); /* 1 */

void f (X, double); /* 2 */

void f (Y, double); /* 3 */

Пусть мы вызываем f(1,5);. По первому параметру мы оставляем 1 и 2 (пользовательские преобразования), по второму – 1 (точное соответствие). Пересечение даёт первый вариант.

Теперь попробуем вызвать f(1,5.0);. По первому параметру мы оставляем 1 и 2 (пользовательские преобразования), по второму – 2 и 3 (точное соответствие). Пересечение даёт второй вариант.

Пример на *пятый шаг*.


class R { public: R (double); ... };

void f (int, R);

void f (int, ...);

void g () {

f (1, 1); // первый обработчик

f (1, “preved!”); // второй обработчик


}


Шаблоны функций.

Настало время поговорить о типовом полиморфизме. Эта идея в C++ появилась не впервые, она была реализована ещё в языка Ada.

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

Пример.

int max (int x, int y) {

<< предыдущая страница   следующая страница >>