Лекции по СП, страница 6

set_terminate(handler);

Перевозбуждение исключений

try { throw x; }

catch (___) { throw; }

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

Пример.

class Vect {

int *p, size;

public:

Vect (int n = 10);

Vect (const Vect &a);

~Vect();

int &operator[] (int i);

};

/* перегрузка операции индексирования возможна только с помощью нестатической функции-члена от целой переменной, возвращающей ссылку, чтобы можно было менять элементы */

Vect::Vect (int n){

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<<”Неверный размер ”<<n<<endl; throw;}

catch (const char *str) {cout<<str<<endl; }

}

// предполагается, что функция, вызывающая g(), способна

// корректно обработать исключение типа int

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

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

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

Такая спецификация означает, что функция может вызывать throw X, throw int (на самом деле, может и throw Y, если X – однозначный доступный базовый класс для Y; то же справедливо и для указателей)

void f() throw () { ... }

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

По умолчанию функция может возбуждать любое исключение. Если функция попытается возбудить исключение, которого возбуждать не должна (контроль осуществляется исключительно во время работы программы!), вызывается функция 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. Пользовательские преобразования - рассматриваются конструкторы, которые могут быть вызваны с одним параметром. Также рассматриваются специальные функции преобразования типов. При выполнении пользовательского преобразования можно сделать еще одно (!) преобразование, но только с шага 2 или 3.

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

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

Рассмотрим ряд примеров.

Пример на 2-й шаг:

void f(int);

void f(double);

void g() {

short a=1;

float ff=1.0;

f(a); // f(int) // 2-й шаг

f(ff); // f(double) // 2-й шаг

}

Пример на 3-й шаг:

void f(char);

void f(double);

void g() {

f(1); // ошибка: неоднозначность

(две возможности на 3-м шаге)

}

Пример на 4-й шаг:

struct S{

S(long); // long -> S

operator int(); // S -> int

};

void f(long);

void f(char *);

void g(S);

void g(char *);

void ex(S &a){

f(a); // f((long)(a.operator int()))

g(1); // g(S((long)(1))

g(0); // g((char *)0) – 3-й шаг!

}

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

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; // выделится память под строку из 10 символов

String s2 = ‘a’; // неужели мы хотим выделить память

// под строку из код('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) { return x>y? x: y; }

Сделаем теперь функцию независимой от типов.

template<class T> T max (T x, T y) { return x>y? x: y; }

У этой функции только типовые параметры. Ключевое слово class не значит, что T должен быть пользовательским типом. Можно передавать данные встроенных типов точно также. (Создатели языка опять не придумали нового ключевого слова)

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

void f() {

max (1,2);

/* по параметру автоматически определяется тип шаблона.

вызовется int max<int> (1,2) */

max (‘0’,’a’); // от char

max (‘a’,100); // неоднозначность. так нельзя!!

max (2.5,1); // неоднозначность. int или double ???

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

• явная квалификация: max<int> (‘a’,100);

• перегрузка шаблонных функций:

int max (char c, int i) { return c>i? c: i; }

Можно перегрузить шаблон и так:

int max (int x, int y) { return x>y? x: y; }

Теперь нам непонятно, что вызывать: шаблонную функцию или явную? Модифицируем наш алгоритм поиска best matching функции, добавив шаг между 1 и 2. На первом шаге, не думая о шаблонах, ищем точное соответствие. На новом, *полуторном* шаге, пытаемся сгенерировать подходящую функцию по шаблону, чтобы получить точное соответствие. Если попытка неудачная, переходим к шагу 2 и далее выполняем алгоритм, как и раньше.

Тип параметра шаблона, как указано выше, можно указать и явно. Эта возможность относительно новая в языке. Об этом пишет Бьярн Страуструп в интереснейшей книге ‘Дизайн и эволюция языка C++’. В некоторых ситуациях не обойтись без явного указания.