Блоки — различия между версиями

Версия 11:00, 21 сентября 2007

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

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

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

И в том и в другом случае на помощь приходят замыкания, анонимные функции или лямбда функции, как их еще называют. Сущность такой функции в том, что она с одной стороны как бы является переменной, а с другой стороны функцией которую можно вызывать. В К++ такие функции носят название блоков. Сущность переменной блоки проявляют в том, что их можно создавать как локальные переменные, присваивать друг другу и даже передавать другим функциям в качестве параметра. Приняв такой параметр, функция может обратиться к нему, как к любой другой функции: вызывать с некоторыми параметрами и как использовать его возвращаемое значение: <source lang="kpp"> function Caller(x, y, block b) {

   return b(x, y);

} </source>

Приведем простой пример объявления блоков и их передачи в вышеописанную функцию: <source lang="kpp"> var sum = { |x, y| return x + y; }; var mul = { |x, y| return x * y; }; var s = Caller(2, 3, sum); // s = 2 + 3 = 5 var m = Caller(2, 5, mul); // m = 2 * 5 = 10 </source>

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

Применение блоков

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

Проблема заключается в том, что на этапе написания реализации алгоритма мы не имеем представления о том, какие же элементы будут храниться в массиве. Как мы отсортируем массив который может состоять из чего угодно: строк, чисел, произвольных объектов и даже самих массивов? Пришлось бы либо писать обширную реализацию некоторого метода сравнения двух элементов, который бы учитывал все возможные варианты типов элементов, либо реализовывать свою функцию сортировки на каждый из типов данных элементов: <source lang="kpp"> extend array {

   public function array SortAsNumbers();
   public function array SortAsStrings();
   public function array SortAsArrays();
   public function array SortAsCollections();

} </source>

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

Давайте взглянем на проблему шире. В сущности, все вышеописанные методы делают ровно одно и то же: некоторым из алгоритмов сортировки, они упорядочивают элементы в массиве. При этом, единственная различающаяся часть — это сама операция сравнения двух элементов. Решение напрашивается само собой — необходимо вынести эту часть из самой функции сортировки и предоставить пользователю самому обеспечить операцию сравнения. Таким образом мы получим ОДИН метод сортировки, который будет работать для ЛЮБЫХ типов элементов — программист-пользователь сам укажет необходимый критерий сортировки, который уже будет использован внутри метода.

Эту задачу можно очень красиво решить с помощью блоков: <source lang="kpp"> extend array {

   public const function array sort(block cmp) {
       if (empty())
           return [ ];
       var array left, array right;
       for (var i = 1; i < size(); ++i)
           cmp(this[i], this[0]) ? left.push(this[i]) : right.push(this[i]);
       return left.sort(cmp) + [ this[0] ] + right.sort(cmp);
   }

} </source>

В качестве параметра, метод sort() принимает один аргумент — блок, который должен производить сравнение двух элементов и возвращать истину, если требуется их перестановка, то есть они расположены в неправильном порядке.

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

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

<source lang="kpp"> var array sorted, ary = [2, 7, 3, 0, 1, 5, 8, 9, 4, 6]; sorted = ary.sort() { |x, y| x < y; }; // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] sorted = ary.sort() { |x, y| x > y; }; // [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

ary = ['q', 'e', 'b', 'z', 'a', 'x', 't']; sorted = ary.sort() { |x, y| x < y; }; // ['a', 'b', 'e', 'q', 't', 'x', 'z'] sorted = ary.sort() { |x, y| x > y; }; // ['z', 'x', 't', 'q', 'e', 'b', 'a'] </source>

Мы объявляем две переменных-массива ary и sorted. Переменная ary инициализируется массивом произвольных чисел, либо строк во втором случае. Затем выполняются вызовы метода sort(), результат выполнения которых сохраняется в переменной sorted.

Примечание: Для сокращения записи, в вышеописанном коде были применены т. н. встроенные блоки (inline). К++ Поддерживает специальный синтаксис для передачи встроенных блоков в функции. Подробнее об этом будет написано чуть ниже.

Отличие от функций

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

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

Типизация параметров

Встроенные блоки