Классы и объекты

История развития ООП

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

Возникновение языков программирования

На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.

Появление ассемблера

Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как язык общения человека и ЭВМ. Так появился первый язык программирования — язык ассемблера. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа транслятор, которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.

Концепция языка высокого уровня

...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами.

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

Структурное программирование

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

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

Объектно-ориентированное программирование

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

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

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

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

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

Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого).

Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом int (целое число) и некоторым пользовательским классом MyWeirdClass: везде, где можно использовать int, можно использовать MyWeirdClass и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса int, равно как ничто не мешает определить математические операторы для класса MyWeirdClass и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!

Понятие класса

Что такое класс проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды, растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем яблоки как понятие, мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. С черенком, на котором остался листик, и маленькой червоточинкой".

Разница заключается в том, что когда вы говорили о яблоках, вы описывали свое представление яблок, как класса объектов. Когда вы описывали яблоко, то вы имели в виду конкретный экземпляр, или объект. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода.

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

Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.

Из примеров выше мы смогли уяснить следующее:

• Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов
• Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности
• Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными

Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:

С точки зрения языка, класс представляет собой набор следующих элементов:

• полей, т.е. переменных, хранящих индивидуальные особенности объектов,
• методов, т.е. функций, определяющих поведение данного объекта;
• свойств, определяющих взаимодействие других объектов с объектами данного класса.

Поля — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом, они могут хранить свое состояние (например, показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того чтобы частично разрешить этот доступ, применяются свойства. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве lvalue).

Методы — это тот самый, связанный с данными код (вспомните историю ООП) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.

Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)

Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью спецификаторов доступа:

• private — Частная собственность! Видимость только внутри методов данного класса
• protected — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов
• public — видимость и доступ для всех

Примечание: По умолчанию методы имеют видимость private, в то время как свойства — public.

Приведем, наконец, пример объявления класса:

<source lang="kpp" line="1"> class MyWeirdClass {

   var m_x = 0;  // поле m_x, изначально проинициализированное нулем
   const m_y = 1; // поле-константа m_y

   // методы класса
   public const function int get_mul() { return m_x * m_y; }
   public function void set_mul(int x) { m_x = x / m_y; }

   // свойство класса
   public property mul read get_mul write set_mul;

} </source>

1

Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово class начинает объявление класса. Далее за ним следует идентификатор имени класса, после чего идет тело класса.

3-4

Здесь мы видим объявление двух полей класса — переменной m_x и константы m_y, которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе Константы.

7-8

Для доступа к состоянию объекта, определены два метода: аксессор get_mul() и мутатор set_mul(). Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.

11

Завершается объявление класса объявлением свойства mul, которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызван аксессор, а результат его выполнения будет возвращен в качестве значения свойства. И, наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том, чтобы оно было "доставлено по адресу".

Примечание: Зачем нужны такие сложности, и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.

Понятие объекта

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

Для создания объекта того или иного класса служит оператор new: <source lang="kpp">

   var myWeirdObject = new MyWeirdClass;

</source>

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

Наследование

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

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

Для задания наследования, в объявлении класса следует указать ключевое слово extends, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:

<source lang="kpp" line="1"> // коробка class Box {

   // из чего сделана коробка?
   public const function string material() { return "Картон"; }

   // что в коробке?
   public const function string contents() { return "Пусто"; }

}

// коробка с картошкой class BoxWithPotatoes extends Box {

   public const function string contents() { return "Картошка"; }

}

function OutputBox(const Box b) {

   print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");

}

export function main() {

   var b1 = new Box;
   var b2 = new BoxWithPotatoes;
   OutputBox(b1); // Материал: Картон, содержит: Пусто
   OutputBox(b2); // Материал: Картон, содержит: Картошка

} </source>

2-8

В этом примере мы создаем класс Box, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как материал и содержимое.

11-13

Далее мы определяем класс BoxWithPotatoes (коробка с картошкой), который наследуется от класса Box, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется перекрытием) собственным методом.

15-17

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

19-24

Объявляется функция main(), внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра b1 и b2 классов Box и BoxWithPotatoes соответственно. А затем, вызываем вышеописанную функцию OutputBox(), которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает, как это все работает.

Примечание: при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако его можно обойти с помощью создания классов-оберток для системного класса, с последующим наследованием от него нового класса.

Методы

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

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

• private, protected или public — определяют область видимости метода
• static — указывает, что метод является статическим (см. ниже)
• const — метод не изменяет объект
• function, operator или constructor указывает, что объявляется: метод, оператор или конструктор (см. ниже)
• const — метод возвращает результат, который нельзя изменять

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

В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в нижеприведенном коде, метод F2() вызывает метод F1() для того же объекта: <source lang="kpp" line="1"> class MyClass {

   public const function string F1() { return "smth"; }
   public const function string F2() { return F1(); }

} </source>

Статические методы

Статический метод класса — это метод, относящийся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.

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

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

Пример: <source lang="kpp"> class MyClass {

   public static function string Info() { return "Я MyClass!"; }

}

function f() {

   // Вызов статического метода:
   var myClassInfo = MyClass.Info();

} </source>

Конструкторы

Внимание: информация в этом разделе устарела. Необходимо обновление

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

Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код, относящийся к созданию инстанции класса. Итак, конструктор класса — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.

Таким образом, следующие объявления в рамках класса эквивалентны: <source lang="kpp"> public constructor Create(); public static MyClass Create(); </source>

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

В качестве примера приведем пример реализации некоторого абстрактного класса MyStream, использующего системную реализацию класса stream, и определяющую собственный конструктор:

<source lang="kpp" line="1"> class MyStream {

   var string m_URL;
   var stream m_Stream;

public:

   static const MODE_READ = 1;
   static const MODE_WRITE = 2;
   constructor open(const string url, int mode) {
       var self = new MyStream;
       self.m_Stream.open(url, mode);
       self.m_URL = url;
       return self;
   }
   // прочие методы (опущены для краткости)

} </source>

2-3

Объявляются поля m_URL и m_Stream нашего класса, которые будут инициализироваться в конструкторе.

5-6

В публичной области класса объявляются статические константы MODE_READ и MODE_WRITE, которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.

7

Объявляется конструктор open(), принимающий в качестве параметров URL ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию self нашего класса. Затем производится попытка открытия потока m_Stream: если операция пройдет успешно, то происходит инициализация оставшегося поля m_URL и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано исключение и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).

Использовать наш класс можно примерно так: <source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source>

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

Абстрактные методы

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

Можно возразить следующее: зачем объявлять прототипы методов, если это не критично для языка? Ведь К++ Не является строго типированным, соответственно необходимость последующей реализации метода можно просто оставить на совести программиста...

На самом деле это не совсем так. Декларация абстрактного метода помогает вылавливать некоторые ошибки и делает интерфейс класса более четким.

Во-первых, при использовании такого метода в абстрактных алгоритмах базового класса, компилятор имеет возможность проверять правильность вызова метода и выполнять автоматическое преобразование типов, если это необходимо.

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

Наконец, объявление абстрактного метода в базовом классе, позволяет автоматически генерировать особый тип исключения: EAbstractError. Оно возникает в случае, если была произведена попытка вызова метода объявленного абстрактным в базовом классе но не реализованом в используемом потомке. В таком случае сразу ясно, где кроется ошибка. Если бы объявления не было, то возникло бы обычное исключение о том что метод не найден.

Примечание: Использование абстрактных методов особенно удобно при реализации примесей. Приведем пример стандартной примеси примесь Enumerable:

<source lang="kpp"> class Enumerable { public:

   abstract const function each(block b);
   abstract const function int compare(const x);

   const function bool all(block b = identity_block) {
       var result = true;
       this.each() { |...|
           if (!b.invoke(args())) {
               result = false;
               break;
           }
       };
       return result;
   }
   
   // (Другие методы примеси)

} </source>

Примесь Enumerable предоставляет классам коллекций несколько методов для итерации по элементам, выбору, поиску и возможности сортировки. Класс испольщующий примесь должен объявить у себя метод each(), который вызывает переданный блок последовательно передавая ему элементы коллекции. Если требуется использовать методы Enumerable::max, min или алгоритм сортировки, то необходимо также реализовать соответствующий метод compare(). Примеси эффективны там, где много различных классов могут реализовывать похожее поведение, однако наследовать их все от некотрого общего базового класса нерационально. В некотором роде, примесь это своеобразный "недокласс", экземпляры которого не является полностью самостоятельными сущностями, но поведение методов примеси в рамках другого класса может быть разумным. Так, напирмер вышеописанная примесь Enumerable предоставляет большое количество методов для работы с коллекциями (обработки элементов), однако она понятия не имеет, о каких именно элементах идет речь. Примесь не располагает механизмом сохранения и выборки элементов, предполагая что эта функциональность будет получена в результате "симбиоза" с классом, включающим данную примесь.

В данном случае мы видим, что примесь явным образом объявляет абстрактные методы each() и compare(). Эти два метода -- единственная внешняя зависимость примеси от класса, ее использующего.

Таким образом, мы можем использовать примесь в любом классе, который может и не являться коллекцией. В качестве примера можно привести такой код: <source lang="kpp"> class MyClass extends Enumerable {

   public const function each(block b) {
       b("hello");
       b("to");
       b("mixin!!!");
   }

}

export function main() {

    var c = new MyClass;
    var i = 1;
    c.collect() { |x| i++ to string + ' ' + x; }.each() { |x| puts(x); }

} </source>

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

1 hello
2 to
3 mixin!!!

Обратите внимание, что мы обращаемся с инстанцией нашего класса как с коллекцией -- вызываем методы collect() и итерируем по элементам так, как будто это массив. Основное преимущество примесей в том, что они позволяют писать очень гибкий код одновременно делая его максимально универсальным и годным для повторного использования.

Примечание: Метод collect() объявлен в стандартной библиотеке К++ (файл kpp.kpp).

Поля

Поле класса — это некоторый объект, используемый объектом данного класса.

Объявление поля начинается с одного из трех ключевых слов:

• var — объявление "обычного" поля;
• const — данное поле является константой и не может быть изменено;
• mutable — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.

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

<source lang="kpp"> var int m_x; const m_y = 0; var m_stream = new stream; </source>

Тип поля определяется по следующим правилам:

• если тип указан явно, ничего определять не надо;
• если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;
• в противном случае, для поля устанавливается динамический тип.

Примечание: В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать свойства (см. ниже).

Свойства

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

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

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

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

<source lang="cpp"> class MyDevice {

   int GetState();

}; </source>

Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:

<source lang="cpp"> int current_state = Device.GetState(); </source>

В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++:

<source lang="kpp"> class MyDevice {

   function int GetState();
   property int state read GetState;

} </source>

Соответственно, обращение к свойству состояния будет выглядеть так:

<source lang="kpp"> var current_state = Device.state; </source>

При обращении к свойству state будет автоматически вызван метод GetState(), результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:

<source lang="cpp"> Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus()); printf("object %s (%d) located at %s : status changed to %u",

   Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());

</source>

<source lang="kpp"> Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status; puts("object % (%) located at % : status changed to %",

   Object1.name, Object1.index, Object1.location, Object1.status);

</source>

В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находиться в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по-разному обрабатывать и отрисовывать этот элемент управления.

В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение, так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:

<source lang="kpp" line="1"> class Widget {

   var m_Enabled = true; //поле, хранящее текущее состояние активности
   function void SetEnabled(const value) {
       var old_value = m_Enabled;
       m_Enabled = value;
       if (old_value != m_Enabled)
           Invalidate(); //Состояние изменилось, обновляем элемент управления
   }
   property enabled read m_Enabled write SetEnabled;
   //далее идет остальная часть класса, например методы отрисовки

} </source>

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

<source lang="kpp"> var myForm = new Form; //создаем окно var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку myButton.caption = "Click me!"; //устанавливаем подпись myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события myForm.Show(); //показываем окно </source>

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

---

В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова property, после которого идет идентификатор типа свойства. Тип может быть опущен, тогда для свойства будет определен динамический тип. Затем указывается идентификатор имени свойства.

Оставшаяся часть зависит от того, какое свойство объявляется:

• Если объявляется свойство на чтение, то указывается ключевое слово read, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как аксессор. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.
• Если объявляется свойство на запись, то указывается, соответственно ключевое слово write после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как мутатор. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.
• Если объявляется свойство, доступное как на чтение, так и на запись, то указываются обе части, причем первой идет часть чтения.

Примечание: Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция приведения типов. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.

Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки: <source lang="kpp"> property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>]; </source>

Примечание 2: Существует альтернативный синтаксис описания аксессоров и мутаторов, при котором код соответствующий им записывается прямо в определении самого свойства. Это выглядит так:

<source lang="kpp"> class MyClass {

   var f = 1;
   property int read { f + 1; } write { |v| f = v; };

} </source>

И аксессор и мутатор, представлены здесь в виде inline конструкций, схожих по описанию (и смыслу) с inline блоками. Аксессор возвращает значение поля f, увеличенное на единицу, в то время как мутатор принимает некоторое значение v и записывает его в соответствующее поле без каких либо изменений.

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

Расширения

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

Как правило, расширения применяются к классам стандартной библиотеки, либо к неуправляемым классам.

В качестве примера приведем код, расширяющий функциональность класса int с помощью свойства factorial. Расширения объявляются путем указания ключевого слова extend, после которого указывается идентификатор имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:

<source lang="kpp" line="1"> package intmod_fact;

extend int {

   const function int GetFactorial() {
       var result = 1;
       for (var x = this; x > 1; x--)
           result *= x;
       return result;
   }
   property int factorial read GetFactorial;

}

export function main() {

   puts("Factorial of 10 is " + 10.factorial);

} </source>

3-11

Мы объявляем расширение класса int, реализованного в стандартной библиотеке. Добавляется частный метод GetFactorial(), и свойство factorial, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная this имеет тип int и ссылается на сам объект. Таким образом, для числа 10 переменная this будет равна 10.

14

Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в константный объект класса int, который подобно любому другому объекту этого же класса будет иметь свойство factorial, которое мы и используем. При попытке чтения из этого свойства будет вызван метод GetFactorial(), результат выполнения которого возвращается как значение свойства, то есть как факториал числа.

Обратите внимание, что функция puts(), принимает в качестве параметра строку, в то время как тип свойства определен как int. В этом нет ничего странного, потому что класс int имеет оператор приведения типа к классу string, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала приводится к типу строки, которая складываясь со строкой слева от оператора +, передается в качестве параметра функции.

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