устранить с помощью обработки ошибок и систематического тестирования. Кроме того, если мы продолжаем создавать все более хорошие компоненты, то из них можно создавать все большие части системы, сокращая долю необходимого “беспорядочного специального” кода.
Тестирование является существенной частью разработки программного обеспечения. Более подробно оно обсуждается в главе 26. Тестирование — это систематический поиск ошибок. Тестируйте как можно раньше и как можно чаще. Например, мы пытаемся разрабатывать наши программы так, чтобы упростить тестирование и помешать ошибкам скрыться в запутанном коде.
22.1.2.3. Непосредственное выражение идей
Когда мы выражаем какую-то идею — высоко- или низкоуровневую, — желательно выразить ее непосредственно в коде, а не устранять проблему обходным путем. Основной принцип выражения идей непосредственно в коде имеет несколько специфических вариантов.
• Выражение идей непосредственно в коде. Например, аргумент лучше представлять с помощью специального типа (например, Month или Color), а не общего (например, int).
• Независимое представление в коде независимых идей. Например, за некоторым исключением, стандартная функция sort() может упорядочивать любой стандартный контейнер любого элементарного типа; концепции сортировки, критерии сортировки контейнера и элементарный тип являются независимыми понятиями. Если бы мы должны были создать вектор объектов, расположенных в свободной памяти, элементы которого относятся к классу, выведенному из класса Object с функцией-членом before(), определенной для вызова из функции vector::sort(), то должны были бы иметь более узкую версию функции sort(), поскольку сделали предположения о хранении, иерархии классов, доступных функциях-членах, порядке и т.д.
• Представление отношений между идеями непосредственно в коде. Наиболее общими отношениями, которые можно непосредственно выразить в коде, являются наследование (например, класс Circle является разновидностью класса Shape) и параметризация (например, класс vector<T> выражает нечто общее для всех векторов независимо от типа элементов).
• Свободное сочетание идей, выраженных в коде, там и только там, где такая комбинация имеет смысл. Например, функция sort() позволяет использовать разные типы элементов и виды контейнеров, но эти элементы должны поддерживать операцию < (если нет, то следует использовать функцию sort() с дополнительным аргументом, задающим критерий сравнения), а контейнеры, которые мы собираемся упорядочивать, должны поддерживать итераторы с произвольным доступом.
• Простое выражение простых идей. Следование принципам, сформулированным выше, может привести к созданию кода, носящего слишком общий характер. Например, мы можем столкнуться с иерархией классов с более сложной таксономией (структурой наследования), чем требуется, или с семью параметрами для каждого (очевидно) простого класса. Для того чтобы избежать возможных осложнений, мы пытаемся создавать простые версии для наиболее распространенных или наиболее важных ситуаций. Например, кроме общей версии функции sort(b,e,op), сортирующей элементы с помощью оператора op, существует вариант sort(b,e), выполняющий неявную сортировку с помощью отношения “меньше”. Если бы мы могли (или имели возможность использовать язык C++0x; см. раздел 22.2.6), то предусмотрели бы также версию sort(c) для сортировки стандартного контейнера с помощью отношения “меньше” и функцию sort(c,op) для сортировки стандартного контейнера с помощью оператора op.
22.1.2.4. Уровень абстракции
Мы предпочитаем работать на максимально возможном уровне абстракции, иначе говоря, стремимся выражать свои решения в как можно более общем виде.
Рассмотрим, например, как представлены записи в телефонной книге, которая может храниться в вашем мобильном телефоне. Мы могли бы представить множество пар (имя, значение) с помощью класса vector<pair<string,Value_type>>. Однако если мы почти всегда обращаемся к этому множеству для поиска имени, то более высокий уровень абстракции обеспечит нам класс map<string,Value_type>. Это позволит не писать (и отлаживать) функции доступа к записям. С другой стороны, класс vector<pair<string,Value_type>> сам по себе находится на более высоком уровне абстракции, чем два массива, string[max] и Value_type[max], где отношение между строкой и значением носит неявный характер. На самом низком уровне абстракции могло бы находиться сочетание типа int (количество элементов) и двух указателей void* (ссылающихся на какую-то форму записи, известную программисту, но не компилятору). В нашем примере каждое из предложенных решений можно отнести к низкому уровню абстракции, поскольку в каждом из них основное внимание сосредоточено на представлении пар значений, а не на их функциях. Для того чтобы приблизиться к реальному приложению, следует определить класс, который непосредственно отражает способ его использования. Например, мы могли бы написать код приложения, используя класс Phonebook с удобным интерфейсом. Класс Phonebook можно было бы реализовать с помощью одного из описанных выше представлений данных.
Причина, по которой мы предпочитаем оставаться на высоком уровне абстракции (если в нашем распоряжении есть соответствующий механизм абстракций и наш язык поддерживает его на приемлемом уровне эффективности), заключается в том, что такие формулировки ближе к нашим размышлениям о задаче и ее решениях, чем решения, выраженные в терминах аппаратного обеспечения компьютера.
Как правило, основной причиной перехода на низкий уровень абстракции называют эффективность. Однако это следует делать только в случае реальной необходимости (раздел 25.2.2). Использование низкоуровневых (более примитивных) языковых свойств не всегда повышает производительность программы. Иногда оно исключает возможности оптимизации. Например, используя класс Phonebook, можем выбрать способ его реализации, например, в виде сочетания массивов string[max] и Value_type[max] или в виде класса map<string,Value_type>. Для одних приложений более эффективным оказывается первый вариант, а для других — второй. Естественно, производительность не является основным фактором, если вы пишете программу для хранения записей из своей телефонной книжки. Но оно становится существенным, если необходимо хранить и обрабатывать миллионы записей. Что еще важнее, использование низкоуровневых средств сопряжено с затратами рабочего времени, которого программисту не хватит на усовершенствование (повышение производительности или чего-то другого).
22.1.2.5. Модульность
Модульность — это принцип. Мы хотим составлять наши системы из компонентов (функций, классов, иерархий классов, библиотек и т.д.), которые можно создавать, анализировать и тестировать по отдельности. В идеале нам также хотелось бы проектировать и реализовывать такие компоненты таким образом, чтобы их можно было использовать в нескольких программах (повторно). Повторное использование (reuse) — это создание систем из ранее протестированных компонентов, которые уже были использованы где-то, а также проектирование и применение таких компонентов. Мы уже касались этой темы, обсуждая классы, иерархии классов, проектирование интерфейсов и обобщенное программирование. Большинство из того, что мы говорили о стилях программирования
