http://man.deeptown.org/api.php?action=feedcontributions&feedformat=atom&user=KroTozeRDeeptown Manual - Вклад участника [ru]2026-05-31T10:32:58ZВклад участникаMediaWiki 1.20.2http://man.deeptown.org/index.php/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8BКлассы и объекты2007-10-05T11:38:46Z<p>KroTozeR: /* Расширения */</p>
<hr />
<div>__TOC__<br />
<br />
== История развития ООП ==<br />
<br />
Для того чтобы понять, что же такое классы и объекты, сперва необходимо проследить историю развития программирования. А конкретнее, историю возникновения концепции ООП. Автор верит, что знание истории возникновения тех или иных мыслей и идей может помочь читателю осознать необходимость нововведений, и главное — их преимуществ перед существовавшими в то время решениями.<br />
<br />
=== Возникновение языков программирования ===<br />
<br />
На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.<br />
<br />
=== Появление ассемблера ===<br />
<br />
Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как ''язык'' общения человека и ЭВМ. Так появился первый язык программирования — ''язык ассемблера''. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа ''транслятор'', которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.<br />
<br />
=== Концепция языка высокого уровня ===<br />
<br />
...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами. <br />
<br />
Но время шло, количество приверженцев нового подхода постоянно увеличивалось. Сами же компиляторы становились все более мощными и генерировали все более компактный и оптимальный код. Дошло до того, что компилятор с оптимизатором в некоторых случаях генерировал код, более качественный, чем это делал программист. С этого момента ЯП высокого уровня заняли свое место в истории и в инструментарии любого разработчика.<br />
<br />
=== Структурное программирование ===<br />
<br />
С развитием языков программирования появились новые концепции и новые парадигмы программирования. От линейного моноблочного программирования, при котором программа писалась единым "куском" от начала до конца, перешли к программам модульным и структурным. При них программа представляла уже совокупность процедур (функций), которые вызывали друг друга в ходе работы программы. Процедуры представляли собой подпрограммы, решающие отдельные частные задачи. При этом код получался более читаемым, и облегчалась его отладка. <br />
<br />
Опять же, в ходе усложнения решаемых задач и, вследствие этого, увеличения количества переменных с которыми приходилось работать программисту, возникла идея группировки некоторых переменных в группы или структуры. Структуры формировались по назначению и содержали в себе переменные, имеющие отношение к одной и той же сущности. Это значительно повысило читаемость программ и уменьшило количество ошибок в них.<br />
<br />
=== Объектно-ориентированное программирование ===<br />
<br />
Ну и наконец, одна светлая голова додумалась до мысли: "а что если в структурах группировать не только переменные, но и сами процедуры которые должны работать с этими переменными?". В результате получилось то, что мы сейчас называем классом — то есть, некоторая обособленная функциональная сущность, которая сама хранит свои данные, а главное сама умеет их обрабатывать. Теперь программисту не нужно помнить, какая из процедур отвечает за некоторое действие над такими-то переменными — он просто берет объект и работает с ним. Все что происходит с объектом внутри — это его личное дело.<br />
<br />
Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.<br />
<br />
При написании программы на объектно-ориентированном языке, программист строит математическую модель взаимодействия различных сущностей. Каждая из сущностей это свой мир, у которого есть свои законы и особенности. При этом сущности могут быть как конкретные, вроде "сетевой интерфейс" или "файл", так и совершенно абстрактные, например "отношение" или "ошибка". Программист описывает каждую из сущностей в отдельности, обособлено от остальных. Вся необходимая для работы информация хранится внутри, а для взаимодействия с внешним миром предусмотрен ''интерфейс'' — некоторая совокупность ''свойств'' данной сущности (отражающих ее внутреннее состояние) и способов взаимодействия с ней — ''методов''.<br />
<br />
В ходе работы программы сущности могут взаимодействовать, читая и записывая свойства и вызывая методы друг друга, использовать друг друга как подсистемы, порождать новые сущности и т. д. Получается, что при написании программы, программист переносит свое внутреннее представление того как он видит эту программу, то из чего она состоит и как отдельные ее части взаимодействуют. Теперь не приходится адаптировать свое понимание проблемы к конкретным инструментальным средствам и возможностям языка программирования (конечно, это все же происходит, но уже гораздо менее заметно).<br />
<br />
В терминах современных языков программирования такие сущности называются ''классами'', в смысле ''классами сущностей''. А отдельные представители этих классов называются ''экземплярами'', ''инстанциями'' (на английский манер) или ''объектами''. Более подробно, различие между классами и объектами будет рассмотрено ниже.<br />
<br />
<br />
Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого). <br />
<br />
Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом <tt>int</tt> (целое число) и некоторым пользовательским классом <tt>MyWeirdClass</tt>: везде, где можно использовать <tt>int</tt>, можно использовать <tt>MyWeirdClass</tt> и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса <tt>int</tt>, равно как ничто не мешает определить математические операторы для класса <tt>MyWeirdClass</tt> и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!<br />
<br />
== Понятие класса ==<br />
<br />
Что такое ''класс'' проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды, растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем ''яблоки как понятие'', мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. С черенком, на котором остался листик, и маленькой червоточинкой". <br />
<br />
Разница заключается в том, что когда вы говорили ''о яблоках'', вы описывали свое представление яблок, как ''класса'' объектов. Когда вы описывали ''яблоко'', то вы имели в виду конкретный ''экземпляр'', или ''объект''. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода. <br />
<br />
Другой пример: если вас попросить "представьте дерево", то вы либо представите некоторое совершенно абстрактное, усредненное дерево, либо попросите уточнить, какое именно дерево имеется в виду. Ваше сознание из имеющейся информации смогло уяснить только самые общие сведения о классе. Но этой информации не достаточно, для более детального описания. Это тоже важно, поскольку в этом простом примере кроется сущность механизма наследования — постепенного уточнения классами-потомками общих черт своих предков. Таким образом, и яблоня, и груша — деревья. Но яблони отличаются от груш. Получается, что классы ''яблони'' и ''груши'' имеют общего предка — класс ''дерево''.<br />
<br />
Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.<br />
<br />
<br />
Из примеров выше мы смогли уяснить следующее:<br />
<br />
* Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов<br />
* Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности<br />
* Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными<br />
<br />
Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:<br />
<br />
С точки зрения языка, ''класс'' представляет собой набор следующих элементов:<br />
* ''полей'', т.е. переменных, хранящих индивидуальные особенности объектов, <br />
* ''методов'', т.е. функций, определяющих поведение данного объекта;<br />
* ''свойств'', определяющих взаимодействие других объектов с объектами данного класса.<br />
<br />
''Поля'' — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом, они могут хранить свое состояние (например, показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того чтобы частично разрешить этот доступ, применяются ''свойства''. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве [[lvalue]]).<br />
<br />
''Методы'' — это тот самый, связанный с данными код (вспомните [[Классы и объекты#История развития ООП|историю ООП]]) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.<br />
<br />
Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)<br />
<br />
Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью [[Спецификаторы доступа|спецификаторов доступа]]:<br />
<br />
* <tt>'''private'''</tt> — Частная собственность! Видимость только внутри методов данного класса<br />
* <tt>'''protected'''</tt> — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов<br />
* <tt>'''public'''</tt> — видимость и доступ для всех<br />
<br />
'''Примечание:''' По умолчанию методы имеют видимость <tt>'''private'''</tt>, в то время как свойства — <tt>'''public'''</tt>.<br />
<br />
Приведем, наконец, пример объявления класса:<br />
<br />
<source lang="kpp" line="1"><br />
class MyWeirdClass {<br />
var m_x = 0; // поле m_x, изначально проинициализированное нулем<br />
const m_y = 1; // поле-константа m_y<br />
<br />
// методы класса<br />
public const function int get_mul() { return m_x * m_y; }<br />
public function void set_mul(int x) { m_x = x / m_y; }<br />
<br />
// свойство класса<br />
public property mul read get_mul write set_mul;<br />
}<br />
</source><br />
<br />
<br />
;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.<br />
<br />
;3-4: Здесь мы видим объявление двух полей класса — переменной ''m_x'' и константы ''m_y'', которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе [[Константы]]. <br />
<br />
;7-8: Для доступа к состоянию объекта, определены два метода: ''аксессор'' <tt>get_mul()</tt> и ''мутатор'' <tt>set_mul()</tt>. Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.<br />
<br />
;11: Завершается объявление класса объявлением свойства ''mul'', которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызван аксессор, а результат его выполнения будет возвращен в качестве значения свойства. И, наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том, чтобы оно было "доставлено по адресу".<br />
<br />
: '''Примечание:''' Зачем нужны такие сложности, и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.<br />
<br />
== Понятие объекта ==<br />
<br />
Собственно, понятие объекта уже много раз было затронуто выше по повествованию. Поэтому здесь приведем лишь небольшое определение: Под ''объектом'' подразумевается экземпляр того или иного класса, т.е. некоторая сущность, поведение которой задается соответствующим классом.<br />
<br />
Для создания объекта того или иного класса служит оператор <tt>'''new'''</tt>:<br />
<source lang="kpp"><br />
var myWeirdObject = new MyWeirdClass;<br />
</source><br />
<br />
Здесь мы видим типичную конструкцию объявления переменной, однако в инициализаторе переменной находится всего один оператор, за которым следует [[идентификатор]] имени класса, экземпляр которого мы хотим создать.<br />
<br />
== Наследование ==<br />
<br />
Под ''наследованием'' классов понимается механизм такого создания (объявления) класса, при котором он расширяет функционал одного или нескольких уже существующих классов (родителей). Вспомните пример с деревьями. Когда мы говорим, что класс ''яблоня'' наследуется от класса ''дерево'' — это значит что ''яблоня'' унаследует все свойства своего класса-родителя, некоторые из которых он может изменить, ну и дополнить своими собственными свойствами. Опыт нам подсказывает, что у любого дерева есть листья (для простоты не будем вспоминать про хвойные), однако не любое дерево плодоносит яблоками. Если же рассмотреть сами яблоки, то можно сказать, что класс ''яблоко'' унаследован от класса ''фрукт'', который определяет что фрукты (и соответственно яблоки) должны расти на деревьях.<br />
<br />
Таким образом, наследование гарантирует, что к дочерним классам применимы все операции, доступные в родительском классе: любой алгоритм, работающий с объектами родительского класса, может работать с объектами его дочерних классов. <br />
<br />
Для задания наследования, в объявлении класса следует указать ключевое слово <tt>'''extends'''</tt>, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:<br />
<br />
<source lang="kpp" line="1"><br />
// коробка<br />
class Box { <br />
// из чего сделана коробка?<br />
public const function string material() { return "Картон"; }<br />
<br />
// что в коробке?<br />
public const function string contents() { return "Пусто"; }<br />
}<br />
<br />
// коробка с картошкой<br />
class BoxWithPotatoes extends Box { <br />
public const function string contents() { return "Картошка"; }<br />
}<br />
<br />
function OutputBox(const Box b) {<br />
STDOUT.print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");<br />
}<br />
<br />
function main() {<br />
var b1 = new Box;<br />
var b2 = new BoxWithPotatoes;<br />
OutputBox(b1); // Материал: Картон, содержит: Пусто<br />
OutputBox(b2); // Материал: Картон, содержит: Картошка<br />
}<br />
</source><br />
<br />
<br />
;2-7: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.<br />
<br />
;10-12: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.<br />
<br />
;14-16: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).<br />
<br />
;18-23: Объявляется функция <tt>main()</tt>, внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра ''b1'' и ''b2'' классов <tt>Box</tt> и <tt>BoxWithPotatoes</tt> соответственно. А затем, вызываем вышеописанную функцию <tt>OutputBox()</tt>, которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает, как это все работает.<br />
<br />
'''Примечание:''' при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако его можно обойти с помощью создания [[Класс-обертка|классов-оберток]] для системного класса, с последующим наследованием от него нового класса.<br />
<br />
== Методы ==<br />
<br />
''Метод'' — это некоторый код, связанный с объектом и управляющий его поведением. Управление может заключаться в изменении переменных состояния объекта (полей), либо выполнением некоторых операций над ними.<br />
<br />
При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:<br />
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода<br />
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод не изменяет объект<br />
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять<br />
<br />
После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].<br />
<br />
Тело метода может быть объявлено как непосредственно в теле класса, так и вынесено за его пределы, например:<br />
<br />
<source lang="kpp" line="1"><br />
class MyClass {<br />
public const function string F1() { return "smth"; }<br />
public const function string F2();<br />
}<br />
<br />
function string MyClass::F2() {<br />
return F1();<br />
}<br />
</source><br />
<br />
<br />
;6: При вынесении функции за пределы класса, имя соответствующего метода предваряется именем класса, из которого он был вынесен; имена отделяются друг от друга символом "двойное двоеточие" ( <tt>::</tt> ); дополнительно — в заголовке вынесенной функции необходимо указать тип возвращаемого значения и параметры функции, все остальные ключевые слова указывать не обязательно.<br />
<br />
;7: В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в коде приведенном выше, метод <tt>F2()</tt> вызывает метод <tt>F1()</tt> для того же объекта.<br />
<br />
=== Статические методы ===<br />
<br />
''Статический метод класса'' — это метод, относящийся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.<br />
<br />
При объявлении статического метода нужно указать ключевое слово <tt>'''static'''</tt>.<br />
<br />
В теле статического метода нет возможности напрямую обращаться к другим методам данного класса, т.к. статическому методу недоступен объект класса. Фактически, единственным отличием статического метода от обычной функции является то, что такой метод может обращаться к защищенным полям и методам класса некоторого другого объекта. Подобный подход широко применяется при написании ''конструкторов'' (см. ниже).<br />
<br />
Пример:<br />
<source lang="kpp"><br />
class MyClass {<br />
public static function string Info() { return "Я MyClass!"; }<br />
}<br />
<br />
function f() {<br />
// Вызов статического метода:<br />
var myClassInfo = MyClass.Info();<br />
}<br />
</source><br />
<br />
=== Конструкторы ===<br />
<br />
В ходе написания программы часто приходится создавать новые объекты. При этом объекту требуется установить некоторое начальное состояние. Разумеется, это выполняется либо путем написания инициализаторов соответствующих полей, либо значения полям присваиваются явным образом. Но что делать, если объект может иметь несколько начальных состояний? То есть, в зависимости от некоторых условий, одним и тем же полям объекта могут быть присвоены различные наборы значений. Тут уже одними инициализаторами не обойтись. Присваивать значения можно прямо в коде программы, однако это не очень красивое решение, поскольку один и тот же объект может создаваться в нескольких местах программы и придется копировать один и тот же участок кода, инициализирующий поля объекта. Недостаток этого подхода в том, что при большом количестве полей, программист может забыть проинициализировать некаторе поле, либо при изменении условий инициализации он может изменить их только в одном месте программы, забыв, что объект может создаваться и в других местах. Более разумным является подход, при котором программист пишет функцию, инициализирующую поля объекта. При этом весь код собирается в одном месте и вероятность ошибок значительно понижается. <br />
<br />
Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код, относящийся к созданию инстанции класса. Итак, ''конструктор класса'' — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.<br />
<br />
Таким образом, следующие объявления в рамках класса эквивалентны:<br />
<source lang="kpp"><br />
public constructor Create();<br />
public static MyClass Create();<br />
</source><br />
<br />
Тело конструктора чаще всего выглядит следующим образом: сначала создается экземпляр класса при помощи оператора <tt>'''new'''</tt>, затем производятся некоторые действия, инициализующие этот объект, и, наконец, этот объект возвращается в качестве результата. <br />
<br />
В качестве примера приведем пример реализации некоторого абстрактного класса <tt>MyStream</tt>, использующего системную реализацию класса <tt>stream</tt>, и определяющую собственный конструктор:<br />
<br />
<source lang="kpp" line="1"><br />
class MyStream {<br />
var string m_URL;<br />
var stream m_Stream;<br />
public:<br />
static const MODE_READ = 1;<br />
static const MODE_WRITE = 2;<br />
constructor open(const string url, int mode) {<br />
var self = new MyStream;<br />
self.m_Stream.open(url, mode);<br />
self.m_URL = url;<br />
return self;<br />
}<br />
// прочие методы (опущены для краткости)<br />
}<br />
</source><br />
<br />
<br />
;2-3: Объявляются поля ''m_URL'' и ''m_Stream'' нашего класса, которые будут инициализироваться в конструкторе. <br />
<br />
;5-6: В публичной области класса объявляются статические константы ''MODE_READ'' и ''MODE_WRITE'', которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.<br />
<br />
;7: Объявляется конструктор <tt>open()</tt>, принимающий в качестве параметров [[URL]] ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию ''self'' нашего класса. Затем производится попытка открытия потока ''m_Stream'': если операция пройдет успешно, то происходит инициализация оставшегося поля ''m_URL'' и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано ''[[Обработка исключений|исключение]]'' и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).<br />
<br />
<br />
Использовать наш класс можно примерно так:<br />
<source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source><br />
<br />
Обратите внимание на второй параметр функции, где мы передаем константу ''MODE_READ'', объявленную внутри самого класса. Подобный подход, когда константы, используемые при работе с классом, инкапсулируются в тело класса, помогает сконцентрировать код в одном месте и избежать многих ошибок. В результате повышается читаемость кода и не возникает конфликта имен констант.<br />
<br />
== Поля ==<br />
<br />
Поле класса — это некоторый объект, используемый объектом данного класса.<br />
<br />
Объявление поля начинается с одного из трех ключевых слов:<br />
* <tt>'''var'''</tt> — объявление "обычного" поля;<br />
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;<br />
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.<br />
<br />
За ключевым словом следует тип поля и [[идентификатор]] его имени. Тип поля может быть опущен. После имени может стоять символ "=" и выражение, инициализирующее значение данного поля. В целом, синтаксис тот же, что и при объявлении обычной переменой или константы:<br />
<br />
<source lang="kpp"><br />
var int m_x;<br />
const m_y = 0;<br />
var m_stream = new stream;<br />
</source><br />
<br />
Тип поля определяется по следующим правилам:<br />
* если тип указан явно, ничего определять не надо;<br />
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;<br />
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].<br />
<br />
'''Примечание:''' В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать ''свойства'' (см. ниже).<br />
<br />
== Свойства ==<br />
<br />
''Свойства'' — это специальные конструкции языка К++, которые позволяют совмещать обращение к данным с вызовом определенного метода. Смысл свойств заключается в том, чтобы программист мог контролировать процесс изменения состояния объекта и своевременно реагировать на это изменение. Свойства бывают доступны на чтение, на запись, или на чтение и на запись одновременно. Это связано с тем, что некоторые свойства объекта (в естественном понимании этого слова), могут предполагать только получение информации о них, другие же могут подразумевать изменение состояния, без возможности чтения. <br />
<br />
В существующих языках программирования, таких как C++ тот же функционал реализуется с помощью вызова специальных методов: ''аксессоров'' и ''мутаторов'', которые используются для получения сведений о некотором свойстве или для записи соответственно. Однако это делает код менее читаемым, особенно в случае мутаторов. Свойства же, позволяют работать с собой подобно обычным полям или объектам, используя операторы. <br />
<br />
Приведем два примера, которые позволят понять смысл свойств и их отличие от обычных полей класса.<br />
<br />
Предположим, что у нас есть класс, отвечающий за чтение состояния некоторого устройства. Допустим, состояние представляется целым числом и должно определяться по мере обращения. Если бы мы писали на языке C++, то мы оформили бы это в виде метода:<br />
<br />
<source lang="cpp"><br />
class MyDevice {<br />
int GetState();<br />
};<br />
</source><br />
<br />
Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:<br />
<br />
<source lang="cpp"><br />
int current_state = Device.GetState();<br />
</source><br />
<br />
В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++: <br />
<br />
<source lang="kpp"><br />
class MyDevice {<br />
function int GetState();<br />
property int state read GetState;<br />
}<br />
</source><br />
<br />
Соответственно, обращение к свойству состояния будет выглядеть так:<br />
<br />
<source lang="kpp"><br />
var current_state = Device.state;<br />
</source><br />
<br />
При обращении к свойству <tt>state</tt> будет автоматически вызван метод <tt>GetState()</tt>, результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:<br />
<br />
<source lang="cpp"><br />
Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus());<br />
printf("object %s (%d) located at %s : status changed to %u", <br />
Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());<br />
</source><br />
<br />
<source lang="kpp"><br />
Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status;<br />
println("object % (%) located at % : status changed to %", <br />
Object1.name, Object1.index, Object1.location, Object1.status);<br />
</source><br />
<br />
В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находиться в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по-разному обрабатывать и отрисовывать этот элемент управления.<br />
<br />
В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение, так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:<br />
<br />
<source lang="kpp" line="1"><br />
class Widget {<br />
var m_Enabled = true; //поле, хранящее текущее состояние активности<br />
function void SetEnabled(const value) {<br />
var old_value = m_Enabled;<br />
m_Enabled = value;<br />
if (old_value != m_Enabled)<br />
Invalidate(); //Состояние изменилось, обновляем элемент управления<br />
}<br />
property enabled read m_Enabled write SetEnabled;<br />
//далее идет остальная часть класса, например методы отрисовки<br />
}<br />
</source><br />
<br />
Теперь, если мы унаследуем некоторый класс от данного класса и переопределим соответствующие методы отрисовки, то у класса потомка так же можно будет использовать свойство <tt>enabled</tt>:<br />
<br />
<source lang="kpp"><br />
var myForm = new Form; //создаем окно<br />
var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку<br />
myButton.caption = "Click me!"; //устанавливаем подпись<br />
myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события<br />
myForm.Show(); //показываем окно<br />
</source><br />
<br />
Приведенный выше код создаст окно и разместит на нем кнопку (подразумевается, что класс <tt>Button</tt> унаследован от нашего класса <tt>Widget</tt>). Затем устанавливаются свойства кнопки, такие как подпись и [[Блоки|блок]] обработчика события <tt>OnClick</tt>. При нажатии на кнопку она станет неактивной.<br />
<br />
<br />
----<br />
<br />
<br />
В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства. <br />
<br />
Оставшаяся часть зависит от того, какое свойство объявляется:<br />
<br />
* Если объявляется свойство на чтение, то указывается ключевое слово <tt>'''read'''</tt>, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как ''аксессор''. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.<br />
* Если объявляется свойство на запись, то указывается, соответственно ключевое слово <tt>'''write'''</tt> после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как ''мутатор''. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.<br />
* Если объявляется свойство, доступное как на чтение, так и на запись, то указываются обе части, причем первой идет часть чтения.<br />
<br />
<br />
'''Примечание:''' Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция [[Приведение типов|приведения типов]]. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.<br />
<br />
Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки:<br />
<source lang="kpp"><br />
property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>];<br />
</source><br />
<br />
== Расширения ==<br />
<br />
Иногда бывает необходимо расширить функциональность некоторого существующего класса без порождения дочернего класса. Это может быть необходимо в тех случаях, когда исходный класс уже используется в коде программы и порождение нового класса нарушило бы спецификацию на интерфейс, либо потребовало значительных изменений в исходных текстах программы. В таких случаях целесообразно применять т. н. ''расширения классов''. Синтаксически, конструкция расширения практически не отличается от конструкции объявления класса, однако методы и свойства, перечисленные в нем, дополняются к исходному классу, то есть наследования не происходит.<br />
<br />
Как правило, расширения применяются к классам [[Стандартной библиотека Gide|стандартной библиотеки]], либо к [[unmanaged код|неуправляемым классам]].<br />
<br />
В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:<br />
<br />
<source lang="kpp" line="1"><br />
package intmod_fact;<br />
import std;<br />
external console_stream STDOUT;<br />
function void println(const string s) { STDOUT.print(s + "\n"); }<br />
<br />
extend int {<br />
const function ubigint GetFactorial() {<br />
var ubigint result = 1, int x;<br />
for (x = this; x > 1; --x)<br />
result *= x;<br />
return result;<br />
}<br />
property ubigint factorial read GetFactorial;<br />
}<br />
<br />
export function main() {<br />
println("Factorial of 10 is " + 10.factorial);<br />
}<br />
</source><br />
<br />
<br />
;6-14: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.<br />
<br />
;17: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. <!--Его мы вызываем с помощью специального синтаксиса, для передачи блока в качестве [[Функции#Аргументы|параметра функции]]. При этом сам блок указывается прямо в коде вызова функции. Тело блока состоит из одного вызова функции, выводящей текущее число в стандартный поток вывода. --><br />
<br />
: Обратите внимание, что функция <tt>println()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|ubigint]]</tt>. В этом нет ничего странного, потому что класс <tt>ubigint</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt>, передается в качестве параметра функции.<br />
<br />
<br />
'''Примечание:''' При работе с расширениями существует одно важное ограничение. Расширять классы можно только методами и свойствами, но не полями. Это связано с внутренней организацией языка К++ и виртуальной машины. Дополнительно стоит отметить, что методы объявленные в расширении будут перекрывать соответствующие им методы класса (имеется в виду ситуация когда имена и наборы параметров полностью совпадают). Важно понимать, что такое перекрытие не является объявлением виртуального метода — происходит именно замещение старого метода новым.<br />
<br />
== Смотри также ==</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8BКлассы и объекты2007-10-05T11:36:00Z<p>KroTozeR: /* Свойства */</p>
<hr />
<div>__TOC__<br />
<br />
== История развития ООП ==<br />
<br />
Для того чтобы понять, что же такое классы и объекты, сперва необходимо проследить историю развития программирования. А конкретнее, историю возникновения концепции ООП. Автор верит, что знание истории возникновения тех или иных мыслей и идей может помочь читателю осознать необходимость нововведений, и главное — их преимуществ перед существовавшими в то время решениями.<br />
<br />
=== Возникновение языков программирования ===<br />
<br />
На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.<br />
<br />
=== Появление ассемблера ===<br />
<br />
Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как ''язык'' общения человека и ЭВМ. Так появился первый язык программирования — ''язык ассемблера''. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа ''транслятор'', которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.<br />
<br />
=== Концепция языка высокого уровня ===<br />
<br />
...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами. <br />
<br />
Но время шло, количество приверженцев нового подхода постоянно увеличивалось. Сами же компиляторы становились все более мощными и генерировали все более компактный и оптимальный код. Дошло до того, что компилятор с оптимизатором в некоторых случаях генерировал код, более качественный, чем это делал программист. С этого момента ЯП высокого уровня заняли свое место в истории и в инструментарии любого разработчика.<br />
<br />
=== Структурное программирование ===<br />
<br />
С развитием языков программирования появились новые концепции и новые парадигмы программирования. От линейного моноблочного программирования, при котором программа писалась единым "куском" от начала до конца, перешли к программам модульным и структурным. При них программа представляла уже совокупность процедур (функций), которые вызывали друг друга в ходе работы программы. Процедуры представляли собой подпрограммы, решающие отдельные частные задачи. При этом код получался более читаемым, и облегчалась его отладка. <br />
<br />
Опять же, в ходе усложнения решаемых задач и, вследствие этого, увеличения количества переменных с которыми приходилось работать программисту, возникла идея группировки некоторых переменных в группы или структуры. Структуры формировались по назначению и содержали в себе переменные, имеющие отношение к одной и той же сущности. Это значительно повысило читаемость программ и уменьшило количество ошибок в них.<br />
<br />
=== Объектно-ориентированное программирование ===<br />
<br />
Ну и наконец, одна светлая голова додумалась до мысли: "а что если в структурах группировать не только переменные, но и сами процедуры которые должны работать с этими переменными?". В результате получилось то, что мы сейчас называем классом — то есть, некоторая обособленная функциональная сущность, которая сама хранит свои данные, а главное сама умеет их обрабатывать. Теперь программисту не нужно помнить, какая из процедур отвечает за некоторое действие над такими-то переменными — он просто берет объект и работает с ним. Все что происходит с объектом внутри — это его личное дело.<br />
<br />
Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.<br />
<br />
При написании программы на объектно-ориентированном языке, программист строит математическую модель взаимодействия различных сущностей. Каждая из сущностей это свой мир, у которого есть свои законы и особенности. При этом сущности могут быть как конкретные, вроде "сетевой интерфейс" или "файл", так и совершенно абстрактные, например "отношение" или "ошибка". Программист описывает каждую из сущностей в отдельности, обособлено от остальных. Вся необходимая для работы информация хранится внутри, а для взаимодействия с внешним миром предусмотрен ''интерфейс'' — некоторая совокупность ''свойств'' данной сущности (отражающих ее внутреннее состояние) и способов взаимодействия с ней — ''методов''.<br />
<br />
В ходе работы программы сущности могут взаимодействовать, читая и записывая свойства и вызывая методы друг друга, использовать друг друга как подсистемы, порождать новые сущности и т. д. Получается, что при написании программы, программист переносит свое внутреннее представление того как он видит эту программу, то из чего она состоит и как отдельные ее части взаимодействуют. Теперь не приходится адаптировать свое понимание проблемы к конкретным инструментальным средствам и возможностям языка программирования (конечно, это все же происходит, но уже гораздо менее заметно).<br />
<br />
В терминах современных языков программирования такие сущности называются ''классами'', в смысле ''классами сущностей''. А отдельные представители этих классов называются ''экземплярами'', ''инстанциями'' (на английский манер) или ''объектами''. Более подробно, различие между классами и объектами будет рассмотрено ниже.<br />
<br />
<br />
Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого). <br />
<br />
Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом <tt>int</tt> (целое число) и некоторым пользовательским классом <tt>MyWeirdClass</tt>: везде, где можно использовать <tt>int</tt>, можно использовать <tt>MyWeirdClass</tt> и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса <tt>int</tt>, равно как ничто не мешает определить математические операторы для класса <tt>MyWeirdClass</tt> и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!<br />
<br />
== Понятие класса ==<br />
<br />
Что такое ''класс'' проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды, растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем ''яблоки как понятие'', мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. С черенком, на котором остался листик, и маленькой червоточинкой". <br />
<br />
Разница заключается в том, что когда вы говорили ''о яблоках'', вы описывали свое представление яблок, как ''класса'' объектов. Когда вы описывали ''яблоко'', то вы имели в виду конкретный ''экземпляр'', или ''объект''. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода. <br />
<br />
Другой пример: если вас попросить "представьте дерево", то вы либо представите некоторое совершенно абстрактное, усредненное дерево, либо попросите уточнить, какое именно дерево имеется в виду. Ваше сознание из имеющейся информации смогло уяснить только самые общие сведения о классе. Но этой информации не достаточно, для более детального описания. Это тоже важно, поскольку в этом простом примере кроется сущность механизма наследования — постепенного уточнения классами-потомками общих черт своих предков. Таким образом, и яблоня, и груша — деревья. Но яблони отличаются от груш. Получается, что классы ''яблони'' и ''груши'' имеют общего предка — класс ''дерево''.<br />
<br />
Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.<br />
<br />
<br />
Из примеров выше мы смогли уяснить следующее:<br />
<br />
* Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов<br />
* Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности<br />
* Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными<br />
<br />
Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:<br />
<br />
С точки зрения языка, ''класс'' представляет собой набор следующих элементов:<br />
* ''полей'', т.е. переменных, хранящих индивидуальные особенности объектов, <br />
* ''методов'', т.е. функций, определяющих поведение данного объекта;<br />
* ''свойств'', определяющих взаимодействие других объектов с объектами данного класса.<br />
<br />
''Поля'' — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом, они могут хранить свое состояние (например, показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того чтобы частично разрешить этот доступ, применяются ''свойства''. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве [[lvalue]]).<br />
<br />
''Методы'' — это тот самый, связанный с данными код (вспомните [[Классы и объекты#История развития ООП|историю ООП]]) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.<br />
<br />
Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)<br />
<br />
Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью [[Спецификаторы доступа|спецификаторов доступа]]:<br />
<br />
* <tt>'''private'''</tt> — Частная собственность! Видимость только внутри методов данного класса<br />
* <tt>'''protected'''</tt> — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов<br />
* <tt>'''public'''</tt> — видимость и доступ для всех<br />
<br />
'''Примечание:''' По умолчанию методы имеют видимость <tt>'''private'''</tt>, в то время как свойства — <tt>'''public'''</tt>.<br />
<br />
Приведем, наконец, пример объявления класса:<br />
<br />
<source lang="kpp" line="1"><br />
class MyWeirdClass {<br />
var m_x = 0; // поле m_x, изначально проинициализированное нулем<br />
const m_y = 1; // поле-константа m_y<br />
<br />
// методы класса<br />
public const function int get_mul() { return m_x * m_y; }<br />
public function void set_mul(int x) { m_x = x / m_y; }<br />
<br />
// свойство класса<br />
public property mul read get_mul write set_mul;<br />
}<br />
</source><br />
<br />
<br />
;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.<br />
<br />
;3-4: Здесь мы видим объявление двух полей класса — переменной ''m_x'' и константы ''m_y'', которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе [[Константы]]. <br />
<br />
;7-8: Для доступа к состоянию объекта, определены два метода: ''аксессор'' <tt>get_mul()</tt> и ''мутатор'' <tt>set_mul()</tt>. Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.<br />
<br />
;11: Завершается объявление класса объявлением свойства ''mul'', которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызван аксессор, а результат его выполнения будет возвращен в качестве значения свойства. И, наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том, чтобы оно было "доставлено по адресу".<br />
<br />
: '''Примечание:''' Зачем нужны такие сложности, и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.<br />
<br />
== Понятие объекта ==<br />
<br />
Собственно, понятие объекта уже много раз было затронуто выше по повествованию. Поэтому здесь приведем лишь небольшое определение: Под ''объектом'' подразумевается экземпляр того или иного класса, т.е. некоторая сущность, поведение которой задается соответствующим классом.<br />
<br />
Для создания объекта того или иного класса служит оператор <tt>'''new'''</tt>:<br />
<source lang="kpp"><br />
var myWeirdObject = new MyWeirdClass;<br />
</source><br />
<br />
Здесь мы видим типичную конструкцию объявления переменной, однако в инициализаторе переменной находится всего один оператор, за которым следует [[идентификатор]] имени класса, экземпляр которого мы хотим создать.<br />
<br />
== Наследование ==<br />
<br />
Под ''наследованием'' классов понимается механизм такого создания (объявления) класса, при котором он расширяет функционал одного или нескольких уже существующих классов (родителей). Вспомните пример с деревьями. Когда мы говорим, что класс ''яблоня'' наследуется от класса ''дерево'' — это значит что ''яблоня'' унаследует все свойства своего класса-родителя, некоторые из которых он может изменить, ну и дополнить своими собственными свойствами. Опыт нам подсказывает, что у любого дерева есть листья (для простоты не будем вспоминать про хвойные), однако не любое дерево плодоносит яблоками. Если же рассмотреть сами яблоки, то можно сказать, что класс ''яблоко'' унаследован от класса ''фрукт'', который определяет что фрукты (и соответственно яблоки) должны расти на деревьях.<br />
<br />
Таким образом, наследование гарантирует, что к дочерним классам применимы все операции, доступные в родительском классе: любой алгоритм, работающий с объектами родительского класса, может работать с объектами его дочерних классов. <br />
<br />
Для задания наследования, в объявлении класса следует указать ключевое слово <tt>'''extends'''</tt>, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:<br />
<br />
<source lang="kpp" line="1"><br />
// коробка<br />
class Box { <br />
// из чего сделана коробка?<br />
public const function string material() { return "Картон"; }<br />
<br />
// что в коробке?<br />
public const function string contents() { return "Пусто"; }<br />
}<br />
<br />
// коробка с картошкой<br />
class BoxWithPotatoes extends Box { <br />
public const function string contents() { return "Картошка"; }<br />
}<br />
<br />
function OutputBox(const Box b) {<br />
STDOUT.print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");<br />
}<br />
<br />
function main() {<br />
var b1 = new Box;<br />
var b2 = new BoxWithPotatoes;<br />
OutputBox(b1); // Материал: Картон, содержит: Пусто<br />
OutputBox(b2); // Материал: Картон, содержит: Картошка<br />
}<br />
</source><br />
<br />
<br />
;2-7: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.<br />
<br />
;10-12: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.<br />
<br />
;14-16: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).<br />
<br />
;18-23: Объявляется функция <tt>main()</tt>, внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра ''b1'' и ''b2'' классов <tt>Box</tt> и <tt>BoxWithPotatoes</tt> соответственно. А затем, вызываем вышеописанную функцию <tt>OutputBox()</tt>, которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает, как это все работает.<br />
<br />
'''Примечание:''' при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако его можно обойти с помощью создания [[Класс-обертка|классов-оберток]] для системного класса, с последующим наследованием от него нового класса.<br />
<br />
== Методы ==<br />
<br />
''Метод'' — это некоторый код, связанный с объектом и управляющий его поведением. Управление может заключаться в изменении переменных состояния объекта (полей), либо выполнением некоторых операций над ними.<br />
<br />
При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:<br />
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода<br />
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод не изменяет объект<br />
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять<br />
<br />
После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].<br />
<br />
Тело метода может быть объявлено как непосредственно в теле класса, так и вынесено за его пределы, например:<br />
<br />
<source lang="kpp" line="1"><br />
class MyClass {<br />
public const function string F1() { return "smth"; }<br />
public const function string F2();<br />
}<br />
<br />
function string MyClass::F2() {<br />
return F1();<br />
}<br />
</source><br />
<br />
<br />
;6: При вынесении функции за пределы класса, имя соответствующего метода предваряется именем класса, из которого он был вынесен; имена отделяются друг от друга символом "двойное двоеточие" ( <tt>::</tt> ); дополнительно — в заголовке вынесенной функции необходимо указать тип возвращаемого значения и параметры функции, все остальные ключевые слова указывать не обязательно.<br />
<br />
;7: В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в коде приведенном выше, метод <tt>F2()</tt> вызывает метод <tt>F1()</tt> для того же объекта.<br />
<br />
=== Статические методы ===<br />
<br />
''Статический метод класса'' — это метод, относящийся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.<br />
<br />
При объявлении статического метода нужно указать ключевое слово <tt>'''static'''</tt>.<br />
<br />
В теле статического метода нет возможности напрямую обращаться к другим методам данного класса, т.к. статическому методу недоступен объект класса. Фактически, единственным отличием статического метода от обычной функции является то, что такой метод может обращаться к защищенным полям и методам класса некоторого другого объекта. Подобный подход широко применяется при написании ''конструкторов'' (см. ниже).<br />
<br />
Пример:<br />
<source lang="kpp"><br />
class MyClass {<br />
public static function string Info() { return "Я MyClass!"; }<br />
}<br />
<br />
function f() {<br />
// Вызов статического метода:<br />
var myClassInfo = MyClass.Info();<br />
}<br />
</source><br />
<br />
=== Конструкторы ===<br />
<br />
В ходе написания программы часто приходится создавать новые объекты. При этом объекту требуется установить некоторое начальное состояние. Разумеется, это выполняется либо путем написания инициализаторов соответствующих полей, либо значения полям присваиваются явным образом. Но что делать, если объект может иметь несколько начальных состояний? То есть, в зависимости от некоторых условий, одним и тем же полям объекта могут быть присвоены различные наборы значений. Тут уже одними инициализаторами не обойтись. Присваивать значения можно прямо в коде программы, однако это не очень красивое решение, поскольку один и тот же объект может создаваться в нескольких местах программы и придется копировать один и тот же участок кода, инициализирующий поля объекта. Недостаток этого подхода в том, что при большом количестве полей, программист может забыть проинициализировать некаторе поле, либо при изменении условий инициализации он может изменить их только в одном месте программы, забыв, что объект может создаваться и в других местах. Более разумным является подход, при котором программист пишет функцию, инициализирующую поля объекта. При этом весь код собирается в одном месте и вероятность ошибок значительно понижается. <br />
<br />
Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код, относящийся к созданию инстанции класса. Итак, ''конструктор класса'' — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.<br />
<br />
Таким образом, следующие объявления в рамках класса эквивалентны:<br />
<source lang="kpp"><br />
public constructor Create();<br />
public static MyClass Create();<br />
</source><br />
<br />
Тело конструктора чаще всего выглядит следующим образом: сначала создается экземпляр класса при помощи оператора <tt>'''new'''</tt>, затем производятся некоторые действия, инициализующие этот объект, и, наконец, этот объект возвращается в качестве результата. <br />
<br />
В качестве примера приведем пример реализации некоторого абстрактного класса <tt>MyStream</tt>, использующего системную реализацию класса <tt>stream</tt>, и определяющую собственный конструктор:<br />
<br />
<source lang="kpp" line="1"><br />
class MyStream {<br />
var string m_URL;<br />
var stream m_Stream;<br />
public:<br />
static const MODE_READ = 1;<br />
static const MODE_WRITE = 2;<br />
constructor open(const string url, int mode) {<br />
var self = new MyStream;<br />
self.m_Stream.open(url, mode);<br />
self.m_URL = url;<br />
return self;<br />
}<br />
// прочие методы (опущены для краткости)<br />
}<br />
</source><br />
<br />
<br />
;2-3: Объявляются поля ''m_URL'' и ''m_Stream'' нашего класса, которые будут инициализироваться в конструкторе. <br />
<br />
;5-6: В публичной области класса объявляются статические константы ''MODE_READ'' и ''MODE_WRITE'', которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.<br />
<br />
;7: Объявляется конструктор <tt>open()</tt>, принимающий в качестве параметров [[URL]] ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию ''self'' нашего класса. Затем производится попытка открытия потока ''m_Stream'': если операция пройдет успешно, то происходит инициализация оставшегося поля ''m_URL'' и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано ''[[Обработка исключений|исключение]]'' и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).<br />
<br />
<br />
Использовать наш класс можно примерно так:<br />
<source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source><br />
<br />
Обратите внимание на второй параметр функции, где мы передаем константу ''MODE_READ'', объявленную внутри самого класса. Подобный подход, когда константы, используемые при работе с классом, инкапсулируются в тело класса, помогает сконцентрировать код в одном месте и избежать многих ошибок. В результате повышается читаемость кода и не возникает конфликта имен констант.<br />
<br />
== Поля ==<br />
<br />
Поле класса — это некоторый объект, используемый объектом данного класса.<br />
<br />
Объявление поля начинается с одного из трех ключевых слов:<br />
* <tt>'''var'''</tt> — объявление "обычного" поля;<br />
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;<br />
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.<br />
<br />
За ключевым словом следует тип поля и [[идентификатор]] его имени. Тип поля может быть опущен. После имени может стоять символ "=" и выражение, инициализирующее значение данного поля. В целом, синтаксис тот же, что и при объявлении обычной переменой или константы:<br />
<br />
<source lang="kpp"><br />
var int m_x;<br />
const m_y = 0;<br />
var m_stream = new stream;<br />
</source><br />
<br />
Тип поля определяется по следующим правилам:<br />
* если тип указан явно, ничего определять не надо;<br />
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;<br />
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].<br />
<br />
'''Примечание:''' В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать ''свойства'' (см. ниже).<br />
<br />
== Свойства ==<br />
<br />
''Свойства'' — это специальные конструкции языка К++, которые позволяют совмещать обращение к данным с вызовом определенного метода. Смысл свойств заключается в том, чтобы программист мог контролировать процесс изменения состояния объекта и своевременно реагировать на это изменение. Свойства бывают доступны на чтение, на запись, или на чтение и на запись одновременно. Это связано с тем, что некоторые свойства объекта (в естественном понимании этого слова), могут предполагать только получение информации о них, другие же могут подразумевать изменение состояния, без возможности чтения. <br />
<br />
В существующих языках программирования, таких как C++ тот же функционал реализуется с помощью вызова специальных методов: ''аксессоров'' и ''мутаторов'', которые используются для получения сведений о некотором свойстве или для записи соответственно. Однако это делает код менее читаемым, особенно в случае мутаторов. Свойства же, позволяют работать с собой подобно обычным полям или объектам, используя операторы. <br />
<br />
Приведем два примера, которые позволят понять смысл свойств и их отличие от обычных полей класса.<br />
<br />
Предположим, что у нас есть класс, отвечающий за чтение состояния некоторого устройства. Допустим, состояние представляется целым числом и должно определяться по мере обращения. Если бы мы писали на языке C++, то мы оформили бы это в виде метода:<br />
<br />
<source lang="cpp"><br />
class MyDevice {<br />
int GetState();<br />
};<br />
</source><br />
<br />
Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:<br />
<br />
<source lang="cpp"><br />
int current_state = Device.GetState();<br />
</source><br />
<br />
В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++: <br />
<br />
<source lang="kpp"><br />
class MyDevice {<br />
function int GetState();<br />
property int state read GetState;<br />
}<br />
</source><br />
<br />
Соответственно, обращение к свойству состояния будет выглядеть так:<br />
<br />
<source lang="kpp"><br />
var current_state = Device.state;<br />
</source><br />
<br />
При обращении к свойству <tt>state</tt> будет автоматически вызван метод <tt>GetState()</tt>, результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:<br />
<br />
<source lang="cpp"><br />
Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus());<br />
printf("object %s (%d) located at %s : status changed to %u", <br />
Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());<br />
</source><br />
<br />
<source lang="kpp"><br />
Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status;<br />
println("object % (%) located at % : status changed to %", <br />
Object1.name, Object1.index, Object1.location, Object1.status);<br />
</source><br />
<br />
В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находиться в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по-разному обрабатывать и отрисовывать этот элемент управления.<br />
<br />
В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение, так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:<br />
<br />
<source lang="kpp" line="1"><br />
class Widget {<br />
var m_Enabled = true; //поле, хранящее текущее состояние активности<br />
function void SetEnabled(const value) {<br />
var old_value = m_Enabled;<br />
m_Enabled = value;<br />
if (old_value != m_Enabled)<br />
Invalidate(); //Состояние изменилось, обновляем элемент управления<br />
}<br />
property enabled read m_Enabled write SetEnabled;<br />
//далее идет остальная часть класса, например методы отрисовки<br />
}<br />
</source><br />
<br />
Теперь, если мы унаследуем некоторый класс от данного класса и переопределим соответствующие методы отрисовки, то у класса потомка так же можно будет использовать свойство <tt>enabled</tt>:<br />
<br />
<source lang="kpp"><br />
var myForm = new Form; //создаем окно<br />
var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку<br />
myButton.caption = "Click me!"; //устанавливаем подпись<br />
myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события<br />
myForm.Show(); //показываем окно<br />
</source><br />
<br />
Приведенный выше код создаст окно и разместит на нем кнопку (подразумевается, что класс <tt>Button</tt> унаследован от нашего класса <tt>Widget</tt>). Затем устанавливаются свойства кнопки, такие как подпись и [[Блоки|блок]] обработчика события <tt>OnClick</tt>. При нажатии на кнопку она станет неактивной.<br />
<br />
<br />
----<br />
<br />
<br />
В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства. <br />
<br />
Оставшаяся часть зависит от того, какое свойство объявляется:<br />
<br />
* Если объявляется свойство на чтение, то указывается ключевое слово <tt>'''read'''</tt>, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как ''аксессор''. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.<br />
* Если объявляется свойство на запись, то указывается, соответственно ключевое слово <tt>'''write'''</tt> после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как ''мутатор''. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.<br />
* Если объявляется свойство, доступное как на чтение, так и на запись, то указываются обе части, причем первой идет часть чтения.<br />
<br />
<br />
'''Примечание:''' Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция [[Приведение типов|приведения типов]]. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.<br />
<br />
Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки:<br />
<source lang="kpp"><br />
property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>];<br />
</source><br />
<br />
== Расширения ==<br />
<br />
Иногда бывает необходимо расширить функциональность некоторого существующего класса без порождения дочернего класса. Это может быть необходимо в тех случаях, когда исходный класс уже используется в коде программы и порождение нового класса нарушило бы спецификацию на интерфейс, либо потребовало значительных изменений в исходных текстах программы. В таких случаях целесообразно применять т. н. ''расширения классов''. Синтаксически, конструкция расширения практически не отличается от конструкции объявления класса, однако методы и свойства перечисленные в нем, дополняются к исходному классу, то есть наследования не происходит.<br />
<br />
Как правило, расширения применяются к классам [[Стандартной библиотека Gide|стандартной библиотеки]], либо к [[unmanaged код|неуправляемым классам]].<br />
<br />
В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же как при описании классов:<br />
<br />
<source lang="kpp" line="1"><br />
package intmod_fact;<br />
import std;<br />
external console_stream STDOUT;<br />
function void println(const string s) { STDOUT.print(s + "\n"); }<br />
<br />
extend int {<br />
const function ubigint GetFactorial() {<br />
var ubigint result = 1, int x;<br />
for (x = this; x > 1; --x)<br />
result *= x;<br />
return result;<br />
}<br />
property ubigint factorial read GetFactorial;<br />
}<br />
<br />
export function main() {<br />
println("Factorial of 10 is " + 10.factorial);<br />
}<br />
</source><br />
<br />
<br />
;6-14: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.<br />
<br />
;17: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. <!--Его мы вызываем с помощью специального синтаксиса, для передачи блока в качестве [[Функции#Аргументы|параметра функции]]. При этом, сам блок указывается прямо в коде вызова функции. Тело блока состоит из одного вызова функции, выводящей текущее число в стандартный поток вывода. --><br />
<br />
: Обратите внимание, что функция <tt>println()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|ubigint]]</tt>. В этом нет ничего странного, потому что класс <tt>ubigint</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt> передается в качестве параметра функции.<br />
<br />
<br />
'''Примечание:''' При работе с расширениями существует одно важное ограничение. Расширять классы можно только методами и свойствами, но не полями. Это связано с внутренней организацией языка К++ и виртуальной машины. Дополнительно стоит отметить, что методы объявленные в расширении будут перекрывать соответствующие им методы класса (имеется в виду ситуация когда имена и наборы параметров полностью совпадают). Важно понимать, что такое перекрытие не является объявлением виртуального метода — происходит именно замещение старого метода новым. <br />
<br />
== Смотри также ==</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8BКлассы и объекты2007-10-05T11:29:53Z<p>KroTozeR: /* Методы */</p>
<hr />
<div>__TOC__<br />
<br />
== История развития ООП ==<br />
<br />
Для того чтобы понять, что же такое классы и объекты, сперва необходимо проследить историю развития программирования. А конкретнее, историю возникновения концепции ООП. Автор верит, что знание истории возникновения тех или иных мыслей и идей может помочь читателю осознать необходимость нововведений, и главное — их преимуществ перед существовавшими в то время решениями.<br />
<br />
=== Возникновение языков программирования ===<br />
<br />
На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.<br />
<br />
=== Появление ассемблера ===<br />
<br />
Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как ''язык'' общения человека и ЭВМ. Так появился первый язык программирования — ''язык ассемблера''. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа ''транслятор'', которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.<br />
<br />
=== Концепция языка высокого уровня ===<br />
<br />
...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами. <br />
<br />
Но время шло, количество приверженцев нового подхода постоянно увеличивалось. Сами же компиляторы становились все более мощными и генерировали все более компактный и оптимальный код. Дошло до того, что компилятор с оптимизатором в некоторых случаях генерировал код, более качественный, чем это делал программист. С этого момента ЯП высокого уровня заняли свое место в истории и в инструментарии любого разработчика.<br />
<br />
=== Структурное программирование ===<br />
<br />
С развитием языков программирования появились новые концепции и новые парадигмы программирования. От линейного моноблочного программирования, при котором программа писалась единым "куском" от начала до конца, перешли к программам модульным и структурным. При них программа представляла уже совокупность процедур (функций), которые вызывали друг друга в ходе работы программы. Процедуры представляли собой подпрограммы, решающие отдельные частные задачи. При этом код получался более читаемым, и облегчалась его отладка. <br />
<br />
Опять же, в ходе усложнения решаемых задач и, вследствие этого, увеличения количества переменных с которыми приходилось работать программисту, возникла идея группировки некоторых переменных в группы или структуры. Структуры формировались по назначению и содержали в себе переменные, имеющие отношение к одной и той же сущности. Это значительно повысило читаемость программ и уменьшило количество ошибок в них.<br />
<br />
=== Объектно-ориентированное программирование ===<br />
<br />
Ну и наконец, одна светлая голова додумалась до мысли: "а что если в структурах группировать не только переменные, но и сами процедуры которые должны работать с этими переменными?". В результате получилось то, что мы сейчас называем классом — то есть, некоторая обособленная функциональная сущность, которая сама хранит свои данные, а главное сама умеет их обрабатывать. Теперь программисту не нужно помнить, какая из процедур отвечает за некоторое действие над такими-то переменными — он просто берет объект и работает с ним. Все что происходит с объектом внутри — это его личное дело.<br />
<br />
Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.<br />
<br />
При написании программы на объектно-ориентированном языке, программист строит математическую модель взаимодействия различных сущностей. Каждая из сущностей это свой мир, у которого есть свои законы и особенности. При этом сущности могут быть как конкретные, вроде "сетевой интерфейс" или "файл", так и совершенно абстрактные, например "отношение" или "ошибка". Программист описывает каждую из сущностей в отдельности, обособлено от остальных. Вся необходимая для работы информация хранится внутри, а для взаимодействия с внешним миром предусмотрен ''интерфейс'' — некоторая совокупность ''свойств'' данной сущности (отражающих ее внутреннее состояние) и способов взаимодействия с ней — ''методов''.<br />
<br />
В ходе работы программы сущности могут взаимодействовать, читая и записывая свойства и вызывая методы друг друга, использовать друг друга как подсистемы, порождать новые сущности и т. д. Получается, что при написании программы, программист переносит свое внутреннее представление того как он видит эту программу, то из чего она состоит и как отдельные ее части взаимодействуют. Теперь не приходится адаптировать свое понимание проблемы к конкретным инструментальным средствам и возможностям языка программирования (конечно, это все же происходит, но уже гораздо менее заметно).<br />
<br />
В терминах современных языков программирования такие сущности называются ''классами'', в смысле ''классами сущностей''. А отдельные представители этих классов называются ''экземплярами'', ''инстанциями'' (на английский манер) или ''объектами''. Более подробно, различие между классами и объектами будет рассмотрено ниже.<br />
<br />
<br />
Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого). <br />
<br />
Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом <tt>int</tt> (целое число) и некоторым пользовательским классом <tt>MyWeirdClass</tt>: везде, где можно использовать <tt>int</tt>, можно использовать <tt>MyWeirdClass</tt> и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса <tt>int</tt>, равно как ничто не мешает определить математические операторы для класса <tt>MyWeirdClass</tt> и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!<br />
<br />
== Понятие класса ==<br />
<br />
Что такое ''класс'' проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды, растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем ''яблоки как понятие'', мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. С черенком, на котором остался листик, и маленькой червоточинкой". <br />
<br />
Разница заключается в том, что когда вы говорили ''о яблоках'', вы описывали свое представление яблок, как ''класса'' объектов. Когда вы описывали ''яблоко'', то вы имели в виду конкретный ''экземпляр'', или ''объект''. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода. <br />
<br />
Другой пример: если вас попросить "представьте дерево", то вы либо представите некоторое совершенно абстрактное, усредненное дерево, либо попросите уточнить, какое именно дерево имеется в виду. Ваше сознание из имеющейся информации смогло уяснить только самые общие сведения о классе. Но этой информации не достаточно, для более детального описания. Это тоже важно, поскольку в этом простом примере кроется сущность механизма наследования — постепенного уточнения классами-потомками общих черт своих предков. Таким образом, и яблоня, и груша — деревья. Но яблони отличаются от груш. Получается, что классы ''яблони'' и ''груши'' имеют общего предка — класс ''дерево''.<br />
<br />
Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.<br />
<br />
<br />
Из примеров выше мы смогли уяснить следующее:<br />
<br />
* Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов<br />
* Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности<br />
* Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными<br />
<br />
Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:<br />
<br />
С точки зрения языка, ''класс'' представляет собой набор следующих элементов:<br />
* ''полей'', т.е. переменных, хранящих индивидуальные особенности объектов, <br />
* ''методов'', т.е. функций, определяющих поведение данного объекта;<br />
* ''свойств'', определяющих взаимодействие других объектов с объектами данного класса.<br />
<br />
''Поля'' — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом, они могут хранить свое состояние (например, показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того чтобы частично разрешить этот доступ, применяются ''свойства''. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве [[lvalue]]).<br />
<br />
''Методы'' — это тот самый, связанный с данными код (вспомните [[Классы и объекты#История развития ООП|историю ООП]]) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.<br />
<br />
Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)<br />
<br />
Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью [[Спецификаторы доступа|спецификаторов доступа]]:<br />
<br />
* <tt>'''private'''</tt> — Частная собственность! Видимость только внутри методов данного класса<br />
* <tt>'''protected'''</tt> — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов<br />
* <tt>'''public'''</tt> — видимость и доступ для всех<br />
<br />
'''Примечание:''' По умолчанию методы имеют видимость <tt>'''private'''</tt>, в то время как свойства — <tt>'''public'''</tt>.<br />
<br />
Приведем, наконец, пример объявления класса:<br />
<br />
<source lang="kpp" line="1"><br />
class MyWeirdClass {<br />
var m_x = 0; // поле m_x, изначально проинициализированное нулем<br />
const m_y = 1; // поле-константа m_y<br />
<br />
// методы класса<br />
public const function int get_mul() { return m_x * m_y; }<br />
public function void set_mul(int x) { m_x = x / m_y; }<br />
<br />
// свойство класса<br />
public property mul read get_mul write set_mul;<br />
}<br />
</source><br />
<br />
<br />
;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.<br />
<br />
;3-4: Здесь мы видим объявление двух полей класса — переменной ''m_x'' и константы ''m_y'', которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе [[Константы]]. <br />
<br />
;7-8: Для доступа к состоянию объекта, определены два метода: ''аксессор'' <tt>get_mul()</tt> и ''мутатор'' <tt>set_mul()</tt>. Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.<br />
<br />
;11: Завершается объявление класса объявлением свойства ''mul'', которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызван аксессор, а результат его выполнения будет возвращен в качестве значения свойства. И, наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том, чтобы оно было "доставлено по адресу".<br />
<br />
: '''Примечание:''' Зачем нужны такие сложности, и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.<br />
<br />
== Понятие объекта ==<br />
<br />
Собственно, понятие объекта уже много раз было затронуто выше по повествованию. Поэтому здесь приведем лишь небольшое определение: Под ''объектом'' подразумевается экземпляр того или иного класса, т.е. некоторая сущность, поведение которой задается соответствующим классом.<br />
<br />
Для создания объекта того или иного класса служит оператор <tt>'''new'''</tt>:<br />
<source lang="kpp"><br />
var myWeirdObject = new MyWeirdClass;<br />
</source><br />
<br />
Здесь мы видим типичную конструкцию объявления переменной, однако в инициализаторе переменной находится всего один оператор, за которым следует [[идентификатор]] имени класса, экземпляр которого мы хотим создать.<br />
<br />
== Наследование ==<br />
<br />
Под ''наследованием'' классов понимается механизм такого создания (объявления) класса, при котором он расширяет функционал одного или нескольких уже существующих классов (родителей). Вспомните пример с деревьями. Когда мы говорим, что класс ''яблоня'' наследуется от класса ''дерево'' — это значит что ''яблоня'' унаследует все свойства своего класса-родителя, некоторые из которых он может изменить, ну и дополнить своими собственными свойствами. Опыт нам подсказывает, что у любого дерева есть листья (для простоты не будем вспоминать про хвойные), однако не любое дерево плодоносит яблоками. Если же рассмотреть сами яблоки, то можно сказать, что класс ''яблоко'' унаследован от класса ''фрукт'', который определяет что фрукты (и соответственно яблоки) должны расти на деревьях.<br />
<br />
Таким образом, наследование гарантирует, что к дочерним классам применимы все операции, доступные в родительском классе: любой алгоритм, работающий с объектами родительского класса, может работать с объектами его дочерних классов. <br />
<br />
Для задания наследования, в объявлении класса следует указать ключевое слово <tt>'''extends'''</tt>, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:<br />
<br />
<source lang="kpp" line="1"><br />
// коробка<br />
class Box { <br />
// из чего сделана коробка?<br />
public const function string material() { return "Картон"; }<br />
<br />
// что в коробке?<br />
public const function string contents() { return "Пусто"; }<br />
}<br />
<br />
// коробка с картошкой<br />
class BoxWithPotatoes extends Box { <br />
public const function string contents() { return "Картошка"; }<br />
}<br />
<br />
function OutputBox(const Box b) {<br />
STDOUT.print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");<br />
}<br />
<br />
function main() {<br />
var b1 = new Box;<br />
var b2 = new BoxWithPotatoes;<br />
OutputBox(b1); // Материал: Картон, содержит: Пусто<br />
OutputBox(b2); // Материал: Картон, содержит: Картошка<br />
}<br />
</source><br />
<br />
<br />
;2-7: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.<br />
<br />
;10-12: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.<br />
<br />
;14-16: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).<br />
<br />
;18-23: Объявляется функция <tt>main()</tt>, внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра ''b1'' и ''b2'' классов <tt>Box</tt> и <tt>BoxWithPotatoes</tt> соответственно. А затем, вызываем вышеописанную функцию <tt>OutputBox()</tt>, которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает, как это все работает.<br />
<br />
'''Примечание:''' при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако его можно обойти с помощью создания [[Класс-обертка|классов-оберток]] для системного класса, с последующим наследованием от него нового класса.<br />
<br />
== Методы ==<br />
<br />
''Метод'' — это некоторый код, связанный с объектом и управляющий его поведением. Управление может заключаться в изменении переменных состояния объекта (полей), либо выполнением некоторых операций над ними.<br />
<br />
При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:<br />
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода<br />
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод не изменяет объект<br />
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять<br />
<br />
После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].<br />
<br />
Тело метода может быть объявлено как непосредственно в теле класса, так и вынесено за его пределы, например:<br />
<br />
<source lang="kpp" line="1"><br />
class MyClass {<br />
public const function string F1() { return "smth"; }<br />
public const function string F2();<br />
}<br />
<br />
function string MyClass::F2() {<br />
return F1();<br />
}<br />
</source><br />
<br />
<br />
;6: При вынесении функции за пределы класса, имя соответствующего метода предваряется именем класса, из которого он был вынесен; имена отделяются друг от друга символом "двойное двоеточие" ( <tt>::</tt> ); дополнительно — в заголовке вынесенной функции необходимо указать тип возвращаемого значения и параметры функции, все остальные ключевые слова указывать не обязательно.<br />
<br />
;7: В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в коде приведенном выше, метод <tt>F2()</tt> вызывает метод <tt>F1()</tt> для того же объекта.<br />
<br />
=== Статические методы ===<br />
<br />
''Статический метод класса'' — это метод, относящийся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.<br />
<br />
При объявлении статического метода нужно указать ключевое слово <tt>'''static'''</tt>.<br />
<br />
В теле статического метода нет возможности напрямую обращаться к другим методам данного класса, т.к. статическому методу недоступен объект класса. Фактически, единственным отличием статического метода от обычной функции является то, что такой метод может обращаться к защищенным полям и методам класса некоторого другого объекта. Подобный подход широко применяется при написании ''конструкторов'' (см. ниже).<br />
<br />
Пример:<br />
<source lang="kpp"><br />
class MyClass {<br />
public static function string Info() { return "Я MyClass!"; }<br />
}<br />
<br />
function f() {<br />
// Вызов статического метода:<br />
var myClassInfo = MyClass.Info();<br />
}<br />
</source><br />
<br />
=== Конструкторы ===<br />
<br />
В ходе написания программы часто приходится создавать новые объекты. При этом объекту требуется установить некоторое начальное состояние. Разумеется, это выполняется либо путем написания инициализаторов соответствующих полей, либо значения полям присваиваются явным образом. Но что делать, если объект может иметь несколько начальных состояний? То есть, в зависимости от некоторых условий, одним и тем же полям объекта могут быть присвоены различные наборы значений. Тут уже одними инициализаторами не обойтись. Присваивать значения можно прямо в коде программы, однако это не очень красивое решение, поскольку один и тот же объект может создаваться в нескольких местах программы и придется копировать один и тот же участок кода, инициализирующий поля объекта. Недостаток этого подхода в том, что при большом количестве полей, программист может забыть проинициализировать некаторе поле, либо при изменении условий инициализации он может изменить их только в одном месте программы, забыв, что объект может создаваться и в других местах. Более разумным является подход, при котором программист пишет функцию, инициализирующую поля объекта. При этом весь код собирается в одном месте и вероятность ошибок значительно понижается. <br />
<br />
Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код, относящийся к созданию инстанции класса. Итак, ''конструктор класса'' — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.<br />
<br />
Таким образом, следующие объявления в рамках класса эквивалентны:<br />
<source lang="kpp"><br />
public constructor Create();<br />
public static MyClass Create();<br />
</source><br />
<br />
Тело конструктора чаще всего выглядит следующим образом: сначала создается экземпляр класса при помощи оператора <tt>'''new'''</tt>, затем производятся некоторые действия, инициализующие этот объект, и, наконец, этот объект возвращается в качестве результата. <br />
<br />
В качестве примера приведем пример реализации некоторого абстрактного класса <tt>MyStream</tt>, использующего системную реализацию класса <tt>stream</tt>, и определяющую собственный конструктор:<br />
<br />
<source lang="kpp" line="1"><br />
class MyStream {<br />
var string m_URL;<br />
var stream m_Stream;<br />
public:<br />
static const MODE_READ = 1;<br />
static const MODE_WRITE = 2;<br />
constructor open(const string url, int mode) {<br />
var self = new MyStream;<br />
self.m_Stream.open(url, mode);<br />
self.m_URL = url;<br />
return self;<br />
}<br />
// прочие методы (опущены для краткости)<br />
}<br />
</source><br />
<br />
<br />
;2-3: Объявляются поля ''m_URL'' и ''m_Stream'' нашего класса, которые будут инициализироваться в конструкторе. <br />
<br />
;5-6: В публичной области класса объявляются статические константы ''MODE_READ'' и ''MODE_WRITE'', которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.<br />
<br />
;7: Объявляется конструктор <tt>open()</tt>, принимающий в качестве параметров [[URL]] ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию ''self'' нашего класса. Затем производится попытка открытия потока ''m_Stream'': если операция пройдет успешно, то происходит инициализация оставшегося поля ''m_URL'' и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано ''[[Обработка исключений|исключение]]'' и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).<br />
<br />
<br />
Использовать наш класс можно примерно так:<br />
<source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source><br />
<br />
Обратите внимание на второй параметр функции, где мы передаем константу ''MODE_READ'', объявленную внутри самого класса. Подобный подход, когда константы, используемые при работе с классом, инкапсулируются в тело класса, помогает сконцентрировать код в одном месте и избежать многих ошибок. В результате повышается читаемость кода и не возникает конфликта имен констант.<br />
<br />
== Поля ==<br />
<br />
Поле класса — это некоторый объект, используемый объектом данного класса.<br />
<br />
Объявление поля начинается с одного из трех ключевых слов:<br />
* <tt>'''var'''</tt> — объявление "обычного" поля;<br />
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;<br />
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.<br />
<br />
За ключевым словом следует тип поля и [[идентификатор]] его имени. Тип поля может быть опущен. После имени может стоять символ "=" и выражение, инициализирующее значение данного поля. В целом, синтаксис тот же, что и при объявлении обычной переменой или константы:<br />
<br />
<source lang="kpp"><br />
var int m_x;<br />
const m_y = 0;<br />
var m_stream = new stream;<br />
</source><br />
<br />
Тип поля определяется по следующим правилам:<br />
* если тип указан явно, ничего определять не надо;<br />
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;<br />
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].<br />
<br />
'''Примечание:''' В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать ''свойства'' (см. ниже).<br />
<br />
== Свойства ==<br />
<br />
''Свойства'' — это специальные конструкции языка К++, которые позволяют совмещать обращение к данным с вызовом определенного метода. Смысл свойств заключается в том, чтобы программист мог контролировать процесс изменения состояния объекта и своевременно реагировать на это изменение. Свойства бывают доступны на чтение, на запись, или на чтение и на запись одновременно. Это связано с тем, что некоторые свойства объекта (в естественном понимании этого слова), могут предполагать только получение информации о них, другие же могут подразумевать изменение состояния, без возможности чтения. <br />
<br />
В существующих языках программирования, таких как C++ тот же функционал реализуется с помощью вызова специальных методов: ''аксессоров'' и ''мутаторов'', которые используются для получения сведений о некотором свойстве или для записи соответственно. Однако, это делает код менее читаемым, особенно в случае мутаторов. Свойства же, позволяют работать с собой подобно обычным полям или объектам, используя операторы. <br />
<br />
Приведем два примера, которые позволят понять смысл свойств и их отличие от обычных полей класса.<br />
<br />
Предположим, что у нас есть класс, отвечающий за чтение состояния некоторого устройства. Допустим, состояние представляется целым числом и должно определяться по мере обращения. Если бы мы писали на языке C++, то мы оформили бы это в виде метода:<br />
<br />
<source lang="cpp"><br />
class MyDevice {<br />
int GetState();<br />
};<br />
</source><br />
<br />
Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:<br />
<br />
<source lang="cpp"><br />
int current_state = Device.GetState();<br />
</source><br />
<br />
В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++: <br />
<br />
<source lang="kpp"><br />
class MyDevice {<br />
function int GetState();<br />
property int state read GetState;<br />
}<br />
</source><br />
<br />
Соответственно, обращение к свойству состояния будет выглядеть так:<br />
<br />
<source lang="kpp"><br />
var current_state = Device.state;<br />
</source><br />
<br />
При обращении к свойству <tt>state</tt> будет автоматически вызыван метод <tt>GetState()</tt>, результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:<br />
<br />
<source lang="cpp"><br />
Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus());<br />
printf("object %s (%d) located at %s : status changed to %u", <br />
Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());<br />
</source><br />
<br />
<source lang="kpp"><br />
Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status;<br />
println("object % (%) located at % : status changed to %", <br />
Object1.name, Object1.index, Object1.location, Object1.status);<br />
</source><br />
<br />
В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находится в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по разному обрабатывать и отрисовывать этот элемент управления.<br />
<br />
В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:<br />
<br />
<source lang="kpp" line="1"><br />
class Widget {<br />
var m_Enabled = true; //поле, хранящее текущее состояние активности<br />
function void SetEnabled(const value) {<br />
var old_value = m_Enabled;<br />
m_Enabled = value;<br />
if (old_value != m_Enabled)<br />
Invalidate(); //Состояние изменилось, обновляем элемент управления<br />
}<br />
property enabled read m_Enabled write SetEnabled;<br />
//далее идет остальная часть класса, например методы отрисовки<br />
}<br />
</source><br />
<br />
Теперь, если мы унаследуем некоторый класс от данного класса и переопределим соответствующие методы отрисовки, то у класса потомка так же можно будет использовать свойство <tt>enabled</tt>:<br />
<br />
<source lang="kpp"><br />
var myForm = new Form; //создаем окно<br />
var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку<br />
myButton.caption = "Click me!"; //устанавливаем подпись<br />
myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события<br />
myForm.Show(); //показываем окно<br />
</source><br />
<br />
Приведенный выше код создаст окно и разместит на нем кнопку (подразумевается, что класс <tt>Button</tt> унаследован от нашего класса <tt>Widget</tt>). Затем устанавливаются свойства кнопки, такие как подпись и [[Блоки|блок]] обработчика события <tt>OnClick</tt>. При нажатии на кнопку она станет неактивной.<br />
<br />
<br />
----<br />
<br />
<br />
В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства. <br />
<br />
Оставшаяся часть зависит от того, какое свойство объявляется:<br />
<br />
* Если объявляется свойство на чтение, то указывается ключевое слово <tt>'''read'''</tt>, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как ''аксессор''. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.<br />
* Если объявляется свойство на запись, то указывается, соответственно ключевое слово <tt>'''write'''</tt> после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как ''мутатор''. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.<br />
* Если объявляется свойство, доступное как на чтение так и на запись, то указываются обе части, причем первой идет часть чтения.<br />
<br />
<br />
'''Примечание:''' Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция [[Приведение типов|приведения типов]]. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.<br />
<br />
Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки:<br />
<source lang="kpp"><br />
property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>];<br />
</source><br />
<br />
== Расширения ==<br />
<br />
Иногда бывает необходимо расширить функциональность некоторого существующего класса без порождения дочернего класса. Это может быть необходимо в тех случаях, когда исходный класс уже используется в коде программы и порождение нового класса нарушило бы спецификацию на интерфейс, либо потребовало значительных изменений в исходных текстах программы. В таких случаях целесообразно применять т. н. ''расширения классов''. Синтаксически, конструкция расширения практически не отличается от конструкции объявления класса, однако методы и свойства перечисленные в нем, дополняются к исходному классу, то есть наследования не происходит.<br />
<br />
Как правило, расширения применяются к классам [[Стандартной библиотека Gide|стандартной библиотеки]], либо к [[unmanaged код|неуправляемым классам]].<br />
<br />
В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же как при описании классов:<br />
<br />
<source lang="kpp" line="1"><br />
package intmod_fact;<br />
import std;<br />
external console_stream STDOUT;<br />
function void println(const string s) { STDOUT.print(s + "\n"); }<br />
<br />
extend int {<br />
const function ubigint GetFactorial() {<br />
var ubigint result = 1, int x;<br />
for (x = this; x > 1; --x)<br />
result *= x;<br />
return result;<br />
}<br />
property ubigint factorial read GetFactorial;<br />
}<br />
<br />
export function main() {<br />
println("Factorial of 10 is " + 10.factorial);<br />
}<br />
</source><br />
<br />
<br />
;6-14: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.<br />
<br />
;17: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. <!--Его мы вызываем с помощью специального синтаксиса, для передачи блока в качестве [[Функции#Аргументы|параметра функции]]. При этом, сам блок указывается прямо в коде вызова функции. Тело блока состоит из одного вызова функции, выводящей текущее число в стандартный поток вывода. --><br />
<br />
: Обратите внимание, что функция <tt>println()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|ubigint]]</tt>. В этом нет ничего странного, потому что класс <tt>ubigint</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt> передается в качестве параметра функции.<br />
<br />
<br />
'''Примечание:''' При работе с расширениями существует одно важное ограничение. Расширять классы можно только методами и свойствами, но не полями. Это связано с внутренней организацией языка К++ и виртуальной машины. Дополнительно стоит отметить, что методы объявленные в расширении будут перекрывать соответствующие им методы класса (имеется в виду ситуация когда имена и наборы параметров полностью совпадают). Важно понимать, что такое перекрытие не является объявлением виртуального метода — происходит именно замещение старого метода новым. <br />
<br />
== Смотри также ==</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8BКлассы и объекты2007-10-05T11:25:09Z<p>KroTozeR: /* Наследование */</p>
<hr />
<div>__TOC__<br />
<br />
== История развития ООП ==<br />
<br />
Для того чтобы понять, что же такое классы и объекты, сперва необходимо проследить историю развития программирования. А конкретнее, историю возникновения концепции ООП. Автор верит, что знание истории возникновения тех или иных мыслей и идей может помочь читателю осознать необходимость нововведений, и главное — их преимуществ перед существовавшими в то время решениями.<br />
<br />
=== Возникновение языков программирования ===<br />
<br />
На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.<br />
<br />
=== Появление ассемблера ===<br />
<br />
Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как ''язык'' общения человека и ЭВМ. Так появился первый язык программирования — ''язык ассемблера''. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа ''транслятор'', которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.<br />
<br />
=== Концепция языка высокого уровня ===<br />
<br />
...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами. <br />
<br />
Но время шло, количество приверженцев нового подхода постоянно увеличивалось. Сами же компиляторы становились все более мощными и генерировали все более компактный и оптимальный код. Дошло до того, что компилятор с оптимизатором в некоторых случаях генерировал код, более качественный, чем это делал программист. С этого момента ЯП высокого уровня заняли свое место в истории и в инструментарии любого разработчика.<br />
<br />
=== Структурное программирование ===<br />
<br />
С развитием языков программирования появились новые концепции и новые парадигмы программирования. От линейного моноблочного программирования, при котором программа писалась единым "куском" от начала до конца, перешли к программам модульным и структурным. При них программа представляла уже совокупность процедур (функций), которые вызывали друг друга в ходе работы программы. Процедуры представляли собой подпрограммы, решающие отдельные частные задачи. При этом код получался более читаемым, и облегчалась его отладка. <br />
<br />
Опять же, в ходе усложнения решаемых задач и, вследствие этого, увеличения количества переменных с которыми приходилось работать программисту, возникла идея группировки некоторых переменных в группы или структуры. Структуры формировались по назначению и содержали в себе переменные, имеющие отношение к одной и той же сущности. Это значительно повысило читаемость программ и уменьшило количество ошибок в них.<br />
<br />
=== Объектно-ориентированное программирование ===<br />
<br />
Ну и наконец, одна светлая голова додумалась до мысли: "а что если в структурах группировать не только переменные, но и сами процедуры которые должны работать с этими переменными?". В результате получилось то, что мы сейчас называем классом — то есть, некоторая обособленная функциональная сущность, которая сама хранит свои данные, а главное сама умеет их обрабатывать. Теперь программисту не нужно помнить, какая из процедур отвечает за некоторое действие над такими-то переменными — он просто берет объект и работает с ним. Все что происходит с объектом внутри — это его личное дело.<br />
<br />
Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.<br />
<br />
При написании программы на объектно-ориентированном языке, программист строит математическую модель взаимодействия различных сущностей. Каждая из сущностей это свой мир, у которого есть свои законы и особенности. При этом сущности могут быть как конкретные, вроде "сетевой интерфейс" или "файл", так и совершенно абстрактные, например "отношение" или "ошибка". Программист описывает каждую из сущностей в отдельности, обособлено от остальных. Вся необходимая для работы информация хранится внутри, а для взаимодействия с внешним миром предусмотрен ''интерфейс'' — некоторая совокупность ''свойств'' данной сущности (отражающих ее внутреннее состояние) и способов взаимодействия с ней — ''методов''.<br />
<br />
В ходе работы программы сущности могут взаимодействовать, читая и записывая свойства и вызывая методы друг друга, использовать друг друга как подсистемы, порождать новые сущности и т. д. Получается, что при написании программы, программист переносит свое внутреннее представление того как он видит эту программу, то из чего она состоит и как отдельные ее части взаимодействуют. Теперь не приходится адаптировать свое понимание проблемы к конкретным инструментальным средствам и возможностям языка программирования (конечно, это все же происходит, но уже гораздо менее заметно).<br />
<br />
В терминах современных языков программирования такие сущности называются ''классами'', в смысле ''классами сущностей''. А отдельные представители этих классов называются ''экземплярами'', ''инстанциями'' (на английский манер) или ''объектами''. Более подробно, различие между классами и объектами будет рассмотрено ниже.<br />
<br />
<br />
Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого). <br />
<br />
Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом <tt>int</tt> (целое число) и некоторым пользовательским классом <tt>MyWeirdClass</tt>: везде, где можно использовать <tt>int</tt>, можно использовать <tt>MyWeirdClass</tt> и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса <tt>int</tt>, равно как ничто не мешает определить математические операторы для класса <tt>MyWeirdClass</tt> и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!<br />
<br />
== Понятие класса ==<br />
<br />
Что такое ''класс'' проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды, растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем ''яблоки как понятие'', мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. С черенком, на котором остался листик, и маленькой червоточинкой". <br />
<br />
Разница заключается в том, что когда вы говорили ''о яблоках'', вы описывали свое представление яблок, как ''класса'' объектов. Когда вы описывали ''яблоко'', то вы имели в виду конкретный ''экземпляр'', или ''объект''. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода. <br />
<br />
Другой пример: если вас попросить "представьте дерево", то вы либо представите некоторое совершенно абстрактное, усредненное дерево, либо попросите уточнить, какое именно дерево имеется в виду. Ваше сознание из имеющейся информации смогло уяснить только самые общие сведения о классе. Но этой информации не достаточно, для более детального описания. Это тоже важно, поскольку в этом простом примере кроется сущность механизма наследования — постепенного уточнения классами-потомками общих черт своих предков. Таким образом, и яблоня, и груша — деревья. Но яблони отличаются от груш. Получается, что классы ''яблони'' и ''груши'' имеют общего предка — класс ''дерево''.<br />
<br />
Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.<br />
<br />
<br />
Из примеров выше мы смогли уяснить следующее:<br />
<br />
* Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов<br />
* Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности<br />
* Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными<br />
<br />
Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:<br />
<br />
С точки зрения языка, ''класс'' представляет собой набор следующих элементов:<br />
* ''полей'', т.е. переменных, хранящих индивидуальные особенности объектов, <br />
* ''методов'', т.е. функций, определяющих поведение данного объекта;<br />
* ''свойств'', определяющих взаимодействие других объектов с объектами данного класса.<br />
<br />
''Поля'' — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом, они могут хранить свое состояние (например, показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того чтобы частично разрешить этот доступ, применяются ''свойства''. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве [[lvalue]]).<br />
<br />
''Методы'' — это тот самый, связанный с данными код (вспомните [[Классы и объекты#История развития ООП|историю ООП]]) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.<br />
<br />
Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)<br />
<br />
Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью [[Спецификаторы доступа|спецификаторов доступа]]:<br />
<br />
* <tt>'''private'''</tt> — Частная собственность! Видимость только внутри методов данного класса<br />
* <tt>'''protected'''</tt> — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов<br />
* <tt>'''public'''</tt> — видимость и доступ для всех<br />
<br />
'''Примечание:''' По умолчанию методы имеют видимость <tt>'''private'''</tt>, в то время как свойства — <tt>'''public'''</tt>.<br />
<br />
Приведем, наконец, пример объявления класса:<br />
<br />
<source lang="kpp" line="1"><br />
class MyWeirdClass {<br />
var m_x = 0; // поле m_x, изначально проинициализированное нулем<br />
const m_y = 1; // поле-константа m_y<br />
<br />
// методы класса<br />
public const function int get_mul() { return m_x * m_y; }<br />
public function void set_mul(int x) { m_x = x / m_y; }<br />
<br />
// свойство класса<br />
public property mul read get_mul write set_mul;<br />
}<br />
</source><br />
<br />
<br />
;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.<br />
<br />
;3-4: Здесь мы видим объявление двух полей класса — переменной ''m_x'' и константы ''m_y'', которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе [[Константы]]. <br />
<br />
;7-8: Для доступа к состоянию объекта, определены два метода: ''аксессор'' <tt>get_mul()</tt> и ''мутатор'' <tt>set_mul()</tt>. Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.<br />
<br />
;11: Завершается объявление класса объявлением свойства ''mul'', которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызван аксессор, а результат его выполнения будет возвращен в качестве значения свойства. И, наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том, чтобы оно было "доставлено по адресу".<br />
<br />
: '''Примечание:''' Зачем нужны такие сложности, и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.<br />
<br />
== Понятие объекта ==<br />
<br />
Собственно, понятие объекта уже много раз было затронуто выше по повествованию. Поэтому здесь приведем лишь небольшое определение: Под ''объектом'' подразумевается экземпляр того или иного класса, т.е. некоторая сущность, поведение которой задается соответствующим классом.<br />
<br />
Для создания объекта того или иного класса служит оператор <tt>'''new'''</tt>:<br />
<source lang="kpp"><br />
var myWeirdObject = new MyWeirdClass;<br />
</source><br />
<br />
Здесь мы видим типичную конструкцию объявления переменной, однако в инициализаторе переменной находится всего один оператор, за которым следует [[идентификатор]] имени класса, экземпляр которого мы хотим создать.<br />
<br />
== Наследование ==<br />
<br />
Под ''наследованием'' классов понимается механизм такого создания (объявления) класса, при котором он расширяет функционал одного или нескольких уже существующих классов (родителей). Вспомните пример с деревьями. Когда мы говорим, что класс ''яблоня'' наследуется от класса ''дерево'' — это значит что ''яблоня'' унаследует все свойства своего класса-родителя, некоторые из которых он может изменить, ну и дополнить своими собственными свойствами. Опыт нам подсказывает, что у любого дерева есть листья (для простоты не будем вспоминать про хвойные), однако не любое дерево плодоносит яблоками. Если же рассмотреть сами яблоки, то можно сказать, что класс ''яблоко'' унаследован от класса ''фрукт'', который определяет что фрукты (и соответственно яблоки) должны расти на деревьях.<br />
<br />
Таким образом, наследование гарантирует, что к дочерним классам применимы все операции, доступные в родительском классе: любой алгоритм, работающий с объектами родительского класса, может работать с объектами его дочерних классов. <br />
<br />
Для задания наследования, в объявлении класса следует указать ключевое слово <tt>'''extends'''</tt>, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:<br />
<br />
<source lang="kpp" line="1"><br />
// коробка<br />
class Box { <br />
// из чего сделана коробка?<br />
public const function string material() { return "Картон"; }<br />
<br />
// что в коробке?<br />
public const function string contents() { return "Пусто"; }<br />
}<br />
<br />
// коробка с картошкой<br />
class BoxWithPotatoes extends Box { <br />
public const function string contents() { return "Картошка"; }<br />
}<br />
<br />
function OutputBox(const Box b) {<br />
STDOUT.print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");<br />
}<br />
<br />
function main() {<br />
var b1 = new Box;<br />
var b2 = new BoxWithPotatoes;<br />
OutputBox(b1); // Материал: Картон, содержит: Пусто<br />
OutputBox(b2); // Материал: Картон, содержит: Картошка<br />
}<br />
</source><br />
<br />
<br />
;2-7: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.<br />
<br />
;10-12: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.<br />
<br />
;14-16: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).<br />
<br />
;18-23: Объявляется функция <tt>main()</tt>, внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра ''b1'' и ''b2'' классов <tt>Box</tt> и <tt>BoxWithPotatoes</tt> соответственно. А затем, вызываем вышеописанную функцию <tt>OutputBox()</tt>, которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает, как это все работает.<br />
<br />
'''Примечание:''' при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако его можно обойти с помощью создания [[Класс-обертка|классов-оберток]] для системного класса, с последующим наследованием от него нового класса.<br />
<br />
== Методы ==<br />
<br />
''Метод'' — это некоторый код, связанный с объектом и управляющий его поведением. Управление может заключаться в изменении переменных постояния объекта (полей), либо выполнением некоторых операций над ними.<br />
<br />
При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:<br />
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода<br />
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод не изменяет объект<br />
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять<br />
<br />
После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].<br />
<br />
Тело метода может быть объявлено как непосредственно в теле класса, так и вынесено за его пределы, например:<br />
<br />
<source lang="kpp" line="1"><br />
class MyClass {<br />
public const function string F1() { return "smth"; }<br />
public const function string F2();<br />
}<br />
<br />
function string MyClass::F2() {<br />
return F1();<br />
}<br />
</source><br />
<br />
<br />
;6: При вынесении функции за пределы класса, имя соответствующего метода предворяется именем класса из которого он был вынесен; имена отделяются друг от друга символом "двойное двоеточие" ( <tt>::</tt> ); дополнительно — в заголовке вынесенной функции необходимо указать тип возвращаемого значения и параметры функции, все остальные ключевые слова указывать не обязательно.<br />
<br />
;7: В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в коде приведенном выше, метод <tt>F2()</tt> вызывает метод <tt>F1()</tt> для того же объекта.<br />
<br />
=== Статические методы ===<br />
<br />
''Статический метод класса'' — это метод, относящиеся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.<br />
<br />
При объявлении статического метода нужно указать ключевое слово <tt>'''static'''</tt>.<br />
<br />
В теле статического метода нет возможности напрямую обращаться к другим методам данного класса, т.к. статическому методу недоступен объект класса. Фактически, единственным отличием статического метода от обычной функции является то, что такой метод может обращаться к защищенным полям и методам класса некоторого другого объекта. Подобный подход широко применяется при написании ''конструкторов'' (см. ниже).<br />
<br />
Пример:<br />
<source lang="kpp"><br />
class MyClass {<br />
public static function string Info() { return "Я MyClass!"; }<br />
}<br />
<br />
function f() {<br />
// Вызов статического метода:<br />
var myClassInfo = MyClass.Info();<br />
}<br />
</source><br />
<br />
=== Конструкторы ===<br />
<br />
В ходе написания программы часто приходится создавать новые объекты. При этом, объекту требуется установить некоторое начальное состояние. Разумеется, это выполняется либо путем написания инициализаторов соответствующих полей, либо занчения полям присваиваются явным образом. Но что делать, если объект может иметь несколько начальных состояний? То есть, в зависимости от некоторых условий, одним и тем же полям объекта могут быть присвоены различные наборы значений. Тут уже одними инициализаторами не обойтись. Присваивать значения можно прямо в коде программы, однако это не очень красивое решение, поскольку один и тот же объект может создаваться в нескольких местах программы и придется копировать один и тот же участок кода, инициализирующий поля объекта. Недостаток этого подхода в том, что при большом количестве полей, программист может забыть проинициализировать некоторе поле, либо при изменении условий инициализации он может изменить их только в одном месте программы, забыв что объект может создаваться и в других местах. Более разумным является подход, при котором программист пишет функцию, инициализирующую поля объекта. При этом, весь код собирается в одном месте и вероятность ошибок значительно понижается. <br />
<br />
Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код относящийся к созданию инстанции класса. Итак, ''конструктор класса'' — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.<br />
<br />
Таким образом, следующие объявления в рамках класса эквивалентны:<br />
<source lang="kpp"><br />
public constructor Create();<br />
public static MyClass Create();<br />
</source><br />
<br />
Тело конструктора чаще всего выглядит следующим образом: сначала создается экземпляр класса при помощи оператора <tt>'''new'''</tt>, затем производятся некоторые действия, инициализующие этот объект, и, наконец, этот объект возвращается в качестве результата. <br />
<br />
В качестве примера приведем пример реализации некоторого абстрактного класса <tt>MyStream</tt>, использующего системную реализацию класса <tt>stream</tt>, и определяющую собственный конструктор:<br />
<br />
<source lang="kpp" line="1"><br />
class MyStream {<br />
var string m_URL;<br />
var stream m_Stream;<br />
public:<br />
static const MODE_READ = 1;<br />
static const MODE_WRITE = 2;<br />
constructor open(const string url, int mode) {<br />
var self = new MyStream;<br />
self.m_Stream.open(url, mode);<br />
self.m_URL = url;<br />
return self;<br />
}<br />
// прочие методы (опущены для краткости)<br />
}<br />
</source><br />
<br />
<br />
;2-3: Объявляются поля ''m_URL'' и ''m_Stream'' нашего класса, которые будут инициализироваться в конструкторе. <br />
<br />
;5-6: В публичной области класса объявляются статические константы ''MODE_READ'' и ''MODE_WRITE'', которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.<br />
<br />
;7: Объявляется конструктор <tt>open()</tt>, принимающий в качестве параметров [[URL]] ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию ''self'' нашего класса. Затем производится попытка открытия потока ''m_Stream'': если операция пройдет успешно, то происходит инициализация оставшегося поля ''m_URL'' и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано ''[[Обработка исключений|исключение]]'' и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).<br />
<br />
<br />
Использовать наш класс можно примерно так:<br />
<source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source><br />
<br />
Обратите внимание на второй параметр функции, где мы передаем константу ''MODE_READ'', объявленную внутри самого класса. Подобный подход, когда константы используемые при работе с классом инкапсулируются в тело класса, помогает сконцентрировать код в одном месте и избежать многих ошибок. В результате повышается читаемость кода и не возникает конфликта имен констант.<br />
<br />
== Поля ==<br />
<br />
Поле класса — это некоторый объект, используемый объектом данного класса.<br />
<br />
Объявление поля начинается с одного из трех ключевых слов:<br />
* <tt>'''var'''</tt> — объявление "обычного" поля;<br />
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;<br />
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.<br />
<br />
За ключевым словом следует тип поля и [[идентификатор]] его имени. Тип поля может быть опущен. После имени может стоять символ "=" и выражение, инициализирующее значение данного поля. В целом, синтаксис тот же, что и при объявлении обычной переменой или константы:<br />
<br />
<source lang="kpp"><br />
var int m_x;<br />
const m_y = 0;<br />
var m_stream = new stream;<br />
</source><br />
<br />
Тип поля определяется по следующим правилам:<br />
* если тип указан явно, ничего определять не надо;<br />
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;<br />
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].<br />
<br />
'''Примечание:''' В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать ''свойства'' (см. ниже).<br />
<br />
== Свойства ==<br />
<br />
''Свойства'' — это специальные конструкции языка К++, которые позволяют совмещать обращение к данным с вызовом определенного метода. Смысл свойств заключается в том, чтобы программист мог контролировать процесс изменения состояния объекта и своевременно реагировать на это изменение. Свойства бывают доступны на чтение, на запись, или на чтение и на запись одновременно. Это связано с тем, что некоторые свойства объекта (в естественном понимании этого слова), могут предполагать только получение информации о них, другие же могут подразумевать изменение состояния, без возможности чтения. <br />
<br />
В существующих языках программирования, таких как C++ тот же функционал реализуется с помощью вызова специальных методов: ''аксессоров'' и ''мутаторов'', которые используются для получения сведений о некотором свойстве или для записи соответственно. Однако, это делает код менее читаемым, особенно в случае мутаторов. Свойства же, позволяют работать с собой подобно обычным полям или объектам, используя операторы. <br />
<br />
Приведем два примера, которые позволят понять смысл свойств и их отличие от обычных полей класса.<br />
<br />
Предположим, что у нас есть класс, отвечающий за чтение состояния некоторого устройства. Допустим, состояние представляется целым числом и должно определяться по мере обращения. Если бы мы писали на языке C++, то мы оформили бы это в виде метода:<br />
<br />
<source lang="cpp"><br />
class MyDevice {<br />
int GetState();<br />
};<br />
</source><br />
<br />
Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:<br />
<br />
<source lang="cpp"><br />
int current_state = Device.GetState();<br />
</source><br />
<br />
В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++: <br />
<br />
<source lang="kpp"><br />
class MyDevice {<br />
function int GetState();<br />
property int state read GetState;<br />
}<br />
</source><br />
<br />
Соответственно, обращение к свойству состояния будет выглядеть так:<br />
<br />
<source lang="kpp"><br />
var current_state = Device.state;<br />
</source><br />
<br />
При обращении к свойству <tt>state</tt> будет автоматически вызыван метод <tt>GetState()</tt>, результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:<br />
<br />
<source lang="cpp"><br />
Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus());<br />
printf("object %s (%d) located at %s : status changed to %u", <br />
Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());<br />
</source><br />
<br />
<source lang="kpp"><br />
Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status;<br />
println("object % (%) located at % : status changed to %", <br />
Object1.name, Object1.index, Object1.location, Object1.status);<br />
</source><br />
<br />
В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находится в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по разному обрабатывать и отрисовывать этот элемент управления.<br />
<br />
В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:<br />
<br />
<source lang="kpp" line="1"><br />
class Widget {<br />
var m_Enabled = true; //поле, хранящее текущее состояние активности<br />
function void SetEnabled(const value) {<br />
var old_value = m_Enabled;<br />
m_Enabled = value;<br />
if (old_value != m_Enabled)<br />
Invalidate(); //Состояние изменилось, обновляем элемент управления<br />
}<br />
property enabled read m_Enabled write SetEnabled;<br />
//далее идет остальная часть класса, например методы отрисовки<br />
}<br />
</source><br />
<br />
Теперь, если мы унаследуем некоторый класс от данного класса и переопределим соответствующие методы отрисовки, то у класса потомка так же можно будет использовать свойство <tt>enabled</tt>:<br />
<br />
<source lang="kpp"><br />
var myForm = new Form; //создаем окно<br />
var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку<br />
myButton.caption = "Click me!"; //устанавливаем подпись<br />
myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события<br />
myForm.Show(); //показываем окно<br />
</source><br />
<br />
Приведенный выше код создаст окно и разместит на нем кнопку (подразумевается, что класс <tt>Button</tt> унаследован от нашего класса <tt>Widget</tt>). Затем устанавливаются свойства кнопки, такие как подпись и [[Блоки|блок]] обработчика события <tt>OnClick</tt>. При нажатии на кнопку она станет неактивной.<br />
<br />
<br />
----<br />
<br />
<br />
В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства. <br />
<br />
Оставшаяся часть зависит от того, какое свойство объявляется:<br />
<br />
* Если объявляется свойство на чтение, то указывается ключевое слово <tt>'''read'''</tt>, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как ''аксессор''. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.<br />
* Если объявляется свойство на запись, то указывается, соответственно ключевое слово <tt>'''write'''</tt> после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как ''мутатор''. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.<br />
* Если объявляется свойство, доступное как на чтение так и на запись, то указываются обе части, причем первой идет часть чтения.<br />
<br />
<br />
'''Примечание:''' Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция [[Приведение типов|приведения типов]]. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.<br />
<br />
Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки:<br />
<source lang="kpp"><br />
property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>];<br />
</source><br />
<br />
== Расширения ==<br />
<br />
Иногда бывает необходимо расширить функциональность некоторого существующего класса без порождения дочернего класса. Это может быть необходимо в тех случаях, когда исходный класс уже используется в коде программы и порождение нового класса нарушило бы спецификацию на интерфейс, либо потребовало значительных изменений в исходных текстах программы. В таких случаях целесообразно применять т. н. ''расширения классов''. Синтаксически, конструкция расширения практически не отличается от конструкции объявления класса, однако методы и свойства перечисленные в нем, дополняются к исходному классу, то есть наследования не происходит.<br />
<br />
Как правило, расширения применяются к классам [[Стандартной библиотека Gide|стандартной библиотеки]], либо к [[unmanaged код|неуправляемым классам]].<br />
<br />
В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же как при описании классов:<br />
<br />
<source lang="kpp" line="1"><br />
package intmod_fact;<br />
import std;<br />
external console_stream STDOUT;<br />
function void println(const string s) { STDOUT.print(s + "\n"); }<br />
<br />
extend int {<br />
const function ubigint GetFactorial() {<br />
var ubigint result = 1, int x;<br />
for (x = this; x > 1; --x)<br />
result *= x;<br />
return result;<br />
}<br />
property ubigint factorial read GetFactorial;<br />
}<br />
<br />
export function main() {<br />
println("Factorial of 10 is " + 10.factorial);<br />
}<br />
</source><br />
<br />
<br />
;6-14: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.<br />
<br />
;17: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. <!--Его мы вызываем с помощью специального синтаксиса, для передачи блока в качестве [[Функции#Аргументы|параметра функции]]. При этом, сам блок указывается прямо в коде вызова функции. Тело блока состоит из одного вызова функции, выводящей текущее число в стандартный поток вывода. --><br />
<br />
: Обратите внимание, что функция <tt>println()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|ubigint]]</tt>. В этом нет ничего странного, потому что класс <tt>ubigint</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt> передается в качестве параметра функции.<br />
<br />
<br />
'''Примечание:''' При работе с расширениями существует одно важное ограничение. Расширять классы можно только методами и свойствами, но не полями. Это связано с внутренней организацией языка К++ и виртуальной машины. Дополнительно стоит отметить, что методы объявленные в расширении будут перекрывать соответствующие им методы класса (имеется в виду ситуация когда имена и наборы параметров полностью совпадают). Важно понимать, что такое перекрытие не является объявлением виртуального метода — происходит именно замещение старого метода новым. <br />
<br />
== Смотри также ==</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8BКлассы и объекты2007-10-05T11:22:26Z<p>KroTozeR: /* Понятие класса */</p>
<hr />
<div>__TOC__<br />
<br />
== История развития ООП ==<br />
<br />
Для того чтобы понять, что же такое классы и объекты, сперва необходимо проследить историю развития программирования. А конкретнее, историю возникновения концепции ООП. Автор верит, что знание истории возникновения тех или иных мыслей и идей может помочь читателю осознать необходимость нововведений, и главное — их преимуществ перед существовавшими в то время решениями.<br />
<br />
=== Возникновение языков программирования ===<br />
<br />
На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.<br />
<br />
=== Появление ассемблера ===<br />
<br />
Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как ''язык'' общения человека и ЭВМ. Так появился первый язык программирования — ''язык ассемблера''. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа ''транслятор'', которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.<br />
<br />
=== Концепция языка высокого уровня ===<br />
<br />
...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами. <br />
<br />
Но время шло, количество приверженцев нового подхода постоянно увеличивалось. Сами же компиляторы становились все более мощными и генерировали все более компактный и оптимальный код. Дошло до того, что компилятор с оптимизатором в некоторых случаях генерировал код, более качественный, чем это делал программист. С этого момента ЯП высокого уровня заняли свое место в истории и в инструментарии любого разработчика.<br />
<br />
=== Структурное программирование ===<br />
<br />
С развитием языков программирования появились новые концепции и новые парадигмы программирования. От линейного моноблочного программирования, при котором программа писалась единым "куском" от начала до конца, перешли к программам модульным и структурным. При них программа представляла уже совокупность процедур (функций), которые вызывали друг друга в ходе работы программы. Процедуры представляли собой подпрограммы, решающие отдельные частные задачи. При этом код получался более читаемым, и облегчалась его отладка. <br />
<br />
Опять же, в ходе усложнения решаемых задач и, вследствие этого, увеличения количества переменных с которыми приходилось работать программисту, возникла идея группировки некоторых переменных в группы или структуры. Структуры формировались по назначению и содержали в себе переменные, имеющие отношение к одной и той же сущности. Это значительно повысило читаемость программ и уменьшило количество ошибок в них.<br />
<br />
=== Объектно-ориентированное программирование ===<br />
<br />
Ну и наконец, одна светлая голова додумалась до мысли: "а что если в структурах группировать не только переменные, но и сами процедуры которые должны работать с этими переменными?". В результате получилось то, что мы сейчас называем классом — то есть, некоторая обособленная функциональная сущность, которая сама хранит свои данные, а главное сама умеет их обрабатывать. Теперь программисту не нужно помнить, какая из процедур отвечает за некоторое действие над такими-то переменными — он просто берет объект и работает с ним. Все что происходит с объектом внутри — это его личное дело.<br />
<br />
Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.<br />
<br />
При написании программы на объектно-ориентированном языке, программист строит математическую модель взаимодействия различных сущностей. Каждая из сущностей это свой мир, у которого есть свои законы и особенности. При этом сущности могут быть как конкретные, вроде "сетевой интерфейс" или "файл", так и совершенно абстрактные, например "отношение" или "ошибка". Программист описывает каждую из сущностей в отдельности, обособлено от остальных. Вся необходимая для работы информация хранится внутри, а для взаимодействия с внешним миром предусмотрен ''интерфейс'' — некоторая совокупность ''свойств'' данной сущности (отражающих ее внутреннее состояние) и способов взаимодействия с ней — ''методов''.<br />
<br />
В ходе работы программы сущности могут взаимодействовать, читая и записывая свойства и вызывая методы друг друга, использовать друг друга как подсистемы, порождать новые сущности и т. д. Получается, что при написании программы, программист переносит свое внутреннее представление того как он видит эту программу, то из чего она состоит и как отдельные ее части взаимодействуют. Теперь не приходится адаптировать свое понимание проблемы к конкретным инструментальным средствам и возможностям языка программирования (конечно, это все же происходит, но уже гораздо менее заметно).<br />
<br />
В терминах современных языков программирования такие сущности называются ''классами'', в смысле ''классами сущностей''. А отдельные представители этих классов называются ''экземплярами'', ''инстанциями'' (на английский манер) или ''объектами''. Более подробно, различие между классами и объектами будет рассмотрено ниже.<br />
<br />
<br />
Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого). <br />
<br />
Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом <tt>int</tt> (целое число) и некоторым пользовательским классом <tt>MyWeirdClass</tt>: везде, где можно использовать <tt>int</tt>, можно использовать <tt>MyWeirdClass</tt> и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса <tt>int</tt>, равно как ничто не мешает определить математические операторы для класса <tt>MyWeirdClass</tt> и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!<br />
<br />
== Понятие класса ==<br />
<br />
Что такое ''класс'' проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды, растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем ''яблоки как понятие'', мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. С черенком, на котором остался листик, и маленькой червоточинкой". <br />
<br />
Разница заключается в том, что когда вы говорили ''о яблоках'', вы описывали свое представление яблок, как ''класса'' объектов. Когда вы описывали ''яблоко'', то вы имели в виду конкретный ''экземпляр'', или ''объект''. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода. <br />
<br />
Другой пример: если вас попросить "представьте дерево", то вы либо представите некоторое совершенно абстрактное, усредненное дерево, либо попросите уточнить, какое именно дерево имеется в виду. Ваше сознание из имеющейся информации смогло уяснить только самые общие сведения о классе. Но этой информации не достаточно, для более детального описания. Это тоже важно, поскольку в этом простом примере кроется сущность механизма наследования — постепенного уточнения классами-потомками общих черт своих предков. Таким образом, и яблоня, и груша — деревья. Но яблони отличаются от груш. Получается, что классы ''яблони'' и ''груши'' имеют общего предка — класс ''дерево''.<br />
<br />
Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.<br />
<br />
<br />
Из примеров выше мы смогли уяснить следующее:<br />
<br />
* Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов<br />
* Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности<br />
* Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными<br />
<br />
Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:<br />
<br />
С точки зрения языка, ''класс'' представляет собой набор следующих элементов:<br />
* ''полей'', т.е. переменных, хранящих индивидуальные особенности объектов, <br />
* ''методов'', т.е. функций, определяющих поведение данного объекта;<br />
* ''свойств'', определяющих взаимодействие других объектов с объектами данного класса.<br />
<br />
''Поля'' — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом, они могут хранить свое состояние (например, показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того чтобы частично разрешить этот доступ, применяются ''свойства''. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве [[lvalue]]).<br />
<br />
''Методы'' — это тот самый, связанный с данными код (вспомните [[Классы и объекты#История развития ООП|историю ООП]]) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.<br />
<br />
Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)<br />
<br />
Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью [[Спецификаторы доступа|спецификаторов доступа]]:<br />
<br />
* <tt>'''private'''</tt> — Частная собственность! Видимость только внутри методов данного класса<br />
* <tt>'''protected'''</tt> — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов<br />
* <tt>'''public'''</tt> — видимость и доступ для всех<br />
<br />
'''Примечание:''' По умолчанию методы имеют видимость <tt>'''private'''</tt>, в то время как свойства — <tt>'''public'''</tt>.<br />
<br />
Приведем, наконец, пример объявления класса:<br />
<br />
<source lang="kpp" line="1"><br />
class MyWeirdClass {<br />
var m_x = 0; // поле m_x, изначально проинициализированное нулем<br />
const m_y = 1; // поле-константа m_y<br />
<br />
// методы класса<br />
public const function int get_mul() { return m_x * m_y; }<br />
public function void set_mul(int x) { m_x = x / m_y; }<br />
<br />
// свойство класса<br />
public property mul read get_mul write set_mul;<br />
}<br />
</source><br />
<br />
<br />
;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.<br />
<br />
;3-4: Здесь мы видим объявление двух полей класса — переменной ''m_x'' и константы ''m_y'', которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе [[Константы]]. <br />
<br />
;7-8: Для доступа к состоянию объекта, определены два метода: ''аксессор'' <tt>get_mul()</tt> и ''мутатор'' <tt>set_mul()</tt>. Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.<br />
<br />
;11: Завершается объявление класса объявлением свойства ''mul'', которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызван аксессор, а результат его выполнения будет возвращен в качестве значения свойства. И, наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том, чтобы оно было "доставлено по адресу".<br />
<br />
: '''Примечание:''' Зачем нужны такие сложности, и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.<br />
<br />
== Понятие объекта ==<br />
<br />
Собственно, понятие объекта уже много раз было затронуто выше по повествованию. Поэтому здесь приведем лишь небольшое определение: Под ''объектом'' подразумевается экземпляр того или иного класса, т.е. некоторая сущность, поведение которой задается соответствующим классом.<br />
<br />
Для создания объекта того или иного класса служит оператор <tt>'''new'''</tt>:<br />
<source lang="kpp"><br />
var myWeirdObject = new MyWeirdClass;<br />
</source><br />
<br />
Здесь мы видим типичную конструкцию объявления переменной, однако в инициализаторе переменной находится всего один оператор, за которым следует [[идентификатор]] имени класса, экземпляр которого мы хотим создать.<br />
<br />
== Наследование ==<br />
<br />
Под ''наследованием'' классов понимается механизм такого создания (объявления) класса, при котором он расширяет функционал одного или нескольких уже существующих классов (родителей). Вспомните пример с деревьями. Когда мы говорим, что класс ''яблоня'' наследуется от класса ''дерево'' — это значит что ''яблоня'' унаследует все свойства своего класса-родителя, некоторые из которых он может изменить, ну и дополнить своими собственными свойствами. Опыт нам подсказывает, что у любого дерева есть листья (для простоты не будем вспоминать про хвойные), однако не любое дерево плодоносит яблоками. Если же рассмотреть сами яблоки, то можно сказать, что класс ''яблоко'' унаследован от класса ''фрукт'', который определяет что фрукты (и соответственно яблоки) должны расти на деревьях.<br />
<br />
Таким образом, наследование гарантирует, что к дочерним классам применимы все операции, доступные в родительском классе: любой алгоритм, работающий с объектами родительского класса, может работать с объектами его дочерних классов. <br />
<br />
Для задания наследования, в объявлении класса следует указать ключевое слово <tt>'''extends'''</tt>, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:<br />
<br />
<source lang="kpp" line="1"><br />
// коробка<br />
class Box { <br />
// из чего сделана коробка?<br />
public const function string material() { return "Картон"; }<br />
<br />
// что в коробке?<br />
public const function string contents() { return "Пусто"; }<br />
}<br />
<br />
// коробка с картошкой<br />
class BoxWithPotatoes extends Box { <br />
public const function string contents() { return "Картошка"; }<br />
}<br />
<br />
function OutputBox(const Box b) {<br />
STDOUT.print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");<br />
}<br />
<br />
function main() {<br />
var b1 = new Box;<br />
var b2 = new BoxWithPotatoes;<br />
OutputBox(b1); // Материал: Картон, содержит: Пусто<br />
OutputBox(b2); // Материал: Картон, содержит: Картошка<br />
}<br />
</source><br />
<br />
<br />
;2-7: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.<br />
<br />
;10-12: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.<br />
<br />
;14-16: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом, мы предполагаем что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).<br />
<br />
;18-23: Объявляется функция <tt>main()</tt>, внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра ''b1'' и ''b2'' классов <tt>Box</tt> и <tt>BoxWithPotatoes</tt> соответственно. А затем, вызываем вышеописанную функцию <tt>OutputBox()</tt>, которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает как это все работает.<br />
<br />
'''Примечание:''' при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако, его можно обойти с помощью создания [[Класс-обертка|классов-оберток]] для системного класса, с последующим наследованием от него нового класса.<br />
<br />
== Методы ==<br />
<br />
''Метод'' — это некоторый код, связанный с объектом и управляющий его поведением. Управление может заключаться в изменении переменных постояния объекта (полей), либо выполнением некоторых операций над ними.<br />
<br />
При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:<br />
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода<br />
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод не изменяет объект<br />
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять<br />
<br />
После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].<br />
<br />
Тело метода может быть объявлено как непосредственно в теле класса, так и вынесено за его пределы, например:<br />
<br />
<source lang="kpp" line="1"><br />
class MyClass {<br />
public const function string F1() { return "smth"; }<br />
public const function string F2();<br />
}<br />
<br />
function string MyClass::F2() {<br />
return F1();<br />
}<br />
</source><br />
<br />
<br />
;6: При вынесении функции за пределы класса, имя соответствующего метода предворяется именем класса из которого он был вынесен; имена отделяются друг от друга символом "двойное двоеточие" ( <tt>::</tt> ); дополнительно — в заголовке вынесенной функции необходимо указать тип возвращаемого значения и параметры функции, все остальные ключевые слова указывать не обязательно.<br />
<br />
;7: В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в коде приведенном выше, метод <tt>F2()</tt> вызывает метод <tt>F1()</tt> для того же объекта.<br />
<br />
=== Статические методы ===<br />
<br />
''Статический метод класса'' — это метод, относящиеся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.<br />
<br />
При объявлении статического метода нужно указать ключевое слово <tt>'''static'''</tt>.<br />
<br />
В теле статического метода нет возможности напрямую обращаться к другим методам данного класса, т.к. статическому методу недоступен объект класса. Фактически, единственным отличием статического метода от обычной функции является то, что такой метод может обращаться к защищенным полям и методам класса некоторого другого объекта. Подобный подход широко применяется при написании ''конструкторов'' (см. ниже).<br />
<br />
Пример:<br />
<source lang="kpp"><br />
class MyClass {<br />
public static function string Info() { return "Я MyClass!"; }<br />
}<br />
<br />
function f() {<br />
// Вызов статического метода:<br />
var myClassInfo = MyClass.Info();<br />
}<br />
</source><br />
<br />
=== Конструкторы ===<br />
<br />
В ходе написания программы часто приходится создавать новые объекты. При этом, объекту требуется установить некоторое начальное состояние. Разумеется, это выполняется либо путем написания инициализаторов соответствующих полей, либо занчения полям присваиваются явным образом. Но что делать, если объект может иметь несколько начальных состояний? То есть, в зависимости от некоторых условий, одним и тем же полям объекта могут быть присвоены различные наборы значений. Тут уже одними инициализаторами не обойтись. Присваивать значения можно прямо в коде программы, однако это не очень красивое решение, поскольку один и тот же объект может создаваться в нескольких местах программы и придется копировать один и тот же участок кода, инициализирующий поля объекта. Недостаток этого подхода в том, что при большом количестве полей, программист может забыть проинициализировать некоторе поле, либо при изменении условий инициализации он может изменить их только в одном месте программы, забыв что объект может создаваться и в других местах. Более разумным является подход, при котором программист пишет функцию, инициализирующую поля объекта. При этом, весь код собирается в одном месте и вероятность ошибок значительно понижается. <br />
<br />
Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код относящийся к созданию инстанции класса. Итак, ''конструктор класса'' — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.<br />
<br />
Таким образом, следующие объявления в рамках класса эквивалентны:<br />
<source lang="kpp"><br />
public constructor Create();<br />
public static MyClass Create();<br />
</source><br />
<br />
Тело конструктора чаще всего выглядит следующим образом: сначала создается экземпляр класса при помощи оператора <tt>'''new'''</tt>, затем производятся некоторые действия, инициализующие этот объект, и, наконец, этот объект возвращается в качестве результата. <br />
<br />
В качестве примера приведем пример реализации некоторого абстрактного класса <tt>MyStream</tt>, использующего системную реализацию класса <tt>stream</tt>, и определяющую собственный конструктор:<br />
<br />
<source lang="kpp" line="1"><br />
class MyStream {<br />
var string m_URL;<br />
var stream m_Stream;<br />
public:<br />
static const MODE_READ = 1;<br />
static const MODE_WRITE = 2;<br />
constructor open(const string url, int mode) {<br />
var self = new MyStream;<br />
self.m_Stream.open(url, mode);<br />
self.m_URL = url;<br />
return self;<br />
}<br />
// прочие методы (опущены для краткости)<br />
}<br />
</source><br />
<br />
<br />
;2-3: Объявляются поля ''m_URL'' и ''m_Stream'' нашего класса, которые будут инициализироваться в конструкторе. <br />
<br />
;5-6: В публичной области класса объявляются статические константы ''MODE_READ'' и ''MODE_WRITE'', которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.<br />
<br />
;7: Объявляется конструктор <tt>open()</tt>, принимающий в качестве параметров [[URL]] ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию ''self'' нашего класса. Затем производится попытка открытия потока ''m_Stream'': если операция пройдет успешно, то происходит инициализация оставшегося поля ''m_URL'' и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано ''[[Обработка исключений|исключение]]'' и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).<br />
<br />
<br />
Использовать наш класс можно примерно так:<br />
<source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source><br />
<br />
Обратите внимание на второй параметр функции, где мы передаем константу ''MODE_READ'', объявленную внутри самого класса. Подобный подход, когда константы используемые при работе с классом инкапсулируются в тело класса, помогает сконцентрировать код в одном месте и избежать многих ошибок. В результате повышается читаемость кода и не возникает конфликта имен констант.<br />
<br />
== Поля ==<br />
<br />
Поле класса — это некоторый объект, используемый объектом данного класса.<br />
<br />
Объявление поля начинается с одного из трех ключевых слов:<br />
* <tt>'''var'''</tt> — объявление "обычного" поля;<br />
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;<br />
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.<br />
<br />
За ключевым словом следует тип поля и [[идентификатор]] его имени. Тип поля может быть опущен. После имени может стоять символ "=" и выражение, инициализирующее значение данного поля. В целом, синтаксис тот же, что и при объявлении обычной переменой или константы:<br />
<br />
<source lang="kpp"><br />
var int m_x;<br />
const m_y = 0;<br />
var m_stream = new stream;<br />
</source><br />
<br />
Тип поля определяется по следующим правилам:<br />
* если тип указан явно, ничего определять не надо;<br />
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;<br />
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].<br />
<br />
'''Примечание:''' В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать ''свойства'' (см. ниже).<br />
<br />
== Свойства ==<br />
<br />
''Свойства'' — это специальные конструкции языка К++, которые позволяют совмещать обращение к данным с вызовом определенного метода. Смысл свойств заключается в том, чтобы программист мог контролировать процесс изменения состояния объекта и своевременно реагировать на это изменение. Свойства бывают доступны на чтение, на запись, или на чтение и на запись одновременно. Это связано с тем, что некоторые свойства объекта (в естественном понимании этого слова), могут предполагать только получение информации о них, другие же могут подразумевать изменение состояния, без возможности чтения. <br />
<br />
В существующих языках программирования, таких как C++ тот же функционал реализуется с помощью вызова специальных методов: ''аксессоров'' и ''мутаторов'', которые используются для получения сведений о некотором свойстве или для записи соответственно. Однако, это делает код менее читаемым, особенно в случае мутаторов. Свойства же, позволяют работать с собой подобно обычным полям или объектам, используя операторы. <br />
<br />
Приведем два примера, которые позволят понять смысл свойств и их отличие от обычных полей класса.<br />
<br />
Предположим, что у нас есть класс, отвечающий за чтение состояния некоторого устройства. Допустим, состояние представляется целым числом и должно определяться по мере обращения. Если бы мы писали на языке C++, то мы оформили бы это в виде метода:<br />
<br />
<source lang="cpp"><br />
class MyDevice {<br />
int GetState();<br />
};<br />
</source><br />
<br />
Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:<br />
<br />
<source lang="cpp"><br />
int current_state = Device.GetState();<br />
</source><br />
<br />
В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++: <br />
<br />
<source lang="kpp"><br />
class MyDevice {<br />
function int GetState();<br />
property int state read GetState;<br />
}<br />
</source><br />
<br />
Соответственно, обращение к свойству состояния будет выглядеть так:<br />
<br />
<source lang="kpp"><br />
var current_state = Device.state;<br />
</source><br />
<br />
При обращении к свойству <tt>state</tt> будет автоматически вызыван метод <tt>GetState()</tt>, результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:<br />
<br />
<source lang="cpp"><br />
Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus());<br />
printf("object %s (%d) located at %s : status changed to %u", <br />
Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());<br />
</source><br />
<br />
<source lang="kpp"><br />
Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status;<br />
println("object % (%) located at % : status changed to %", <br />
Object1.name, Object1.index, Object1.location, Object1.status);<br />
</source><br />
<br />
В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находится в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по разному обрабатывать и отрисовывать этот элемент управления.<br />
<br />
В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:<br />
<br />
<source lang="kpp" line="1"><br />
class Widget {<br />
var m_Enabled = true; //поле, хранящее текущее состояние активности<br />
function void SetEnabled(const value) {<br />
var old_value = m_Enabled;<br />
m_Enabled = value;<br />
if (old_value != m_Enabled)<br />
Invalidate(); //Состояние изменилось, обновляем элемент управления<br />
}<br />
property enabled read m_Enabled write SetEnabled;<br />
//далее идет остальная часть класса, например методы отрисовки<br />
}<br />
</source><br />
<br />
Теперь, если мы унаследуем некоторый класс от данного класса и переопределим соответствующие методы отрисовки, то у класса потомка так же можно будет использовать свойство <tt>enabled</tt>:<br />
<br />
<source lang="kpp"><br />
var myForm = new Form; //создаем окно<br />
var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку<br />
myButton.caption = "Click me!"; //устанавливаем подпись<br />
myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события<br />
myForm.Show(); //показываем окно<br />
</source><br />
<br />
Приведенный выше код создаст окно и разместит на нем кнопку (подразумевается, что класс <tt>Button</tt> унаследован от нашего класса <tt>Widget</tt>). Затем устанавливаются свойства кнопки, такие как подпись и [[Блоки|блок]] обработчика события <tt>OnClick</tt>. При нажатии на кнопку она станет неактивной.<br />
<br />
<br />
----<br />
<br />
<br />
В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства. <br />
<br />
Оставшаяся часть зависит от того, какое свойство объявляется:<br />
<br />
* Если объявляется свойство на чтение, то указывается ключевое слово <tt>'''read'''</tt>, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как ''аксессор''. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.<br />
* Если объявляется свойство на запись, то указывается, соответственно ключевое слово <tt>'''write'''</tt> после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как ''мутатор''. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.<br />
* Если объявляется свойство, доступное как на чтение так и на запись, то указываются обе части, причем первой идет часть чтения.<br />
<br />
<br />
'''Примечание:''' Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция [[Приведение типов|приведения типов]]. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.<br />
<br />
Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки:<br />
<source lang="kpp"><br />
property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>];<br />
</source><br />
<br />
== Расширения ==<br />
<br />
Иногда бывает необходимо расширить функциональность некоторого существующего класса без порождения дочернего класса. Это может быть необходимо в тех случаях, когда исходный класс уже используется в коде программы и порождение нового класса нарушило бы спецификацию на интерфейс, либо потребовало значительных изменений в исходных текстах программы. В таких случаях целесообразно применять т. н. ''расширения классов''. Синтаксически, конструкция расширения практически не отличается от конструкции объявления класса, однако методы и свойства перечисленные в нем, дополняются к исходному классу, то есть наследования не происходит.<br />
<br />
Как правило, расширения применяются к классам [[Стандартной библиотека Gide|стандартной библиотеки]], либо к [[unmanaged код|неуправляемым классам]].<br />
<br />
В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же как при описании классов:<br />
<br />
<source lang="kpp" line="1"><br />
package intmod_fact;<br />
import std;<br />
external console_stream STDOUT;<br />
function void println(const string s) { STDOUT.print(s + "\n"); }<br />
<br />
extend int {<br />
const function ubigint GetFactorial() {<br />
var ubigint result = 1, int x;<br />
for (x = this; x > 1; --x)<br />
result *= x;<br />
return result;<br />
}<br />
property ubigint factorial read GetFactorial;<br />
}<br />
<br />
export function main() {<br />
println("Factorial of 10 is " + 10.factorial);<br />
}<br />
</source><br />
<br />
<br />
;6-14: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.<br />
<br />
;17: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. <!--Его мы вызываем с помощью специального синтаксиса, для передачи блока в качестве [[Функции#Аргументы|параметра функции]]. При этом, сам блок указывается прямо в коде вызова функции. Тело блока состоит из одного вызова функции, выводящей текущее число в стандартный поток вывода. --><br />
<br />
: Обратите внимание, что функция <tt>println()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|ubigint]]</tt>. В этом нет ничего странного, потому что класс <tt>ubigint</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt> передается в качестве параметра функции.<br />
<br />
<br />
'''Примечание:''' При работе с расширениями существует одно важное ограничение. Расширять классы можно только методами и свойствами, но не полями. Это связано с внутренней организацией языка К++ и виртуальной машины. Дополнительно стоит отметить, что методы объявленные в расширении будут перекрывать соответствующие им методы класса (имеется в виду ситуация когда имена и наборы параметров полностью совпадают). Важно понимать, что такое перекрытие не является объявлением виртуального метода — происходит именно замещение старого метода новым. <br />
<br />
== Смотри также ==</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8BКлассы и объекты2007-10-05T11:17:19Z<p>KroTozeR: /* История развития ООП */</p>
<hr />
<div>__TOC__<br />
<br />
== История развития ООП ==<br />
<br />
Для того чтобы понять, что же такое классы и объекты, сперва необходимо проследить историю развития программирования. А конкретнее, историю возникновения концепции ООП. Автор верит, что знание истории возникновения тех или иных мыслей и идей может помочь читателю осознать необходимость нововведений, и главное — их преимуществ перед существовавшими в то время решениями.<br />
<br />
=== Возникновение языков программирования ===<br />
<br />
На заре зарождения вычислительных машин их приходилось программировать поистине "вручную". Все, что было в руках программиста это пульт управления ЭВМ. На шестнадцатеричной клавиатуре (а еще раньше на пульте с тумблерами) программист задавал некоторый адрес ячейки памяти, затем он мог либо выполнить операцию чтения — тогда на табло появлялись цифры, соответствующие значению ячейки памяти, либо операцию записи — при этом, по указанному адресу записывалось значение, набранное на клавиатуре данных. Затем, программист переходил к следующей ячейке, и так повторялось до тех пор, пока в память ЭВМ не была внесена вся программа. На программистах (точнее, на операторах ЭВМ) лежала огромная ответственность! Одна ошибка, один неверно установленный переключатель или одна пропущенная команда неминуемо вели к ошибкам в работе программы, а, следовательно, и к ошибкам в расчетах. Могли потребоваться недели, и даже месяцы на поиск этой ошибки и на ее исправление! Естественно, ни о каких языках программирования тогда не могло идти и речи.<br />
<br />
=== Появление ассемблера ===<br />
<br />
Впоследствии, программисты смекнули, что команды можно записывать в виде мнемонических обозначений или мнемоник — то, что раньше применялось только для удобства записи на бумаге — было стандартизировано и приспособлено как ''язык'' общения человека и ЭВМ. Так появился первый язык программирования — ''язык ассемблера''. Конечно, языком его можно назвать с некоторой натяжкой, ведь он не обеспечивал и десятой доли тех возможностей (вроде автоматического разбора арифметических выражений), которые мы привыкли ассоциировать с языками программирования. Тем не менее, ассемблер выполнял свою главную и основную функцию — избавлял программиста от необходимости работать с памятью (и адресами) напрямую. Вместо этого, программист записывал свои команды в стандартной форме, понятной ЭВМ. Далее выполнялась программа ''транслятор'', которая преобразовывала исходный текст программы в поток машинных команд, которые уже можно исполнять.<br />
<br />
=== Концепция языка высокого уровня ===<br />
<br />
...С увеличением сложности программ, программировать на ассемблере становилось все сложнее и сложнее. Ввиду естественных ограничений человеческой памяти и внимания, написание программ и их отладка стали настолько сложными, что люди всерьез подошли к рассмотрению идеи языка высокого уровня — некоторой системы обозначений и абстрактных команд, которая позволила бы записывать программы в абстрактной форме, не заботясь о том, как располагать в памяти код и данные, как их структурировать и т. д. Всю эту работу брал на себя компилятор. Кроме того, он обеспечивал программиста удобным способом записи математических выражений — в естественной форме. При этом, компилятор сам "разворачивал" эти выражения в наборы инструкций ассемблера, попутно подставляя значения констант и адреса переменных. Это дало возможность программистам записывать формулы вычислений в натуральном виде, что уменьшало трудозатраты, ускоряло написание программ и уменьшало вероятность ошибок. Тем не менее, многие авторитеты того времени очень негативно отзывались о языках высокого уровня. В то время языки были довольно несовершенными и генерировали "ужасный" с точки зрения программистов код. Код был не оптимален, занимал огромное по тем временам количество памяти и работал медленнее, чем та же программа, написанная на ассемблере. Смешно сказать, но в то время многие не верили в то, что будущее за ЯП высокого уровня; их считали не более чем игрушкой для "чайников", возжелавших вообразить себя настоящими программистами. <br />
<br />
Но время шло, количество приверженцев нового подхода постоянно увеличивалось. Сами же компиляторы становились все более мощными и генерировали все более компактный и оптимальный код. Дошло до того, что компилятор с оптимизатором в некоторых случаях генерировал код, более качественный, чем это делал программист. С этого момента ЯП высокого уровня заняли свое место в истории и в инструментарии любого разработчика.<br />
<br />
=== Структурное программирование ===<br />
<br />
С развитием языков программирования появились новые концепции и новые парадигмы программирования. От линейного моноблочного программирования, при котором программа писалась единым "куском" от начала до конца, перешли к программам модульным и структурным. При них программа представляла уже совокупность процедур (функций), которые вызывали друг друга в ходе работы программы. Процедуры представляли собой подпрограммы, решающие отдельные частные задачи. При этом код получался более читаемым, и облегчалась его отладка. <br />
<br />
Опять же, в ходе усложнения решаемых задач и, вследствие этого, увеличения количества переменных с которыми приходилось работать программисту, возникла идея группировки некоторых переменных в группы или структуры. Структуры формировались по назначению и содержали в себе переменные, имеющие отношение к одной и той же сущности. Это значительно повысило читаемость программ и уменьшило количество ошибок в них.<br />
<br />
=== Объектно-ориентированное программирование ===<br />
<br />
Ну и наконец, одна светлая голова додумалась до мысли: "а что если в структурах группировать не только переменные, но и сами процедуры которые должны работать с этими переменными?". В результате получилось то, что мы сейчас называем классом — то есть, некоторая обособленная функциональная сущность, которая сама хранит свои данные, а главное сама умеет их обрабатывать. Теперь программисту не нужно помнить, какая из процедур отвечает за некоторое действие над такими-то переменными — он просто берет объект и работает с ним. Все что происходит с объектом внутри — это его личное дело.<br />
<br />
Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.<br />
<br />
При написании программы на объектно-ориентированном языке, программист строит математическую модель взаимодействия различных сущностей. Каждая из сущностей это свой мир, у которого есть свои законы и особенности. При этом сущности могут быть как конкретные, вроде "сетевой интерфейс" или "файл", так и совершенно абстрактные, например "отношение" или "ошибка". Программист описывает каждую из сущностей в отдельности, обособлено от остальных. Вся необходимая для работы информация хранится внутри, а для взаимодействия с внешним миром предусмотрен ''интерфейс'' — некоторая совокупность ''свойств'' данной сущности (отражающих ее внутреннее состояние) и способов взаимодействия с ней — ''методов''.<br />
<br />
В ходе работы программы сущности могут взаимодействовать, читая и записывая свойства и вызывая методы друг друга, использовать друг друга как подсистемы, порождать новые сущности и т. д. Получается, что при написании программы, программист переносит свое внутреннее представление того как он видит эту программу, то из чего она состоит и как отдельные ее части взаимодействуют. Теперь не приходится адаптировать свое понимание проблемы к конкретным инструментальным средствам и возможностям языка программирования (конечно, это все же происходит, но уже гораздо менее заметно).<br />
<br />
В терминах современных языков программирования такие сущности называются ''классами'', в смысле ''классами сущностей''. А отдельные представители этих классов называются ''экземплярами'', ''инстанциями'' (на английский манер) или ''объектами''. Более подробно, различие между классами и объектами будет рассмотрено ниже.<br />
<br />
<br />
Итак, любой современный объектно-ориентированный язык оперирует понятиями классов и объектов. Точно такой же подход нашел свое применение в нашей виртуальной машине. Основой всей платформы Gide является объектно-ориентированный принцип. Причем, в этом смысле она является более объектно-ориентированной, нежели традиционные ЯП вроде C++. В C++ существуют понятия элементарных типов. Это сделано в целях производительности и было продиктовано архитектурой самого языка. В классических языках программирования, элементарные типы, так или иначе, отражают сущности из "реального мира". Например, целочисленные типы int и short соответствуют 32х и 16ти разрядным регистрам процессора, указатели и строки соответствуют представлению данных в памяти и т. д. В Gide это не так. Все с чем оперирует виртуальная машина — это объекты. Соответственно, не существует понятия элементарных типов (просто нет критерия, который бы позволил отделить одно от другого). <br />
<br />
Язык K++ в полной мере наследует идеологию Gide. Скажем, для него нет отличия между типом <tt>int</tt> (целое число) и некоторым пользовательским классом <tt>MyWeirdClass</tt>: везде, где можно использовать <tt>int</tt>, можно использовать <tt>MyWeirdClass</tt> и наоборот. Более того, это позволяет работать с системными классами так же, как с пользовательскими! Например, ничто не мешает унаследовать свой класс от класса <tt>int</tt>, равно как ничто не мешает определить математические операторы для класса <tt>MyWeirdClass</tt> и использовать объекты этого класса в арифметических выражениях. При этом изменится логика работы всего языка. К примеру, после добавления некоторого метода к классу int можно будет вызывать методы у всех его экземпляров, даже тех, что представлены числовыми константами внутри самого языка!<br />
<br />
== Понятие класса ==<br />
<br />
Что такое ''класс'' проще всего объяснить на примерах. Представьте, что вас спрашивают "что такое яблоко?". Скорее всего, вы ответите что-то вроде: "яблоки, это вкусные плоды растущие на деревьях — яблонях; они бывают разных цветов и размеров". Заметьте, что когда мы описываем ''яблоки как понятие'', мы не имеем в виду некоторый конкретный объект, а скорее описываем наше обобщенное представление о них. Если же вас попросят описать совершенно конкретное яблоко, лежащее на блюдечке перед вами, вы будете говорить о нем по другому: "это яблоко, оно красное, сочное, судя по всему спелое. с черенком, на котором остался листик, и маленькой червоточинкой". <br />
<br />
Разница заключается в том, что когда вы говорили ''о яблоках'', вы описывали свое представление яблок, как ''класса'' объектов. Когда вы описывали ''яблоко'', то вы имели в виду конкретный ''экземпляр'', или ''объект''. Говоря о классе, вы можете описать только те свойства, что принадлежат всем яблокам; когда же вы описываете объект, то в первую очередь имеете в виду его индивидуальные особенности (свойства). Тем не менее, описание объекта начинается с упоминания его класса ("это яблоко,..."), а затем уже свойств объекта (ведь "сочным и спелым" может быть и апельсин). Это важная особенность объектно-ориентированного подхода. <br />
<br />
Другой пример: если вас попросить "представьте дерево", то вы либо представите некоторое совершенно абстрактное, усредненное дерево, либо попросите уточнить, какое именно дерево имеется в виду. Ваше сознание из имеющейся информации смогло уяснить только самые общие сведения о классе. Но этой информации не достаточно, для более детального описания. Это тоже важно, поскольку в этом простом примере кроется сущность механизма наследования — постепенного уточнения классами-потомками общих черт своих предков. Таким образом, и яблоня и груша — деревья. Но яблони отличаются от груш. Получается, что классы ''яблони'' и ''груши'' имеют общего предка — класс ''дерево''.<br />
<br />
Таким образом, понятия классов и объектов это не математическая абстракция, а скорее часть нашего восприятия мира, того как мы мыслим.<br />
<br />
<br />
Из примеров выше мы смогли уяснить следующее:<br />
<br />
* Классы, это некоторые абстрактные сущности, задающие общие черты своих объектов<br />
* Все объекты одного класса похожи друг на друга, но имеют некоторые индивидуальные особенности<br />
* Классы могут наследоваться, расширяя набор свойств класса родителя своими собственными<br />
<br />
Перейдем теперь ближе к основной теме нашего повествования, а именно языку К++:<br />
<br />
С точки зрения языка, ''класс'' представляет собой набор следующих элементов:<br />
* ''полей'', т.е. переменных, хранящих индивидуальные особенности объектов, <br />
* ''методов'', т.е. функций, определяющих поведение данного объекта;<br />
* ''свойств'', определяющих взаимодействие других объектов с объектами данного класса.<br />
<br />
''Поля'' — это переменные, которые относятся к некоторому конкретному экземпляру нашего класса. Каждый экземпляр имеет свою копию набора переменных, таким образом они могут хранить свое состояние (например показатель "спелости", в примере с яблоками). Эти переменные доступны только самому классу, доступ извне для них запрещен. Для того, чтобы частично разрешить этот доступ, применяются ''свойства''. Сами свойства будут описаны позже, здесь стоит отметить только то, что свойство может быть доступно "только на чтение", "только на запись" или "и на чтение и на запись". Свойство может быть связано либо с некоторым полем, либо с методом. Например, если свойство доступно "только на чтение" то его можно использовать для получения значения, но не для его записи (то есть, такое свойство не может фигурировать в качестве [[lvalue]]).<br />
<br />
''Методы'' — это тот самый, связанный с данными код (вспомните [[Классы и объекты#История развития ООП|историю ООП]]) который, естественно, может работать с переменными объекта (то есть с полями) и служит для описания поведения данного класса объектов.<br />
<br />
Класс может иметь одного или нескольких родителей (опять же, подробнее об этом см. ниже)<br />
<br />
Методы и свойства класса могут находиться в различных областях видимости. Это обеспечивается с помощью [[Спецификаторы доступа|спецификаторов доступа]]:<br />
<br />
* <tt>'''private'''</tt> — Частная собственность! Видимость только внутри методов данного класса<br />
* <tt>'''protected'''</tt> — "Семейная реликвия", доступ внутри методов данного класса и всех его дочерних классов<br />
* <tt>'''public'''</tt> — видимость и доступ для всех<br />
<br />
'''Примечание:''' По умолчанию методы имеют видимость <tt>'''private'''</tt>, в то время как свойства — <tt>'''public'''</tt>.<br />
<br />
Приведем наконец пример объявления класса:<br />
<br />
<source lang="kpp" line="1"><br />
class MyWeirdClass {<br />
var m_x = 0; // поле m_x, изначально проинициализированное нулем<br />
const m_y = 1; // поле-константа m_y<br />
<br />
// методы класса<br />
public const function int get_mul() { return m_x * m_y; }<br />
public function void set_mul(int x) { m_x = x / m_y; }<br />
<br />
// свойство класса<br />
public property mul read get_mul write set_mul;<br />
}<br />
</source><br />
<br />
<br />
;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.<br />
<br />
;3-4: Здесь мы видим объявление двух полей класса — переменной ''m_x'' и константы ''m_y'', которые, подобно обычным переменным инициализируются тут же, на месте объявления (камень в огород C++). Зачем нужны поля-константы, описано в главе [[Константы]]. <br />
<br />
;7-8: Для доступа к состоянию объекта, определены два метода: ''аксессор'' <tt>get_mul()</tt> и ''мутатор'' <tt>set_mul()</tt>. Подобные конструкции применяются настолько часто, что им были даны специальные имена. Как видно из названия, первый метод дает доступ к значению, второй изменяет или мутирует его.<br />
<br />
;11: Завершается объявление класса объявлением свойства ''mul'', которое связывается с аксессором и мутатором. Думаю, читатель уже догадался, что это свойство типа "чтение и запись". Таким образом, при обращении к свойству на чтение, будет вызыан аксессор, а результат его выполнения будет возвращен в качсетве значения свойства. И наоборот, при попытке записать в свойство некоторое значение, будет вызван мутатор, в качестве аргумента которому будет передано это самое значение, а уж сам мутатор позаботится о том чтобы оно было "доставлено по адресу". <br />
<br />
: '''Примечание:''' Зачем нужны такие сложности и зачем дублировать вроде бы одинаковый функционал, будет описано ниже.<br />
<br />
== Понятие объекта ==<br />
<br />
Собственно, понятие объекта уже много раз было затронуто выше по повествованию. Поэтому здесь приведем лишь небольшое определение: Под ''объектом'' подразумевается экземпляр того или иного класса, т.е. некоторая сущность, поведение которой задается соответствующим классом.<br />
<br />
Для создания объекта того или иного класса служит оператор <tt>'''new'''</tt>:<br />
<source lang="kpp"><br />
var myWeirdObject = new MyWeirdClass;<br />
</source><br />
<br />
Здесь мы видим типичную конструкцию объявления переменной, однако в инициализаторе переменной находится всего один оператор, за которым следует [[идентификатор]] имени класса, экземпляр которого мы хотим создать.<br />
<br />
== Наследование ==<br />
<br />
Под ''наследованием'' классов понимается механизм такого создания (объявления) класса, при котором он расширяет функционал одного или нескольких уже существующих классов (родителей). Вспомните пример с деревьями. Когда мы говорим, что класс ''яблоня'' наследуется от класса ''дерево'' — это значит что ''яблоня'' унаследует все свойства своего класса-родителя, некоторые из которых он может изменить, ну и дополнить своими собственными свойствами. Опыт нам подсказывает, что у любого дерева есть листья (для простоты не будем вспоминать про хвойные), однако не любое дерево плодоносит яблоками. Если же рассмотреть сами яблоки, то можно сказать, что класс ''яблоко'' унаследован от класса ''фрукт'', который определяет что фрукты (и соответственно яблоки) должны расти на деревьях.<br />
<br />
Таким образом, наследование гарантирует, что к дочерним классам применимы все операции, доступные в родительском классе: любой алгоритм, работающий с объектами родительского класса, может работать с объектами его дочерних классов. <br />
<br />
Для задания наследования, в объявлении класса следует указать ключевое слово <tt>'''extends'''</tt>, за которым необходимо перечислить список идентификаторов классов-родителей, разделяя их запятыми:<br />
<br />
<source lang="kpp" line="1"><br />
// коробка<br />
class Box { <br />
// из чего сделана коробка?<br />
public const function string material() { return "Картон"; }<br />
<br />
// что в коробке?<br />
public const function string contents() { return "Пусто"; }<br />
}<br />
<br />
// коробка с картошкой<br />
class BoxWithPotatoes extends Box { <br />
public const function string contents() { return "Картошка"; }<br />
}<br />
<br />
function OutputBox(const Box b) {<br />
STDOUT.print("Материал: " + b.material() + ", содержит: " + b.contents() + "\n");<br />
}<br />
<br />
function main() {<br />
var b1 = new Box;<br />
var b2 = new BoxWithPotatoes;<br />
OutputBox(b1); // Материал: Картон, содержит: Пусто<br />
OutputBox(b2); // Материал: Картон, содержит: Картошка<br />
}<br />
</source><br />
<br />
<br />
;2-7: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.<br />
<br />
;10-12: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.<br />
<br />
;14-16: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом, мы предполагаем что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).<br />
<br />
;18-23: Объявляется функция <tt>main()</tt>, внутри которой и происходит самое интересное. Сначала мы создаем два экземпляра ''b1'' и ''b2'' классов <tt>Box</tt> и <tt>BoxWithPotatoes</tt> соответственно. А затем, вызываем вышеописанную функцию <tt>OutputBox()</tt>, которая отображает содержимое. Вывод в терминал (написан в комментарии к вызову) показывает как это все работает.<br />
<br />
'''Примечание:''' при использовании множественного наследования существует одно серьезное ограничение: его нельзя применять для наследования от классов стандартной библиотеки. Это ограничение связано с архитектурой платформы Gide. Однако, его можно обойти с помощью создания [[Класс-обертка|классов-оберток]] для системного класса, с последующим наследованием от него нового класса.<br />
<br />
== Методы ==<br />
<br />
''Метод'' — это некоторый код, связанный с объектом и управляющий его поведением. Управление может заключаться в изменении переменных постояния объекта (полей), либо выполнением некоторых операций над ними.<br />
<br />
При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:<br />
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода<br />
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод не изменяет объект<br />
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)<br />
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять<br />
<br />
После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].<br />
<br />
Тело метода может быть объявлено как непосредственно в теле класса, так и вынесено за его пределы, например:<br />
<br />
<source lang="kpp" line="1"><br />
class MyClass {<br />
public const function string F1() { return "smth"; }<br />
public const function string F2();<br />
}<br />
<br />
function string MyClass::F2() {<br />
return F1();<br />
}<br />
</source><br />
<br />
<br />
;6: При вынесении функции за пределы класса, имя соответствующего метода предворяется именем класса из которого он был вынесен; имена отделяются друг от друга символом "двойное двоеточие" ( <tt>::</tt> ); дополнительно — в заголовке вынесенной функции необходимо указать тип возвращаемого значения и параметры функции, все остальные ключевые слова указывать не обязательно.<br />
<br />
;7: В теле метода доступны все поля, методы и свойства данного класса и его предков. Например, в коде приведенном выше, метод <tt>F2()</tt> вызывает метод <tt>F1()</tt> для того же объекта.<br />
<br />
=== Статические методы ===<br />
<br />
''Статический метод класса'' — это метод, относящиеся к данному классу, но не объекту этого класса. Т.е. это некоторая вспомогательная для данного класса функция.<br />
<br />
При объявлении статического метода нужно указать ключевое слово <tt>'''static'''</tt>.<br />
<br />
В теле статического метода нет возможности напрямую обращаться к другим методам данного класса, т.к. статическому методу недоступен объект класса. Фактически, единственным отличием статического метода от обычной функции является то, что такой метод может обращаться к защищенным полям и методам класса некоторого другого объекта. Подобный подход широко применяется при написании ''конструкторов'' (см. ниже).<br />
<br />
Пример:<br />
<source lang="kpp"><br />
class MyClass {<br />
public static function string Info() { return "Я MyClass!"; }<br />
}<br />
<br />
function f() {<br />
// Вызов статического метода:<br />
var myClassInfo = MyClass.Info();<br />
}<br />
</source><br />
<br />
=== Конструкторы ===<br />
<br />
В ходе написания программы часто приходится создавать новые объекты. При этом, объекту требуется установить некоторое начальное состояние. Разумеется, это выполняется либо путем написания инициализаторов соответствующих полей, либо занчения полям присваиваются явным образом. Но что делать, если объект может иметь несколько начальных состояний? То есть, в зависимости от некоторых условий, одним и тем же полям объекта могут быть присвоены различные наборы значений. Тут уже одними инициализаторами не обойтись. Присваивать значения можно прямо в коде программы, однако это не очень красивое решение, поскольку один и тот же объект может создаваться в нескольких местах программы и придется копировать один и тот же участок кода, инициализирующий поля объекта. Недостаток этого подхода в том, что при большом количестве полей, программист может забыть проинициализировать некоторе поле, либо при изменении условий инициализации он может изменить их только в одном месте программы, забыв что объект может создаваться и в других местах. Более разумным является подход, при котором программист пишет функцию, инициализирующую поля объекта. При этом, весь код собирается в одном месте и вероятность ошибок значительно понижается. <br />
<br />
Конструкторы развивают эту идею, дополняя код инициализации полей кодом создания самого экземпляра объекта. То есть, в конструкторе собирается весь код относящийся к созданию инстанции класса. Итак, ''конструктор класса'' — это специальный метод, инициализирующий объект класса. С точки зрения языка, конструктор — это статический метод класса, возвращающий экземпляр данного класса.<br />
<br />
Таким образом, следующие объявления в рамках класса эквивалентны:<br />
<source lang="kpp"><br />
public constructor Create();<br />
public static MyClass Create();<br />
</source><br />
<br />
Тело конструктора чаще всего выглядит следующим образом: сначала создается экземпляр класса при помощи оператора <tt>'''new'''</tt>, затем производятся некоторые действия, инициализующие этот объект, и, наконец, этот объект возвращается в качестве результата. <br />
<br />
В качестве примера приведем пример реализации некоторого абстрактного класса <tt>MyStream</tt>, использующего системную реализацию класса <tt>stream</tt>, и определяющую собственный конструктор:<br />
<br />
<source lang="kpp" line="1"><br />
class MyStream {<br />
var string m_URL;<br />
var stream m_Stream;<br />
public:<br />
static const MODE_READ = 1;<br />
static const MODE_WRITE = 2;<br />
constructor open(const string url, int mode) {<br />
var self = new MyStream;<br />
self.m_Stream.open(url, mode);<br />
self.m_URL = url;<br />
return self;<br />
}<br />
// прочие методы (опущены для краткости)<br />
}<br />
</source><br />
<br />
<br />
;2-3: Объявляются поля ''m_URL'' и ''m_Stream'' нашего класса, которые будут инициализироваться в конструкторе. <br />
<br />
;5-6: В публичной области класса объявляются статические константы ''MODE_READ'' и ''MODE_WRITE'', которые задают желаемый режим доступа к открываемому потоку. Это единственный случай, когда поле класса доступно на прямой доступ извне.<br />
<br />
;7: Объявляется конструктор <tt>open()</tt>, принимающий в качестве параметров [[URL]] ресурса который требуется открыть и число, задающее с помощью вышеописанных констант режим доступа к потоку. В теле конструктора мы создаем инстанцию ''self'' нашего класса. Затем производится попытка открытия потока ''m_Stream'': если операция пройдет успешно, то происходит инициализация оставшегося поля ''m_URL'' и выход из конструктора с возвратом созданной инстанции; если же операция открытия потока провалится, то будет сгенерировано ''[[Обработка исключений|исключение]]'' и выполнение конструктора прекратится (управление будет передано "наверх", вызывающему коду).<br />
<br />
<br />
Использовать наш класс можно примерно так:<br />
<source lang="kpp">var data = MyStream.open("http://www.deeptown.org/index.html", MyStream.MODE_READ);</source><br />
<br />
Обратите внимание на второй параметр функции, где мы передаем константу ''MODE_READ'', объявленную внутри самого класса. Подобный подход, когда константы используемые при работе с классом инкапсулируются в тело класса, помогает сконцентрировать код в одном месте и избежать многих ошибок. В результате повышается читаемость кода и не возникает конфликта имен констант.<br />
<br />
== Поля ==<br />
<br />
Поле класса — это некоторый объект, используемый объектом данного класса.<br />
<br />
Объявление поля начинается с одного из трех ключевых слов:<br />
* <tt>'''var'''</tt> — объявление "обычного" поля;<br />
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;<br />
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.<br />
<br />
За ключевым словом следует тип поля и [[идентификатор]] его имени. Тип поля может быть опущен. После имени может стоять символ "=" и выражение, инициализирующее значение данного поля. В целом, синтаксис тот же, что и при объявлении обычной переменой или константы:<br />
<br />
<source lang="kpp"><br />
var int m_x;<br />
const m_y = 0;<br />
var m_stream = new stream;<br />
</source><br />
<br />
Тип поля определяется по следующим правилам:<br />
* если тип указан явно, ничего определять не надо;<br />
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;<br />
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].<br />
<br />
'''Примечание:''' В K++ доступ к полям имеет только объект класса — т.е. фактически, все поля находятся в закрытой (private) области видимости. Для предоставления внешним классам доступа к полям следует использовать ''свойства'' (см. ниже).<br />
<br />
== Свойства ==<br />
<br />
''Свойства'' — это специальные конструкции языка К++, которые позволяют совмещать обращение к данным с вызовом определенного метода. Смысл свойств заключается в том, чтобы программист мог контролировать процесс изменения состояния объекта и своевременно реагировать на это изменение. Свойства бывают доступны на чтение, на запись, или на чтение и на запись одновременно. Это связано с тем, что некоторые свойства объекта (в естественном понимании этого слова), могут предполагать только получение информации о них, другие же могут подразумевать изменение состояния, без возможности чтения. <br />
<br />
В существующих языках программирования, таких как C++ тот же функционал реализуется с помощью вызова специальных методов: ''аксессоров'' и ''мутаторов'', которые используются для получения сведений о некотором свойстве или для записи соответственно. Однако, это делает код менее читаемым, особенно в случае мутаторов. Свойства же, позволяют работать с собой подобно обычным полям или объектам, используя операторы. <br />
<br />
Приведем два примера, которые позволят понять смысл свойств и их отличие от обычных полей класса.<br />
<br />
Предположим, что у нас есть класс, отвечающий за чтение состояния некоторого устройства. Допустим, состояние представляется целым числом и должно определяться по мере обращения. Если бы мы писали на языке C++, то мы оформили бы это в виде метода:<br />
<br />
<source lang="cpp"><br />
class MyDevice {<br />
int GetState();<br />
};<br />
</source><br />
<br />
Везде, где нам потребовалось бы читать состояние устройства мы должны были писать что-то типа:<br />
<br />
<source lang="cpp"><br />
int current_state = Device.GetState();<br />
</source><br />
<br />
В случае с К++, чтение свойств осуществляется подобно обычным полям. Перепишем вышеописанный пример на язык К++: <br />
<br />
<source lang="kpp"><br />
class MyDevice {<br />
function int GetState();<br />
property int state read GetState;<br />
}<br />
</source><br />
<br />
Соответственно, обращение к свойству состояния будет выглядеть так:<br />
<br />
<source lang="kpp"><br />
var current_state = Device.state;<br />
</source><br />
<br />
При обращении к свойству <tt>state</tt> будет автоматически вызыван метод <tt>GetState()</tt>, результат которого будет возвращен как значение свойства. Вышеописанный пример кому-то может показаться странным, ведь получается, что мы усложнили код класса ради сомнительного выигрыша в коде обращения. На самом деле, в реальных условиях, с настоящими классами, с большим количеством свойств и в сложных выражениях, выигрыш становится куда более заметен. Сравните два примера одного и того же участка кода, один из которых написан на C++, другой на K++. Несмотря на то, что приведенный код тоже взят "с потолка", разница в читаемости уже более заметна. В целом, чем сложнее выражение и чем больше в нем применяется операций присваивания и доступа к полям классов — тем большее преимущество дает использование свойств:<br />
<br />
<source lang="cpp"><br />
Object1.SetStatus(Object2.GetStatus() > 0 ? Object2.GetStatus() : DefaultObject.GetStatus());<br />
printf("object %s (%d) located at %s : status changed to %u", <br />
Object1.GetName(), Object1.GetIndex(), Object1.GetLocation(), Object1.GetStatus());<br />
</source><br />
<br />
<source lang="kpp"><br />
Object1.status = Object2.status > 0 ? Object2.status : DefaultObject.status;<br />
println("object % (%) located at % : status changed to %", <br />
Object1.name, Object1.index, Object1.location, Object1.status);<br />
</source><br />
<br />
В качестве второго примера мы приведем код, более близкий к реальной жизни. Как известно, многие элементы управления современных графических интерфейсов могут находится в состоянии "активен" или "не активен". Неактивные элементы не реагируют на действия пользователя (например, кнопки не будут нажиматься) и как правило окрашиваются в оттенки серого (для того чтобы нельзя было их спутать с активными элементами). Естественно, это поведение определяется некоторым полем в объекте элемента управления. В зависимости от его значения, библиотека графического интерфейса будет по разному обрабатывать и отрисовывать этот элемент управления.<br />
<br />
В языке К++ это поведение можно легко описать, используя двусторонние свойства, то есть такие, которые можно использовать как на чтение так и на запись. Логично предположить, что чтение такого свойства не должно сказываться на самом элементе управления, в то время как запись в свойство должна дать команду элементу управления изменить свое состояние и соответственно внешний вид. Вот пример описания некоторого абстрактного класса элемента управления:<br />
<br />
<source lang="kpp" line="1"><br />
class Widget {<br />
var m_Enabled = true; //поле, хранящее текущее состояние активности<br />
function void SetEnabled(const value) {<br />
var old_value = m_Enabled;<br />
m_Enabled = value;<br />
if (old_value != m_Enabled)<br />
Invalidate(); //Состояние изменилось, обновляем элемент управления<br />
}<br />
property enabled read m_Enabled write SetEnabled;<br />
//далее идет остальная часть класса, например методы отрисовки<br />
}<br />
</source><br />
<br />
Теперь, если мы унаследуем некоторый класс от данного класса и переопределим соответствующие методы отрисовки, то у класса потомка так же можно будет использовать свойство <tt>enabled</tt>:<br />
<br />
<source lang="kpp"><br />
var myForm = new Form; //создаем окно<br />
var myButton = Button.CreateAtPos(myForm, 10, 10); //добавляем кнопку<br />
myButton.caption = "Click me!"; //устанавливаем подпись<br />
myButton.OnClick += { |x| x.enabled = false; }; //подключаем обработчик события<br />
myForm.Show(); //показываем окно<br />
</source><br />
<br />
Приведенный выше код создаст окно и разместит на нем кнопку (подразумевается, что класс <tt>Button</tt> унаследован от нашего класса <tt>Widget</tt>). Затем устанавливаются свойства кнопки, такие как подпись и [[Блоки|блок]] обработчика события <tt>OnClick</tt>. При нажатии на кнопку она станет неактивной.<br />
<br />
<br />
----<br />
<br />
<br />
В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства. <br />
<br />
Оставшаяся часть зависит от того, какое свойство объявляется:<br />
<br />
* Если объявляется свойство на чтение, то указывается ключевое слово <tt>'''read'''</tt>, после которого идет либо идентификатор имени поля, которое нужно читать, либо имя метода, который должен использоваться как ''аксессор''. В роли аксессора может выступать метод, не принимающий параметров и возвращающий некоторое значение, которое будет возвращаться как значение свойства.<br />
* Если объявляется свойство на запись, то указывается, соответственно ключевое слово <tt>'''write'''</tt> после которого идет либо имя поля, которое нужно записывать, либо имя метода, который должен использоваться как ''мутатор''. В качестве мутатора может выступать метод, принимающий один параметр. Возвращаемое значение игнорируется, так что оно может быть любым.<br />
* Если объявляется свойство, доступное как на чтение так и на запись, то указываются обе части, причем первой идет часть чтения.<br />
<br />
<br />
'''Примечание:''' Если тип свойства указан явно, то в зависимости от типа поля либо типа возвращаемого значения аксессора, может быть выполнена операция [[Приведение типов|приведения типов]]. Разумеется, если тип поля или результат аксессора неприводим к указанному типу свойства, то будет выдано сообщение об ошибке. Аналогичная ситуация обстоит и с параметром мутатора.<br />
<br />
Кратко, синтаксис объявления свойства можно описать в стиле справки к командам оболочки:<br />
<source lang="kpp"><br />
property [тип] <имя> [read <аксессор|поле>] [write <мутатор|поле>];<br />
</source><br />
<br />
== Расширения ==<br />
<br />
Иногда бывает необходимо расширить функциональность некоторого существующего класса без порождения дочернего класса. Это может быть необходимо в тех случаях, когда исходный класс уже используется в коде программы и порождение нового класса нарушило бы спецификацию на интерфейс, либо потребовало значительных изменений в исходных текстах программы. В таких случаях целесообразно применять т. н. ''расширения классов''. Синтаксически, конструкция расширения практически не отличается от конструкции объявления класса, однако методы и свойства перечисленные в нем, дополняются к исходному классу, то есть наследования не происходит.<br />
<br />
Как правило, расширения применяются к классам [[Стандартной библиотека Gide|стандартной библиотеки]], либо к [[unmanaged код|неуправляемым классам]].<br />
<br />
В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же как при описании классов:<br />
<br />
<source lang="kpp" line="1"><br />
package intmod_fact;<br />
import std;<br />
external console_stream STDOUT;<br />
function void println(const string s) { STDOUT.print(s + "\n"); }<br />
<br />
extend int {<br />
const function ubigint GetFactorial() {<br />
var ubigint result = 1, int x;<br />
for (x = this; x > 1; --x)<br />
result *= x;<br />
return result;<br />
}<br />
property ubigint factorial read GetFactorial;<br />
}<br />
<br />
export function main() {<br />
println("Factorial of 10 is " + 10.factorial);<br />
}<br />
</source><br />
<br />
<br />
;6-14: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.<br />
<br />
;17: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. <!--Его мы вызываем с помощью специального синтаксиса, для передачи блока в качестве [[Функции#Аргументы|параметра функции]]. При этом, сам блок указывается прямо в коде вызова функции. Тело блока состоит из одного вызова функции, выводящей текущее число в стандартный поток вывода. --><br />
<br />
: Обратите внимание, что функция <tt>println()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|ubigint]]</tt>. В этом нет ничего странного, потому что класс <tt>ubigint</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt> передается в качестве параметра функции.<br />
<br />
<br />
'''Примечание:''' При работе с расширениями существует одно важное ограничение. Расширять классы можно только методами и свойствами, но не полями. Это связано с внутренней организацией языка К++ и виртуальной машины. Дополнительно стоит отметить, что методы объявленные в расширении будут перекрывать соответствующие им методы класса (имеется в виду ситуация когда имена и наборы параметров полностью совпадают). Важно понимать, что такое перекрытие не является объявлением виртуального метода — происходит именно замещение старого метода новым. <br />
<br />
== Смотри также ==</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9A%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82%D1%8BКонстанты2007-10-01T09:16:38Z<p>KroTozeR: </p>
<hr />
<div>== Понятие константы ==<br />
<br />
В сущности, и с точки зрения языка, ''константы'' это те же [[переменные]], за исключением того, что однажды установленное их значение нельзя изменять. В остальном они ведут себя так же как обычные [[объекты]]: их можно использовать в арифметических выражениях, передавать в качестве [[Функции#Аргументы|параметров]] [[Функции|функциям]], использовать их [[K++ как объектно-ориентированный язык#Свойства|свойства]] и вызывать [[K++ как объектно-ориентированный язык#Методы|методы]]. Разумеется, только те, которые не изменяют состояние самого объекта.<br />
<br />
Объявление любой константы начинается с ключевого слова <tt>'''const'''</tt>, за которым идут тип (можно не указывать), [[идентификатор]] имени константы и выражение-инициализатор. <br />
<br />
Вот примеры объявления констант:<br />
<source lang="kpp"> <br />
const real e = 2.7182818;<br />
const pi = 3.1415926;<br />
const s = "hello world";<br />
</source><br />
<br />
Тип константы можно либо указать явно, как это происходит в случае константы ''e'', либо неявно. При этом он будет назначен как тип инициализатора: константа ''pi'' будет иметь тип числа с плавающей точкой (<tt>[[Стандартные типы данных#Числа с плавающей точкой|real]]</tt>), а константа ''s'' — строковый тип (<tt>[[Стандартные типы данных#Строки|string]]</tt>).<br />
<br />
'''Примечание:''' При объявлении констант следите за тем, чтобы их тип был ясно виден из строки объявления. Если выражение инициализатора представляет собой довольно сложное математическое выражение, либо содержит вызовы функций, лучше всего указать тип константы явно (как в примере с константой ''e''). Иначе, это может вызывать проблемы в будущем, при работе программы или при ее отладке. В целом ситуация такая же, что и с инициализацией переменных ([[Переменные#Типизация при инициализации|см. примечание]]).<br />
<br />
== Константные объекты ==<br />
<br />
Как уже было сказано выше, константами могут являться или быть объявлены любые объекты языка. Даже числа и строки, фигурирующие в программе в явном виде — тоже являются константными объектами. И их тоже можно использовать как объекты. <br />
<br />
Например, так можно узнать длину строки, используя свойство <tt>length</tt>:<br />
<source lang="kpp">var len = "hello world".length();</source><br />
<br />
В общем случае, создать константный объект можно тем же способом что и обычную переменную-экземпляр класса:<br />
<source lang="kpp"><br />
const myinstance = new MyClass;<br />
const myobject = MyClass.Create();<br />
</source><br />
<br />
== Константные функции ==<br />
<br />
При работе с константными объектами подразумевается, что их значение (простые объекты, вроде числовой константы) или в общем случае их состояние (экземпляр некоторого класса) не будут изменено. Чтобы указать компилятору, какие методы и операторы можно использовать, а какие нет, вводится понятие ''спецификатора функции''. Спецификатор <tt>'''const'''</tt>, указанный в объявлении метода или оператора указывает на то, что этот метод не изменяет состояния объекта и может вызываться для констант:<br />
<br />
<source lang="kpp"><br />
class MyClass {<br />
var m_i = 0;<br />
public const function ShowStatus() { println(m_i); } <br />
public function Check() { return i > 5; }<br />
function SetI(value) { m_i = value; }<br />
property i read m_i write SetI;<br />
}<br />
</source><br />
<br />
В том случае, если где-то в коде будет создан константный экземпляр класса, то он будет допускать чтение свойства ''i'' и вызовы метода <tt>ShowStatus()</tt>, но не <tt>SetI()</tt>:<br />
<br />
<source lang="kpp"><br />
var v = new MyClass; //создаем экземпляр-переменную<br />
const c = new MyClass; //создаем экземпляр-константу<br />
<br />
println('v =' + v.i); //можно, доступ на чтение<br />
println('c =' + c.i); //тоже можно, чтение свойства разрешено<br />
v.i = 5; //можно, v - переменная<br />
c.i = v.i; //нельзя, c - константа, запись свойства запрещена<br />
v.Check(); //можно<br />
<br />
c.Check(); //нельзя. метод не помечен как const <br />
//(хоть и не изменяет состояния)<br />
<br />
v.ShowStatus(); //можно<br />
c.ShowStatus(); //тоже можно, метод не меняет состояния (помечен как const)<br />
</source></div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5Переменные2007-10-01T09:09:31Z<p>KroTozeR: </p>
<hr />
<div>__TOC__<br />
== Понятие переменной, тип переменной ==<br />
<br />
В классических книгах по программированию, под переменными понимают некоторую поименованную область памяти, либо регистр процессора. В нашем же случае, мы имеем дело с виртуальной машиной, соответственно ни регистров, ни памяти в обычном понимании у нас нет. Все, с чем мы имеем дело, это с объектами в "сознании" виртуальной машины. Так или иначе, но и там и тут переменные служат для одной цели: для хранения некоторой информации. Ей могут быть и исходные данные программы, и некоторые промежуточные значения, или же результаты выполнения программы. Впрочем, некоторые программы могут не иметь исходных данных (например, генератор текстур), другие же могут не производить никакого вывода, так что все это довольно условно.<br />
<br />
Поэтому, будем считать проще, что переменная это просто некоторая сущность, некоторый объект, способный хранить данные. Под данными мы будем понимать любую информацию, которую возможно представить в цифровом виде.<br />
<br />
=== Тип переменной ===<br />
<br />
Часто с понятием переменной связывают понятие ее типа. Стоит отметить, что это понятие так же является математической абстракцией. С точки зрения самой машины все данные представляют собой одно и то же — совокупность нулей и единиц. А что под ними понимать в каждом конкретном случае — решает уже программист. Так вот, в некотором смысле ''тип переменной'' показывает, что именно хранится в данной переменной. <br />
<br />
Наиболее распространенные типы переменных это:<br />
* Логический тип, принимающий только два значения ("истина" и "ложь")<br />
* Целые числа различной длины (байт, слово, двойное слово и т. д.)<br />
* Числа с плавающей точкой<br />
* Строки (последовательность байтов в памяти, воспринимаемая как строка текста)<br />
* Указатели (переменные, содержащие в себе адрес другой переменной)<br />
* Составные типы (некоторая совокупность из вышеперечисленных типов)<br />
<br />
Как уже говорилось выше, первоначально о типе переменной знал только программист, пишущий программу. Естественно, вся ответственность за соблюдение соответствия типов выполняемым операциям была возложена на самого программиста. Постепенно, с развитием языков программирования высокого уровня, была выдвинута идея явным образом сопоставлять переменной ее тип. Это обеспечивало большее удобство в написании программ, поскольку всю работу по контролю над типами выполнял сам компилятор, который выдавал сообщения об ошибках, если типы переменных не соответствовали операциям, или была вероятность неверного их истолкования. Так появились языки со статической типизацией.<br />
<br />
== Статическая типизация на примере C++ ==<br />
<br />
Итак, ''статическая типизация'' это — приём, при котором переменная, параметр подпрограммы или возвращаемое значение функции связывается с типом в момент объявления и этот тип не может быть изменён позже (переменная или параметр будут принимать, а функция будет возвращать значения только этого типа). <br />
<br />
То есть, если мы объявляем переменные целочисленного типа как <tt>int i, j;</tt> то мы можем выполнять над ними только операции, соответствующие понятиям этого типа, вроде операции сложения <tt>i + j</tt> или операции присваивания одной переменной другой <tt>i = j</tt>. Если же мы попытаемся присвоить такой переменной значение другого, ''неприводимого'' типа, например <tt>i = "hello world"</tt> то компилятор выдаст ошибку.<br />
<br />
Рассмотрим кратко преимущества и недостатки статически типированных языков и сравним их впоследствии с другими подходами к типизации.<br />
<br />
Преимущества статической типизации:<br />
* Строгость программ<br />
* Большая возможность оптимизации, а, следовательно:<br />
** Высокая скорость работы<br />
** Минимальные требования к памяти<br />
<br />
Недостатки:<br />
* Необходимость объявления типов даже там где это очевидно<br />
* Засорение кода программы дополнительными символами, а, следовательно:<br />
** Отвлечение внимания программиста от самой задачи в сторону рутины формализации<br />
** Плохая читаемость кода<br />
* Необходимость дополнительных ухищрений для передачи параметров разных типов<br />
* Невозможность написания абстрактных алгоритмов<br />
<br />
'''Вывод:''' Программы, написанные на языках со статической типизацией, обладают большой эффективностью и производительностью, однако это дается ценой строгости и определенности. Программирование на таких языках это принятие их правил игры, при этом программист должен мыслить в жестко ограниченных рамках. Вот почему эти языки чаще всего применяются именно для системного программирования, где в первую очередь важна производительность полученного кода, и только потом удобство его написания и поддержки.<br />
<br />
== Динамическая типизация на примере Ruby ==<br />
<br />
Впоследствии, в противовес статической типизации была разработана модель динамически типированных языков. При таком подходе, переменная не имеет заранее определенного типа, а принимает тип при инициализации и при присвоении ей некоторого значения. Таким образом, в различных участках программы одна и та же переменная может принимать значения разных типов. <br />
<br />
На первый взгляд это может показать странным, особенно с точки зрения программиста, привыкшего к статически типированным языкам (таким как С++ или Паскаль). На самом деле здесь нет ничего страшного или нелогичного. Все мы в своей жизни, сами того не подозревая, оперируем понятиями динамических переменных. Один и тот же объект в разных ситуациях мы можем воспринимать с разных точек зрения. Задавая вопрос "как пройти в библиотеку", мы можем получить как конкретный ответ "в 3 часа ночи?! идиот!" так и целый набор: "на автобусе номер 23, на такси или пешком, тут не очень далеко". При этом нас совершенно не смущает то, что мы заранее не знаем, каков будет результат, наоборот — это дает нам большую гибкость и свободу действий; мы двигаемся дальше на основании того, каков был результат предыдущей операции. Подобно этому примеру, мы можем писать программы, которые оперируют переменными неопределенного типа. В результате, код получается более лаконичным, более читаемым и, в конце концов, более близким к естественному восприятию человека (ведь именно этого мы ждем от языков программирования!).<br />
<br />
Концепция динамической типизации в полной мере нашла свое применение в языке Ruby. В этом языке любая переменная может в разное время иметь различные типы. Вот пример кода на этом языке:<br />
<br />
<source lang="ruby"><br />
def get_data(need_array = false)<br />
result = 0 # целое число<br />
if need_array<br />
result = [ 1, 2, 3, 4 ] # тип меняется на Array<br />
else<br />
result = { 1 => 2, 3 => 4} # тип меняется на Hash<br />
end<br />
result<br />
end<br />
</source><br />
<br />
Преимущества динамической типизации:<br />
* Легкость написания программ<br />
* Лаконичность и хорошая читаемость<br />
* Высокая гибкость языка. Возможность решения проблемы разными способами<br />
* Большая возможность повторного использования кода (абстрактные алгоритмы)<br />
<br />
Недостатки:<br />
* Существенно меньшая производительность, по сравнению со статически типированными языками<br />
* Сложность в написании оптимизаторов, их малая эффективность<br />
* Как правило, динамически типированные языки являются интерпретаторами (компиляция неэффективна)<br />
<br />
'''Вывод:''' Языки с динамической типизацией очень удобны для использования на прикладном уровне. Учитывая их высокую гибкость и лаконичность, программисту легче излагать свои мысли, при том, что свое внимание он концентрирует на самой задаче, не отвлекаясь на частные проблемы реализации. Конечно, они уступают по эффективности статическим, компилируемым языкам, однако это уже вопрос, требующий отдельного рассмотрения в рамках конкретно поставленной задачи.<br />
<br />
== Полудинамическая типизация ==<br />
<br />
Рассмотрев преимущества и недостатки статической и динамической типизации, мы подходим к мысли объединения этих двух подходов в рамках одного языка. Языка, который бы сочетал в себе все преимущества динамической типизации, с возможностью указания типов там, где это необходимо. В результате мы получили бы язык, достаточно гибкий и в то же время позволяющий эффективно работать с типами.<br />
<br />
Язык К++ как раз и ставит перед собой задачу совмещения этих двух подходов. Переменные этого языка могут быть либо типированными, либо не типированными (динамическими). Первые обеспечивают производительность, вторые — гибкость. Достигается это, прежде всего ценой того, что переменная не может изменять свой тип во время выполнения программы. Однако это относится только к статически типированным переменным. Полностью динамические переменные этого недостатка лишены. <br />
<br />
При разработке программы на языке К++, программист должен стараться держать баланс между удобством написания программы и ее эффективностью. В целом, рекомендуется указывать типы переменных везде, где это возможно. Динамические же переменные следует применять в тех местах, где заранее неизвестно, с каким типом переменной придется работать. При этом код получится достаточно производительным и одновременно гибким.<br />
<br />
== Типизация при объявлении ==<br />
<br />
Язык К++ позволяет задавать тип переменной несколькими способами. Одним из них является типирование переменной при объявлении. При этом необходимо написать ключевое слово <tt>'''var'''</tt>, за которым следует [[идентификатор]] типа переменной, а затем ее имя. Точка с запятой (;) завершает конструкцию:<br />
<br />
<source lang="kpp"><br />
var int i;<br />
</source><br />
<br />
Здесь мы объявили [[Стандартные типы данных#Числа|целочисленную]] переменную с именем ''i'' и неявно [[Инициализация|инициализировали]] ее значением 0. Такой синтаксис удобен в тех случаях, когда заранее неизвестно каким должно быть значение переменной. Видимо, в данном случае программист решил, что оно будет присвоено явным образом впоследствии. Если же заранее ясно, что на момент объявления переменная должна иметь определенное значение, следует применять синтаксис ''объявления с инициализацией''.<br />
<br />
'''Примечание:''' Неявная инициализация это причина многих трудноуловимых ошибок времени выполнения. В языке К++ это имеет менее разрушительные последствия, чем например в С++ (где значение неинициализированной переменной может быть абсолютно произвольным!), тем не менее '''настоятельно рекомендуется инициализировать переменные''' сразу при объявлении. Это избавит вас от опасности забыть присвоить значение переменной впоследствии.<br />
<br />
== Типизация при инициализации ==<br />
<br />
Более предпочтительным способом объявления типированной переменной является ''объявление с инициализацией''. В данном случае, под ''инициализацией'' понимается процесс начального задания значения переменной. Для этого следует так же написать ключевое слово <tt>'''var'''</tt>, после которого сразу идет [[идентификатор]] имени переменной, а затем выражение — инициализатор, присваивающее значение вновь созданной переменной. При этом тип переменной будет определен как тип инициализатора:<br />
<br />
<source lang="kpp"><br />
var i = 0;<br />
var s = "hello world";<br />
</source><br />
<br />
В приведенном выше примере, переменной ''i'' будет назначен целочисленный тип (<tt>[[Стандартные типы данных#Целые числа|int]]</tt>), в то время как переменная ''s'' будет иметь строковый тип (<tt>[[Стандартные типы данных#Строки|string]]</tt>).<br />
<br />
'''Примечание:''' В некоторых случаях может сложиться ситуация, что инициализатор переменной это довольно сложное выражение. При этом программисту сложно определить, какой же на самом деле будет тип переменной. Для ясности приведем пример из разряда "как не надо делать":<br />
<br />
<source lang="kpp"><br />
var x = 2+3*4+f(3)/3*0.2;<br />
</source><br />
<br />
Синтаксически здесь все верно. Переменная будет создана и ей будет назначен некоторый тип. Но вот какой? Опытный читатель заметит, что в выражении присутствуют константы с плавающей точкой и операция деления. Стало быть, в результате [[Приведение типов|приведения типов]], результирующий тип переменной так же будет [[Стандартные типы данных#Числа с плавающей точкой|числом с плавающей точкой]]. Внимательный же читатель заметит так же, что в выражении присутствует [[Выражения#Вызов функций|вызов функции]] <tt>f(3)</tt>. И тут дело обстоит еще хуже. [[Функции|Функция]] может возвращать значение любого типа. Чтобы узнать какого именно, нужно обратиться к документации, либо к описанию самой функции. А что если она возвращает нетипированную переменную ([[Переменные#Нетипированные (динамические) переменные|см. ниже]])? Тогда предсказать тип переменной будет еще сложнее (если забежать вперед, то можно сказать что результат выражения так же будет нетипирован).<br />
<br />
Скорее всего, Читатель уже согласился с мыслью, что подобных конструкций следует избегать. Однако что же делать, если все же требуется завести переменную, которая должна быть инициализирована подобным образом? Выхода тут может быть два. Либо отделить объявление переменной от ее инициализации, либо совместить типированное объявление с инициализацией.<br />
<br />
Первый вариант:<br />
<source lang="kpp"><br />
var real x;<br />
... //где то по коду программы<br />
x = 2+3*4+f(3)/3*0.2; <br />
</source><br />
<br />
Второй, более удачный вариант:<br />
<source lang="kpp"><br />
var real x = 2+3*4+f(3)/3*0.2;<br />
</source><br />
<br />
Стоит отметить, что во втором случае будет выполнена операция [[Приведение типов|приведения типов]], то есть будет сделана попытка преобразовать тип значения инициализатора к явно указанному типу переменной. Если тип инициализатора возможно ''привести'' к типу переменной, то все пройдет успешно. Если же типы ''неприводимы'', то произойдет либо ошибка компиляции (при статическом типе инициализатора), либо ошибка времени выполнения.<br />
<br />
== Нетипированные (динамические) переменные ==<br />
<br />
Иногда бывает необходимо работать с переменной, тип которой на момент компиляции неизвестен. В этом случае применяются ''нетипированные'' или ''динамические'' переменные. Такие переменные объявляются просто, путем написания ключевого слова <tt>'''var'''</tt>, за которым идет [[идентификатор]] имени переменной:<br />
<br />
<source lang="kpp"><br />
var x;<br />
</source><br />
<br />
В ходе работы программы, такая переменная может принимать значения любых типов. Она будет автоматически приводиться к нужным типам (и наоборот), что, в конечном счете, обеспечивает гибкость кода.<br />
<br />
Примером применения динамических переменных могут послужить контейнеры — объекты, которые могут хранить в себе другие объекты. Простейшими примерами контейнеров могут послужить [[Стандартные типы данных#Массивы|массивы]]. В языке К++ массивы не являются типированными. Они могут хранить любые объекты, даже объекты различных типов. Разумеется, сам массив оперирует со своими элементами как с нетипированными переменными (ведь он не знает заранее, объекты каких типов будут в него класть). <br />
<br />
Программист может написать некоторую подпрограмму для обработки элементов массива, например для их сортировки. При этом все, что ему нужно знать это способ перебора элементов контейнера и некоторую операцию сравнения двух элементов, для выяснения их очередности (эту операцию контейнеру предоставляет пользователь; как именно это делается, будет описано [[Блоки#Применение блоков|дальше]]). Этим достигается эффективность написания кода, и открываются широкие возможности по повторному использованию кода. К примеру, в традиционных типированных языках вроде Паскаля, пришлось бы реализовывать отдельные методы сортировки строк, числовых массивов и т. д., здесь же мы обходимся одной реализацией.<br />
<br />
'''Примечание:''' Применение динамических переменных негативно сказывается на эффективности работы программы и на скорости ее выполнения. Поэтому старайтесь применять динамические переменные только там где это действительно необходимо, либо там где не требуется высокая производительность.<br />
<br />
== О важности инициализации переменных ==<br />
<br />
В заключение этой главы, приведем краткое обобщение материала относительно инициализации переменных. Как уже было сказано выше, инициализация переменных это важный момент, правильное понимание которого позволит программисту писать более эффективные программы, и в то же время избавить себя от многих типичных ошибок программирования. В ходе изучения языка постарайтесь выработать у себя некоторые шаблоны проектирования, следуя которым вы избавите себя от возможных проблем.<br />
<br />
Вот некоторый список рекомендаций относительно объявления переменных:<br />
* Старайтесь всегда объявлять переменные, инициализируя их<br />
* Если выражение инициализатора достаточно сложное, либо содержит вызовы функций, применяйте явное типирование объявляемой переменной, либо используйте [[приведение типов]] в самом выражении<br />
* Объявляйте переменные как можно ближе к месту их использования<br />
* Нетипированные переменные применяйте только в тех случаях, где это действительно необходимо<br />
<br />
Конечно, этот список далеко не полный, да он и не претендует на полноту. То, что написано выше ни в коем случае не является правилом, которому нужно следовать непременно, везде и всегда. Границы разумного определяете вы сами. Просто старайтесь не упускать этих моментов из виду.</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5,_%D0%B8%D0%BB%D0%B8_%D0%BA%D1%80%D0%B0%D1%82%D0%BA%D0%B8%D0%B9_%D0%BE%D0%B1%D0%B7%D0%BE%D1%80Введение, или краткий обзор2007-10-01T08:47:51Z<p>KroTozeR: </p>
<hr />
<div>__TOC__<br />
<br />
(Введение...)<br />
<br />
== Здравствуй, мир! ==<br />
<br />
Классический пример программы, выводящей строку "Hello, world!" на экран, на языке K++ выглядит следующим образом:<br />
<br />
<source lang="kpp" line="1"><br />
package hello_world;<br />
<br />
external console_stream STDOUT;<br />
<br />
export function void main()<br />
{<br />
STDOUT.print("Hello, world!\n");<br />
}<br />
</source><br />
<br />
<br />
;1: Как уже [[Модули|отмечалось ранее]], в K++ любая программа или библиотека является модулем. Ключевое слово <tt>'''package'''</tt> используется для объявления имени модуля, в который должна быть скомпилирована программа.<br />
<br />
;3: Здесь мы объявляем глобальную переменную ''STDOUT'', имеющую тип <tt>console_stream</tt>. Ключевое слово <tt>'''external'''</tt> помечает переменную как ''внешнюю'' — т.е. создаваемую пользователем. <br />
<br />
;5-8: Наконец, объявляется функция <tt>main()</tt>, которая вызывает метод <tt>print()</tt> объекта ''STDOUT'', передав ему строку "Hello, world!\n" в качестве параметра.<br />
<br />
: Ключевое слово <tt>'''export'''</tt> говорит о том, что имя функции не следует декорировать. Декорирование имен применяется для того, чтобы дать возможность [[Функции#Перегрузка функций и операторов|перегружать функции]] с одинаковыми именами, но разными списками параметров (или параметрами разных типов).<br />
<br />
<br />
Теперь несколько слов о том, как такая программа будет запущена. В первую очередь стоит отметить, что нет никаких стандартов на имя функции <tt>main()</tt> или объекта ''STDOUT''. На платформе Gide каждая программа является библиотекой, и порядок ее использования полностью определяется пользователем. В данном случае предполагается, что программа будет запускаться при помощи консольной команды '''gide.run''', реализованной в модуле стандартной библиотеки. Эта команда определяет три глобальные переменные ''STDIN'', ''STDOUT'' и ''STDERR'', имеющие тип <tt>console_stream</tt> и запускает функцию <tt>main()</tt>, экспортируемую программой.<br />
<br />
Если бы мы, скажем, писали программу, генерирующую текстуру — никакой функции <tt>main()</tt> в ней не было бы. Набор экспортируемых ей функций полностью определялся бы требованиями генератора текстур, которые описаны в соответствующей документации.<br />
<br />
== Более сложный пример ==<br />
<br />
Вот более сложный пример, демонстрирующий использование переменных и циклов:<br />
<br />
<source lang="kpp" line="1"><br />
package sums;<br />
<br />
export function void main()<br />
{<br />
var ary = [ 1, 2, 3, 4 ];<br />
var sums = new array;<br />
var int i;<br />
sums.push(ary[0]);<br />
for(i = 1; i < ary.size(); ++i)<br />
sums.push(sums[i-1] + ary[i]);<br />
}<br />
</source><br />
<br />
Смысл этой программы понятен интуитивно: создается два массива — исходный (''ary'') и результирующий (''sums''), и затем массив ''sums'' заполняется суммами чисел из массива ''ary'' от 0 до текущего индекса i.<br />
<br />
;5-6: Особое внимание в этом примере следует уделить объявлениям переменных. Мы видим, что объявляются два [[Стандартные типы данных#Массивы|массива]] — ''ary'' и ''sums'', причем в инструкции <tt>'''var'''</tt> их тип никак не указывается. В этом случае работает следующее правило: если при объявлении переменной ее тип не указан, то типом переменной становится тип результата инициализатора переменной, т.е. выражения, стоящего справа от оператора '='.<br />
<br />
:Выражения, записанные в квадратных скобках через запятую — это встроенная в K++ конструкция, создающая объект, имеющий тип <tt>[[Стандартные типы данных#Массивы|array]]</tt> (объявленный в [[Стандартная библиотека gide|стандартной библиотеке]]) и заполненный соответствующими значениями.<br />
<br />
:Оператор <tt>'''new'''</tt> создает экземпляр произвольного класса — здесь мог бы стоять, в том числе, и пользовательский класс. В данном случае <tt>'''new'''</tt> создает экземпляр класса <tt>[[Стандартные типы данных#Массивы|array]]</tt>.<br />
<br />
;7: Здесь мы создаем переменную типа <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. Когда тип указан в самой конструкции <tt>'''var'''</tt> — объект соответствующего класса создается автоматически. Таким образом, например, следующие объявления эквивалентны:<br />
<br />
<source lang="kpp"><br />
var sums = new array;<br />
var sums = [ ];<br />
var array sums;<br />
</source><br />
<br />
или<br />
<br />
<source lang="kpp"><br />
var i = 0;<br />
var i = new int;<br />
var int i;<br />
</source><br />
<br />
Метод <tt>push()</tt> класса <tt>array</tt> добавляет элемент в конец массива; <tt>size()</tt> — возвращает количество элементов массива. Дальнейший код, думаю, объяснять не стоит.<br />
<br />
== Использование блоков ==<br />
<br />
Подобно языку Ruby, в K++ реализован механизм передачи в качестве параметра функции некоторого связанного (с вызовом) блока кода. Функция затем может вызвать этот блок один или более раз, и воспользоваться результатом, который он возвращает.<br />
<br />
Выглядит это следующим образом:<br />
<br />
<source lang="kpp" line="1"><br />
package block_demo;<br />
<br />
external console_stream STDOUT;<br />
<br />
function void times(int i, block b)<br />
{<br />
var int n;<br />
for(n = 0; n < i; ++n)<br />
b(n);<br />
}<br />
<br />
export function void main()<br />
{<br />
times(3) { |i| STDOUT.print((i as string) + " "); };<br />
STDOUT.print("\n");<br />
}<br />
</source><br />
<br />
Результат выполнения программы:<br />
<br />
0 1 2<br />
<br />
Данный пример также демонстрирует объявление параметров функции: это делается в стиле языка C. Впрочем, тип параметра функции можно опустить — в этом случае будет сгенерирован [[Переменные#Динамическая типизация на примере Ruby|динамический код]].<br />
<br />
;14:В функции <tt>main()</tt> используется специальный синтаксис для вызова функции <tt>times()</tt>: тело блока идет сразу после оператора вызова функции. Такой синтаксис работает только в том случае, если параметр—блок объявлен последним.<br />
<br />
Можно было бы переписать эту конструкцию так:<br />
<br />
<source lang="kpp"><br />
var b = { |i| STDOUT.print((i as string) + " "); };<br />
times(3,b);<br />
</source><br />
<br />
Параметры блока могут быть перечислены между символами "|" через запятую. В данном случае блок принимает один параметр — номер итерации.<br />
<br />
== Расширение классов ==<br />
<br />
Приведенный выше пример можно переписать следующим образом:<br />
<br />
<source lang="kpp" line="1"><br />
package extend_demo;<br />
<br />
external console_stream STDOUT;<br />
<br />
extend int {<br />
public const function void times(block b)<br />
{<br />
var int n;<br />
for(n = 0; n < this; ++n)<br />
b(n);<br />
}<br />
}<br />
<br />
export function void main()<br />
{<br />
3.times() { |i| STDOUT.print((i as string) + " "); };<br />
STDOUT.print("\n");<br />
}<br />
</source><br />
<br />
<br />
;5-12: Оператор <tt>'''extend'''</tt> расширяет функционал класса — в данном случае класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. Его использование аналогично объявлению класса, но объявленные внутри поля, методы и операторы будут добавлены к уже существующему классу.<br />
<br />
: Таким образом, к классу <tt>int</tt>, объявленному в стандартной библиотеке, добавляется метод <tt>times()</tt>, вызывающий связанный блок количество раз, равное текущему числу (не забываем: мы добавляем метод в класс <tt>int</tt>, который отвечает за хранение числа).<br />
<br />
;16: После такого объявления, в функции <tt>main()</tt> мы используем уже метод <tt>times()</tt> класса <tt>int</tt>: конструкция <tt>3.times()</tt> означает создание объекта 3 класса <tt>int</tt> и вызов у этого объекта метода <tt>times()</tt>.<br />
<br />
<br />
'''Примечание:''' Расширение будет работать во всем модуле, а так же во всех модулях, которые импортируют данный модуль.</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:K%2B%2BОбсуждение:K++2007-09-30T22:05:28Z<p>KroTozeR: Новая: Буду периодически править грамматику по главам.--~~~~ Подправил грамматику главы "Введение".--~~~~</p>
<hr />
<div>Буду периодически править грамматику по главам.--[[Участник:KroTozeR|KroTozeR]] 18:05, 30 сентября 2007 (EDT)<br />
<br />
Подправил грамматику главы "Введение".--[[Участник:KroTozeR|KroTozeR]] 18:05, 30 сентября 2007 (EDT)</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%98%D0%B4%D0%B5%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0Идеология языка2007-09-30T22:03:39Z<p>KroTozeR: </p>
<hr />
<div>== Немного теории о языках программирования ==<br />
<br />
В этой главе мы кратко рассмотрим основные понятия, касающиеся языков программирования, а также попробуем классифицировать язык К++ с позиции этих понятий.<br />
<br />
Любой язык программирования создается для решения определенного круга задач. Не существует языка, который бы позволял одинаково удобно решать задачи любого характера. Языки программирования различают по многим критериям, делят на большое количество классов и т. д. Мы же рассмотрим такой вопрос как идеологические особенности языка. Здесь, под идеологией языка понимаются некоторые конкретные подходы к отдельным вопросам, например к используемым парадигмам программирования, принципам организации памяти, отношению к исключениям и т. д.<br />
<br />
== Компиляторы и интерпретаторы ==<br />
<br />
Все языки программирования можно условно разделить на два класса: компилируемые и интерпретируемые. <br />
<br />
''Компилируемые языки программирования'' - это такие языки, для обработки которых используются ''компиляторы''. Они преобразуют исходный код программы в машинный код, понятный конкретному процессору и способный выполняться на нем непосредственно. К достоинствам такого подхода можно отнести то, что программа, написанная целиком на машинном коде, имеет высокую производительность. Недостатком является то, что скомпилированная программа ориентирована на конкретную архитектуру и на конкретный процессор. В результате, программа, собранная для одного процессора не будет работать на другом.<br />
<br />
''Интерпретируемые языки программирования'' - языки, для обработки которых используются ''интерпретаторы'', которые (в противовес компиляторам) не производят преобразования программы в машинные коды, а исполняют ее непосредственно. Конечно, производительность интерпретаторов заметно меньше, однако для выполнения, программу не требуется компилировать — она будет работать на любой платформе, где есть реализация ее интерпретатора. <br />
<br />
Условным это разделение было названо потому, что граница между компиляторами и интерпретаторами очень прозрачная. Практически любой компилируемый язык можно интерпретировать, в то же время многие современные интерпретаторы для повышения быстродействия производят т. н. "компиляцию на лету", при которой исходный текст программы преобразуется в абстрактный набор инструкций или байт код, который уже выполняется.<br />
<br />
Язык К++ как раз относится к такой промежуточной категории языков. В результате компилирования исходного текста программы на языке К++ получается байт код модуля, который уже может быть выполнен на виртуальной машине gide. Байт код является платформенно независимым, что позволяет исполнять его на любой платформе, где существует реализация виртуальной машины.<br />
<br />
== Парадигменность ==<br />
<br />
[http://ru.wikipedia.org Википедия] дает следующее определение понятия парадигма программирования: <br />
<br />
«''Парадигма программирования — это [http://ru.wikipedia.org/wiki/Парадигма парадигма], определяющая стиль программирования, иначе говоря — некоторый цельный набор идей и рекомендаций, определяющих стиль написания программ. Парадигма программирования представляет (и определяет) то, как программист видит выполнение программы. Например, в объектно-ориентированном программировании, программист рассматривает программу как набор взаимодействующих объектов, тогда как в функциональном программировании программа представляется в виде цепочки вычисления функций''».<br />
<br />
В общем смысле, под ''парадигмой'' можно понимать некоторый набор концепций, которые применяются при построении программы. Языки, которые позволяют писать программы в рамках нескольких парадигм, называются ''мультипарадигменными''. Например, язык К++ позволяет писать программы в структурном (совокупность функций, вызывающих друг друга), объектно-ориентированном (построение объектной модели) и смешанном (объединение обоих подходов) стилях. Следовательно, К++ тоже может служить примером мульрипарадигменного языка.<br />
<br />
Говоря о парадигмах, нельзя не упомянуть подлинно объектно-ориентированную природу языка К++, которая достигается уже на уровне виртуальной машины. В отличие от C++, где объектная модель является всего лишь "надстройкой" над структурной основой, язык К++, подобно Ruby и его предтечи — языку Smalltalk, придерживается принципа "все есть объект". Это значит, что все элементы языка являются объектами. Встроенные типы данных отсутствуют, вместо них применяются классы из [[Стандартная библиотека gide|стандартной библиотеки]] языка. Это позволяет добиться удивительной гибкости при проектировании программ, вплоть до того, что программист может видоизменять даже стандартные классы, расширяя их и добавляя в них собственный функционал.<br />
<br />
'''Примечание:''' Более подробно, о расширениях можно почитать в кратком [[Введение, или краткий обзор#Расширение классов|обзоре]], либо в главе [[K++ как объектно-ориентированный язык#Расширения|K++ как объектно-ориентированный язык]].<br />
<br />
== Понятие о типизации ==<br />
<br />
Если говорить кратко, то под типизацией понимаются принципы организации переменных в языке. Различают ''статическую типизацию'', при которой каждой переменной ставится в соответствие ее тип, который не может быть изменен в процессе выполнения программы, и ''динамическую типизацию'', где переменные меняют свой тип от случая к случаю. К++ вводит понятие ''полудинамической типизации'', которая сочетает в себе преимущества обоих подходов и позволяет взять лучшие стороны каждого из них.<br />
<br />
'''Примечание:''' Более подробно понятие типизации рассмотрено в главе [[Переменные]].<br />
<br />
== Управление памятью ==<br />
<br />
Различные языки подразумевают разные способы управления памятью. Некоторые языки, например, такие как Си, предоставляют программисту прямой доступ к памяти, при этом программист сам должен следить за тем, чтобы память выделялась по мере обращения к ней и, самое главное, своевременно освобождалась после использования.<br />
<br />
Другие же языки, предоставляют программисту лишь тот уровень абстракции, на который они рассчитаны, при том, что вся работа по управлению памятью ложится на сам язык. Это уберегает программиста от проблем и ошибок, связанных с неправильной работой с памятью. Например, язык Java не предполагает прямого доступа к памяти виртуальной машины. Взамен, он предоставляет наборы классов, которые должны обеспечить программиста всеми необходимыми инструментами.<br />
<br />
Подобно Java, язык К++ так же не предполагает прямого доступа к памяти. В терминах языка программист описывает свои требования к хранилищу данных, не заботясь о том, как нужно выделять память и когда ее освобождать.<br />
<br />
== Понятие исключения ==<br />
<br />
С развитием вычислительной техники и усложнения программ возникла проблема стабильности программ. Традиционный подход, при котором функция возвращает код ошибки, превратил разработку программного обеспечения в настоящий ад, при том, что буквально каждый вызов функции приходилось оборачивать в соответствующее условие проверки кода ошибки. В некоторых областях это все же оправданно (например, ядро Диптауна с успехом применяет этот механизм в совокупности со стеком ошибок). В других областях, таких как сфера прикладного ПО такой подход менее востребован, поскольку там приводятся жесткие требования к скорости написания программ и к их качеству.<br />
<br />
В результате, возникла концепция исключительных ситуаций или ''исключений''. ''Механизм исключений'', — это концепция, позволяющая повысить стабильность работы программы путем внесения в нее своеобразных "контрольных точек". Если в процессе работы программы происходит непредвиденная ситуация, например, такая как ошибка ввода-вывода или внезапное прекращение сеанса связи, то код, обнаруживший ошибку, создает специальный объект-исключение и "выбрасывает" его, то есть ''генерирует исключение''. При этом, выполнение программы прерывается и управление передается ближайшей контрольной точке, которая может перехватить это исключение и принять некоторое решение относительно того что делать дальше: например, показать пользователю сообщение об ошибке.<br />
<br />
Преимущество концепции исключений в том, что программисту не надо проверять каждый вызов на правильность. Он просто пишет код, предполагая что "все идет как надо". Лишь в некоторых местах, где заранее предусматривается возможность возникновения ошибки, вставляются те самые опорные точки — перехватчики исключений. Если же ошибка произойдет, то она рано или поздно будет отловлена.</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%98%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F_%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D1%8F_%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0История создания языка2007-09-30T21:50:30Z<p>KroTozeR: </p>
<hr />
<div>Когда мы разрабатывали платформу Диптауна, мы постоянно держали в уме следующие критерии:<br />
<br />
* Кроссплатформенность<br />
* Расширяемость<br />
* Распределенность<br />
* Масштабируемость <br />
* Гибкость<br />
* Модульность<br />
<br />
То есть, система должна работать на максимально возможном количестве аппаратных платформ. При этом для портирования на новую платформу трудозатраты должны быть минимальными. Система должна быть легко расширяемой, позволяя легко и быстро интегрировать новые возможности без необходимости внесения значительных модификаций в код. Система должна быть масштабируемой, то есть она должна предоставлять возможность ее выполнения в сети с использованием множества вычислительных систем. Добавление очередного "узла" должно быть прозрачным для остальной части системы, равно как и сбой одного из существующих узлов не должен оказать значительного влияния на функционирование оставшейся части системы. Система должна быть достаточно гибкой, чтобы одну и ту же задачу возможно было решать несколькими способами. Наконец, система должна быть построена таким образом, чтобы можно было свободно заменять некоторые ее части на предоставляющие те же возможности, и чтобы эта замена так же осталась прозрачной.<br />
<br />
Учитывая все эти факторы, очевидно, что решить такую задачу традиционным образом практически невозможно. Различия в архитектурах систем и в особенностях их реализации сводят на нет все усилия по "обобщению" задач. Код, написанный на одной платформе, не будет работать на другой и наоборот. Пришлось бы для каждой из платформ делать свою отдельную релаизацию системы. Думаю, что Читатель может себе представить, во что обошлась бы разработка и самое главное поддержка подобной системы.<br />
<br />
Решение проблемы кроется в системах абстракции и виртуализации. Вместо написания множества реализаций одной и той же системы, пишется некая система абстракции, которая представляет собой прослойку между низкоуровневым кодом конкретной платформы и высокоуровневым кодом нашей системы. Эту задачу решает библиотека OSA и ядро диптауна, которые вместе предоставляют удобный программный интерфейс для кроссплатформенной разработки программ. Однако платформа диптауна из соображений производительности написана на языке С++, который хоть и является в некоторой степени кроссплатформенным, все же не обеспечивает бинарной совместимости программ. <br />
<br />
Таким образом, мы подходим к третьему уровню абстракции — виртуальной машине. Виртуальная машина это вычислительная среда, которая построена целиком на программной основе и поэтому не зависит от особенностей конкретной архитектуры, будь то x86, SPARC или ARM. Виртуальная машина, подобно реальной, оперирует понятиями кода и данных. В отличие от реального процессора, кодом для виртуальной машины являются не инструкции, а байт код — набор абстрактных инструкций. Достоинством такого подхода является то, что программа, транслированная в байт код, будет выполняться на любой платформе, где есть реализация виртуальной машины. А поскольку виртуальная машина сама написана на базе кроссплатформенного кода, то это обеспечивает еще большие возможности по переносимости.<br />
<br />
В рамках проекта Диптаун была написана своя собственная виртуальная машина [[gide]]. Она написана целиком на нашей платформе и учитывает ее особенности. Для программирования виртуальной машины используется свой язык, похожий на ассемблер, но его применение в практических задачах сильно затруднено (сложность написания программ, а главное их отладки). Было принято решение написать язык высокого уровня, который бы компилировался в gide ассемблер. В результате этого и появился язык К++.</div>KroTozeRhttp://man.deeptown.org/index.php/%D0%9F%D1%80%D0%B5%D0%B4%D0%B8%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D0%B5Предисловие2007-09-30T21:36:22Z<p>KroTozeR: </p>
<hr />
<div>__NOTOC__<br />
В последнее время наблюдается постоянный интерес программистов к написанию собственных языков программирования. Одни видят в этом хороший способ повысить свою квалификацию, другие делают это из интереса, третьи — из желания сделать язык, отвечающий их личному пониманию того, каким же должен быть Идеальный Язык Программирования. Так или иначе, и те и другие пытаются найти компромисс между теми знаниями о языках которые были у них на момент начала работы и того что они ожидали получить в итоге. <br />
<br />
Некоторые программисты пытаются сделать своего рода конгломерат мыслей и идей, объединив в одном языке лучшие черты нескольких других; другие же пытаются создать что-то принципиально новое, не похожее ни на один из существующих языков программирования. Иногда это удается, тогда язык может стать новым словом в программировании и в понимании самого процесса написания программы. Таким примером может послужить идея "графического" или "визуального" программирования. В этом случае программист не пишет программу в обычном понимании этого слова, а "рисует" ее, так же как художник пишет картину. Подобно тому, как художник берет краски с палитры и переносит их на холст, программист, пишущий на визуальном языке, работает с палитрой компонентов, перенося их на рабочее поле, соединяя их связями и тем самым получая готовый Образ программы. Такой подход дает существенный выигрыш в том плане, что мозг программиста работает в естественной для него среде — среде образов, объектов и взаимосвязей, что, в конечном счете, положительно сказывается на эффективности работы программиста и на сокращении трудозатрат, необходимых на получение качественной программы. Конечно, многие могут оспорить это заявление и привести тысячу доводов в защиту "классического" подхода, при котором программист оперирует только текстовым редактором и, конечно, собственным воображением. Каждая задача, каждая проблема может быть решена несколькими путями, с использованием различных инструментов. Какие из них более эффективные или удобные, решать все же самому программисту. <br />
<br />
Однако такие нововведения случаются сравнительно редко. Гораздо чаще происходит своеобразное "изобретение велосипеда", при котором новоиспеченный язык программирования не претендует на место таких "монстров" как С++ или Perl. Взамен, он решает некоторые конкретные проблемы, предлагает свои решения по обеспечению удобства написания кода и его последующей отладки.<br />
<br />
В этом смысле, язык К++ не является исключением. При написании его мы не старались сделать что-то принципиально новое, а скорее хотели переосмыслить наше понимание языков программирования. Мы хотели сохранить лучшие черты, которые мы нашли в других языках и в то же время постараться органично совместить их в нашем языке. Совместить так, чтобы они не противоречили друг другу и представляли собой цельную и законченную систему. Часто это было довольно сложно, поскольку исходные языки представляли собой принципиально различные системы, "исповедующие" разные идеологии. <br />
<br />
Язык К++ вобрал в себя строгость Паскаля, лаконичность С++, удобство Ruby, гибкость Perl и в чем-то даже "совершенство в простоте", присущее языку Smalltalk. На самом деле, этот список можно продолжить и дальше, однако наибольшее влияние оказали именно вышеперечисленные языки. Если вы знаете один или несколько из этих языков, то по ходу изложения материала вы, скорее всего, будете подмечать знакомые места. Разумеется, чем больше вы знакомы с программированием на этих языках, тем легче вам будет освоить язык К++. <br />
<br />
Надеюсь, уважаемый Читатель еще не был утомлен потоком моего красноречия. Если это все-таки случилось, то вы можете вздохнуть спокойно, потому что самая философская часть книги закончилась. В будущем "воды" будет меньше, однако мы все же постараемся сохранить доверительный стиль изложения и не свалиться в пучину бездны так называемого сухого научного стиля...<br />
<br />
== Роль K++ в проекте Диптаун ==<br />
<br />
На этот язык была возложена большая ответственность. Фактически, он является вторым языком после С++, который будет использоваться в повседневной работе разработчика платформы Диптауна. К++ будет применяться практически во всех сферах, начиная от пользовательского интерфейса и заканчивая объектами виртуального пространства (программирование ботов и аватаров, ai и др.). Отдельно стоит подчеркнуть задачу динамической генерации моделей и текстур, что, в конечном счете, позволит использовать Диптаун даже пользователям, обладающим медленным сетевым соединением (вплоть до модемного). Можно даже сказать, что этот язык является основным языком программирования под платформу Диптауна, поскольку С++ подразумевает решение задач по расширению и интеграции самой платформы в отличие от К++, который используется непосредственно для ее программирования.<br />
<br />
== Почему именно K++? ==<br />
<br />
Как это часто бывает, как идея, так и название языка пришли случайно. Первоначально так назывался экспериментальный язык одного из авторов, названный по первой букве сетевого псевдонима (или по первой букве фамилии). Плюсы указывали на некоторое сходство с С++ (с точки зрения синтаксиса и объектной природы). Затем, после разработки виртуальной машины gide, потребовался язык высокого уровня, который мог бы компилироваться в gide код. Необходимо было либо адаптировать уже существующий язык к нашим нуждам, либо написать свой. По некоторым причинам решили писать свой язык (в основном из соображений единства и целостности кода). Так вспомнили о старой разработке, которая и легла в основу данного языка. Название (раньше просто рабочее обозначение) постепенно закрепилось и заняло свое место окончательно.<br />
<br />
'''Примечание:''' Более подробно история создания языка описана [[История создания языка|здесь]].<br />
<br />
== Для кого эта книга ==<br />
<br />
Эта книга написана в первую очередь для тех, кто желает использовать язык К++. Книга предназначена в первую очередь для обучения собственно языку (синтаксису, принципам программирования и т.д.). Однако в ней так же будут затронуты вопросы решения конкретных практических задач, как например программирование аватаров или написание модулей для графического интерфейса системы. После прочтения этой книги вы сможете писать программы любой сложности, начиная от простейших скриптов и заканчивая сложными программами, использующими все возможности платформы Диптаун. Мы постараемся затронуть как можно больше вопросов связанных с использованием платформы. Будут рассмотрены типовые задачи и приемы их решения. <br />
<br />
Книга ориентирована на подготовленного читателя; предполагается, что читатель уже знаком с программированием вообще и с объектно-ориентированным программированием в частности, обладает навыками написания программ и некоторыми специальными знаниями.<br />
<br />
== Стиль изложения материала ==<br />
<br />
Если вы дочитали до этого места, то уже должны примерно себе представлять, в каком стиле написана книга. Тем не мене, стоит отметить, что авторы всячески будут стараться писать более живым языком, кое-где отходя от основной мысли и разбавляя сухой текст рассуждениями, историческими сведениями и др.<br />
<br />
Авторами учитывался тот факт, что книга писалась в первую очередь как онлайн-руководство; ее структура была изначально рассчитана на использование перекрестных ссылок. Везде, где это возможно, будут проставляться ссылки на другие разделы книги, а так же на дополнительные материалы, касающиеся темы изложения. Сам материал излагается в несколько этапов. Сначала дается краткий обзор темы, затем более детальное рассмотрение вопросов по отдельности. Было решено, что такой подход является более эффективным, нежели обычное, линейное изложение материала. Таким образом, книгу можно использовать и как учебник, и как справочное руководство, а читать ее можно практически с любого интересующего места.<br />
<br />
== Тесная взаимосвязь с gide ==<br />
<br />
Как уже отмечалось выше, язык К++ является высокоуровневым языком, компилирующимся в байт код [[gide]]. Хорошее понимание процессов, происходящих при компиляции, и умение читать листинги gide ассемблера позволят вам писать более эффективные программы, а так же задействовать все возможности виртуальной машины. <br />
<br />
Поэтому, по ходу изложения материала, в некоторых местах будут приводиться листинги как программ, написанных на К++, так и соответствующий им gide код. Это поможет более полно представлять себе, что же происходит на самом деле. Если же вы считаете, что вы еще не достаточно квалифицированны для работы с ассемблером, то смело можете пропускать эти части. Однако настоятельно рекомендуется впоследствии изучить и эти материалы.<br />
<br />
== Принятые обозначения ==<br />
<br />
Рассмотрим кратко типографские обозначения, принятые в книге. При ее написании, авторы старались придерживаться единого стиля, что должно было обеспечить лучшую читаемость материала и более легкое его восприятие.<br />
<br />
Важные места, на которые следует обратить внимание, выделяются '''жирным''' шрифтом, например, так выделяются примечания. Различные термины и определения выделяются ''курсивом'', таким же образом выделяются переменные в ходе описания их использования в тексте (а не в самой программе). Ключевые слова, являющиеся важной частью любого языка и несущие строго определенный смысл, выделяются <tt>'''жирным моноширинным'''</tt> стилем. <br />
<br />
Имена полей функций и методов, названия классов и стандартных типов данных выделяются <tt>моноширинным</tt> стилем. Если описываемый класс имеет свою страницу в данной книге или в другом месте, на него будет сделана ссылка. Имена методов записываются вместе с круглыми скобками позади них, чтобы их можно было визуально отличить от свойств.<br />
<br />
Кроме того, листинги программ записываются отдельно, причем текст программы подсвечивается так, как это принято в редакторе. Подсветка синтаксиса облегчает восприятие программы и позволяет легче выделять отдельные ее структурные элементы. Относительно длинные листинги программ будут дополняться столбцом номеров строк, для облегчения описания действия отдельных частей программы.<br />
<br />
Ниже приведен небольшой пример применения вышеописанных стилей (на самом деле, это вырезка из главы [[Константы]]).<br />
<br />
<br />
----<br />
<br />
<br />
...с точки зрения языка, ''константы'' это те же [[переменные]], за исключением того, что однажды установленное их значение нельзя изменять. В остальном они ведут себя так же как обычные [[объекты]]: их можно использовать в арифметических выражениях, передавать в качестве [[Функции#Аргументы|параметров]] [[Функции|функциям]], использовать их [[K++ как объектно-ориентированный язык#Свойства|свойства]] и вызывать [[K++ как объектно-ориентированный язык#Методы|методы]]. Разумеется, только те, которые не изменяют состояние самого объекта.<br />
<br />
Объявление любой константы начинается с ключевого слова <tt>'''const'''</tt>, за которым идут тип (можно не указывать), [[идентификатор]] имени константы и выражение-инициализатор. <br />
<br />
Вот примеры объявления констант:<br />
<source lang="kpp"> <br />
const real e = 2.7182818;<br />
const pi = 3.1415926;<br />
const s = "hello world";<br />
</source><br />
<br />
Тип константы можно либо указать явно, как это происходит в случае константы ''e'', либо неявно. При этом он будет назначен как тип инициализатора: константа ''pi'' будет иметь тип числа с плавающей точкой (<tt>[[Стандартные типы данных#Числа с плавающей точкой|real]]</tt>), а константа ''s'' — строковый тип (<tt>[[Стандартные типы данных#Строки|string]]</tt>).<br />
<br />
'''Примечание:''' При объявлении констант следите за тем, чтобы их тип был ясно виден из строки объявления. Если выражение инициализатора представляет собой довольно сложное математическое выражение, либо содержит вызовы функций, лучше всего указать тип константы явно (как в примере с константой ''e''). Иначе, это может вызывать проблемы в будущем, при работе программы или при ее отладке. В целом ситуация такая же, что и с инициализацией переменных ([[Переменные#Типизация при инициализации|см. примечание]]).</div>KroTozeR