Программирование на C / C++ / Ален И. Голуб. Правила программирования на Си и Си++ [pdf]
.pdfС++ для начинающих |
62 |
try {
pstats[0] = sum_it (ia,size); pstats[1] = min_val (ia,size); pstats[2] = max_val (ia,size);
}
catch (string exceptionMsg) { // код обработчика
}
catch (const statsException &statsExcp) { // код обработчика
}
pstats [3] = pstats[0] / size; do_something (pstats);
return pstats;
}
В данном примере в теле функции stats() три оператора заключены в try-блок, а четыре – нет. Из этих четырех операторов два способны возбудить исключения.
1) int *pstats = new int [4];
Выполнение оператора new может окончиться неудачей. Стандартная библиотека С++
предусматривает возбуждение исключения bad_alloc в случае невозможности выделить нужное количество памяти. Поскольку в примере не предусмотрен обработчик исключения bad_alloc, при его возбуждении выполнение программы закончится аварийно.
2) do_something (pstats);
Мы не знаем реализации функции do_something(). Любая инструкция этой функции, или функции, вызванной из этой функции, или функции, вызванной из функции, вызванной этой функцией, и так далее, потенциально может возбудить исключение. Если
в реализации функции do_something и вызываемых из нее предусмотрен обработчик такого исключения, то выполнение stats() продолжится обычным образом. Если же такого обработчика нет, выполнение программы аварийно завершится.
Необходимо заметить, что, хотя оператор
pstats [3] = pstats[0] / size;
может привести к делению на ноль, в стандартной библиотеке не предусмотрен такой тип исключения.
Обратимся теперь к инструкциям, объединенным в try-блок. Если в одной из вызываемых в этом блоке функций – sum_it(), min_val() или max_val() –произойдет исключение, управление будет передано на обработчик, следующий за try-блоком и перехватывающий именно это исключение. Ни инструкция, возбудившая исключение, ни следующие за ней инструкции в try-блоке выполнены не будут. Представим себе, что при вызове функции sum_it() возбуждено исключение:
throw string ("Ошибка: adump27832");
Выполнение функции sum_it() прервется, операторы, следующие в try-блоке за вызовом этой функции, также не будут выполнены, и pstats[0] не будет инициализирована. Вместо этого возбуждается исключительное состояние и исследуются два catch-обработчика. В нашем случае выполняется catch с параметром типа string:
С++ для начинающих |
63 |
catch (string exceptionMsg) { // код обработчика
}
После выполнения управление будет передано инструкции, следующей за последним catch-обработчиком, относящимся к данному try-блоку. В нашем случае это
pstats [3] = pstats[0] / size;
(Конечно, обработчик сам может возбуждать исключения, в том числе – того же типа. В такой ситуации будет продолжено выполнение catch-предложений, определенных в программе, вызвавшей функцию stats().)
catch (string exceptionMsg) {
Вот пример:
// код обработчика
cerr << "stats(): исключение: "
<<exceptionMsg
<<endl; delete [] pstats;
return 0;
}
В таком случае выполнение вернется в функцию, вызвавшую stats(). Будем считать,
что разработчик программы предусмотрел проверку возвращаемого функцией stats() значения и корректную реакцию на нулевое значение.
Функция stats() умеет реагировать на два типа исключений: string и statsException. Исключение любого другого типа игнорируется, и управление передается в вызвавшую функцию, а если и в ней не найдется обработчика, – то в функцию более высокого уровня, и так до функции main().При отсутствии обработчика и там, программа аварийно завершится.
Возможно задание специального обработчика, который реагирует на любой тип
catch (...) {
//обрабатывает любое исключение,
//однако ему недоступен объект, переданный
//в обработчик в инструкции throw
исключения. Синтаксис его таков:
}
(Детально обработка исключительных ситуаций рассматривается в главах 11 и 19.) Упражнение 2.18
Какие ошибочные ситуации могут возникнуть во время выполнения следующей функции:
int *alloc_and_init (string file_name)
{
ifstream infile (file_name)
С++ для начинающих |
64 |
int elem_cnt; infile >> elem_cnt;
int *pi = allocate_array(elem_cnt);
int elem; int index=0;
while (cin >> elem) pi[index++] = elem;
sort_array(pi,elem_cnt); register_data(pi);
return pi;
}
Упражнение 2.19
В предыдущем примере вызываемые функции allocate_array(), sort_array() и register_data() могут возбуждать исключения типов noMem, int и string соответственно. Перепишите функцию alloc_and_init(), вставив соответствующие блоки try и catch для обработки этих исключений. Пусть обработчики просто выводят в cerr сообщение об ошибке.
Упражнение 2.20
Усовершенствуйте функцию alloc_and_init() так, чтобы она сама возбуждала исключение в случае возникновения всех возможных ошибок (это могут быть исключения, относящиеся к вызываемым функциям allocate_array(), sort_array() и register_data() и какими-то еще операторами внутри функции alloc_and_init()). Пусть это исключение имеет тип string и строка, передаваемая обработчику, содержит описание ошибки.
2.7. Использование пространства имен
Предположим, что мы хотим предоставить в общее пользование наш класс Array, разработанный в предыдущих примерах. Однако не мы одни занимались этой проблемой; возможно, кем-то где-то, скажем, в одном из подразделений компании Intel был создан одноименный класс. Из-за того что имена этих классов совпадают, потенциальные пользователи не могут задействовать оба класса одновременно, они должны выбрать один из них. Эта проблема решается добавлением к имени класса некоторой строки, идентифицирующей его разработчиков, скажем,
class Cplusplus_Primer_Third_Edition_Array { ... };
Конечно, это тоже не гарантирует уникальность имени, но с большой вероятностью избавит пользователя от данной проблемы. Как, однако, неудобно пользоваться столь длинными именами!
Стандарт С++ предлагает для решения проблемы совпадения имен механизм, называемый пространством имен. Каждый производитель программного обеспечения может заключить свои классы, функции и другие объекты в свое собственное пространство имен. Вот как выглядит, например, объявление нашего класса Array:
С++ для начинающих |
65 |
namespace Cplusplus_Primer_3E {
template <class elemType> class Array { ... };
}
Ключевое слово namespace задает пространство имен, определяющее видимость нашего класса и названное в данном случае Cplusplus_Primer_3E. Предположим, что у нас есть классы от других разработчиков, помещенные в другие пространства имен:
namespace IBM_Canada_Laboratory {
template <class elemType> class Array { ... }; class Matrix { ... };
}
namespace Disney_Feature_Animation { class Point { ... };
template <class elemType> class Array { ... };
}
По умолчанию в программе видны объекты, объявленные без явного указания пространства имен; они относятся к глобальному пространству имен. Для того чтобы обратиться к объекту из другого пространства, нужно использовать его квалифицированное имя, которое состоит из идентификатора пространства имен и идентификатора объекта, разделенных оператором разрешения области видимости (::).
Cplusplus_Primer_3E::Array<string> text;
Вот как выглядят обращения к объектам приведенных выше примеров:
IBM_Canada_Laboratory::Matrix mat; Disney_Feature_Animation::Point origin(5000,5000);
Для удобства использования можно назначать псевдонимы пространствам имен. Псевдоним выбирают коротким и легким для запоминания. Например:
// псевдонимы
namespace LIB = IBM_Canada_Laboratory; namespace DFA = Disney_Feature_Animation;
int main()
{
LIB::Array<int> ia(1024);
}
Псевдонимы употребляются и для того, чтобы скрыть использование пространств имен. Заменив псевдоним, мы можем сменить набор задействованных функций и классов, причем во всем остальном код программы останется таким же. Исправив только одну строчку в приведенном выше примере, мы получим определение уже совсем другого массива:
namespace LIB = Cplusplus_Primer_3E; int main()
{
LIB::Array<int> ia(1024);
}
С++ для начинающих |
66 |
Конечно, чтобы это стало возможным, необходимо точное совпадение интерфейсов классов и функций, объявленных в этих пространствах имен. Представим, что класс Array из Disney_Feature_Animation не имеет конструктора с одним параметром – размером. Тогда следующий код вызовет ошибку:
namespace LIB = Disney_Feature_Animation;
int main()
{
LIB::Array<int> ia(1024);
}
Еще более удобным является способ использования простого, неквалифицированного имени для обращения к объектам, определенным в некотором пространстве имен. Для этого существует директива using:
#include "IBM_Canada_Laboratory.h"
using namespace IBM_Canada_Laboratory;
int main()
{
//IBM_Canada_Laboratory::Matrix Matrix mat(4,4);
//IBM_Canada_Laboratory::Array Array<int> ia(1024);
//...
}
Пространство имен IBM_Canada_Laboratory становится видимым в программе. Можно сделать видимым не все пространство, а отдельные имена внутри него (селективная директива using):
#include "IBM_Canada_Laboratory.h"
using namespace IBM_Canada_Laboratory::Matrix; // видимым становится только Matrix
int main()
{
//IBM_Canada_Laboratory::Matrix Matrix mat(4,4);
//Ошибка: IBM_Canada_Laboratory::Array невидим Array<int> ia(1024);
//...
}
Как мы уже упоминали, все компоненты стандартной библиотеки С++ объявлены внутри пространства имен std. Поэтому простого включения заголовочного файла недостаточно, чтобы напрямую пользоваться стандартными функциями и классами:
#include <string>
// ошибка: string невидим
string current_chapter = "Обзор С++";
С++ для начинающих |
67 |
|
|
Необходимо использовать директиву using: |
|
|
|
|
|
#include <string> |
|
|
using namespace std; |
|
|
// Ok: видим string |
|
|
string current_chapter = "Обзор С++"; |
|
|
|
|
Заметим, однако, что таким образом мы возвращаемся к проблеме “засорения” |
||
глобального пространства имен, ради решения которой и |
был создан механизм |
#include <string>
именованных пространств. Поэтому лучше использовать либо квалифицированное имя:
// правильно: квалифицированное имя std::string current_chapter = "Обзор С++";
либо селективную директиву using: #include <string>
using namespace std::string;
// Ok: string видим
string current_chapter = "Обзор С++";
Мы рекомендуем пользоваться последним способом.
Вбольшинстве примеров этой книги директивы пространств имен были опущены. Это сделано ради сокращения размера кода, а также потому, что большинство примеров были скомпилированы компилятором, не поддерживающим пространства имен – достаточно недавнего нововведения С++. (Детали применения using-объявлений при работе с стандартной библиотекой С++ обсуждаются в разделе 8.6.)
Внижеследующих главах мы создадим еще четыре класса: String, Stack, List и модификацию Stack. Все они будут заключены в одно пространство имен – Cplusplus_Primer_3E. (Более подробно работа с пространствами имен рассматривается в главе 8.)
Упражнение 2.21
namespace Exercize {
Дано пространство имен
template <class elemType> class Array { ... };
template <class EType>
void print (Array< EType > );
class String { ... } template <class ListType>
class List { ... };
}
и текст программы:
С++ для начинающих |
68 |
int main() {
const int size = 1024; Array<String> as (size); List<int> il (size);
// ...
Array<String> *pas = new Array<String>(as);
List<int> *pil = new List<int>(il);
print (*pas);
}
Программа не компилируется, поскольку объявления используемых классов заключены в пространство имен Exercise. Модифицируйте код программы, используя
(a)квалифицированные имена
(b)селективную директиву using
(c)механизм псевдонимов
(d)директиву using
2.8. Стандартный массив – это вектор
Хотя встроенный массив формально и обеспечивает механизм контейнера, он, как мы видели выше, не поддерживает семантику абстракции контейнера. До принятия стандарта C++ для программирования на таком уровне мы должны были либо приобрести нужный класс, либо реализовать его самостоятельно. Теперь же класс массива является частью стандартной библиотеки C++. Только называется он не массив, а вектор.
Разумеется, вектор реализован в виде шаблона класса. Так, мы можем написать
vector<int> ivec(10); vector<string> svec(10);
Есть два существенных отличия нашей реализации шаблона класса Array от реализации шаблона класса vector. Первое отличие состоит в том, что вектор поддерживает как присваивание значений существующим элементам, так и вставку дополнительных элементов, то есть динамически растет во время выполнения, если программист решил воспользоваться этой его возможностью. Второе отличие более радикально и отражает существенное изменение парадигмы проектирования. Вместо того чтобы поддержать большой набор операций-членов, применимых к вектору, таких, как sort(), min(), max(), find()и так далее, класс vector предоставляет минимальный набор: операции сравнения на равенство и на меньше, size() и empty(). Более общие операции, перечисленные выше, определены как независимые обобщенные алгоритмы.
Для использования класса vector мы должны включить соответствующий заголовочный файл.
#include <vector>
С++ для начинающих |
69 |
// разные способы создания объектов типа vector vector<int> vec0; // пустой вектор
const int size = 8; const int value = 1024;
//вектор размером 8
//каждый элемент инициализируется 0 vector<int> vec1(size);
//вектор размером 8
//каждый элемент инициализируется числом 1024 vector<int> vec2(size,value);
//вектор размером 4
//инициализируется числами из массива ia
int ia[4] = { 0, 1, 1, 2 }; vector<int> vec3(ia,ia+4);
// vec4 - копия vec2
vector<int> vec4(vec2);
Так же, как наш класс Array, класс vector поддерживает операцию доступа по индексу.
#include <vector>
Вот пример перебора всех элементов вектора: extern int getSize();
void mumble()
{
int size = getSize(); vector<int> vec(size);
for (int ix=0; ix<size; ++ix) vec[ix] = ix;
// ...
}
Для такого перебора можно также использовать итераторную пару. Итератор – это объект класса, поддерживающего абстракцию указательного типа. В шаблоне класса vector определены две функции-члена – begin() и end(), устанавливающие итератор соответственно на первый элемент вектора и на элемент, который следует за последним. Вместе эти две функции задают диапазон элементов вектора. Используя итератор,
#include <vector>
предыдущий пример можно переписать таким образом: extern int getSize();
void mumble()
{
int size = getSize(); vector<int> vec(size);
С++ для начинающих |
70 |
vector<int>::iterator iter = vec.begin();
for (int ix=0; iter!=vec.end(); ++iter, ++ix) *iter = ix;
// ...
}
Определение переменной iter
vector<int>::iterator iter = vec.begin();
инициализирует ее адресом первого элемента вектора vec. iterator определен с помощью typedef в шаблоне класса vector, содержащего элементы типа int. Операция
инкремента
++iter
перемещает итератор на следующий элемент вектора. Чтобы получить сам элемент, нужно применить операцию разыменования:
*iter
В стандартной библиотеке С++ имеется поразительно много функций, работающих с классом vector, но определенных не как функции-члены класса, а как набор обобщенных алгоритмов. Вот их неполный перечень:
алгоритмы поиска: find(), find_if(), search(), binary_search(), count(), count_if();
алгоритмы сортировки и упорядочения: sort(), partial_sort(), merge(), partition(), rotate(), reverse(), random_shuffle();
алгоритмы удаления: unique(), remove();
численные алгоритмы: accumulate(), partial_sum(), inner_product(), adjacent_difference();
алгоритмы генерации и изменения последовательности: generate(), fill(), transform(), copy(), for_each();
алгоритмы сравнения: equal(), min(), max().
В число параметров этих обобщенных алгоритмов входит итераторная пара, задающая диапазон элементов вектора, к которым применяется алгоритм. Скажем, чтобы упорядочить все элементы некоторого вектора ivec, достаточно написать следующее:
sort ( ivec.begin(), ivec.end() );
Чтобы применить алгоритм sort() только к первой половине вектора, мы напишем:
sort ( ivec.begin(), ivec.begin() + ivec.size()/2 );
Роль итераторной пары может играть и пара указателей на элементы встроенного массива. Пусть, например, нам дан массив:
С++ для начинающих |
71 |
int ia[7] = { 10, 7, 9, 5, 3, 7, 1 };
Упорядочить весь массив можно вызовом алгоритма sort():
sort ( ia, ia+7 );
Так можно упорядочить первые четыре элемента:
sort ( ia, ia+4 );
Для использования алгоритмов в программу необходимо включить заголовочный файл
#include <algorithm>
Ниже приведен пример программы, использующей разнообразные алгоритмы в применении к объекту типа vector: