Deeptown Manual - Вклад участника [ru]

История создания языка

2012-08-23T13:23:28Z

Korvin: Правки DanielBell91 (обсуждение) откачены к версии KroTozeR

Когда мы разрабатывали платформу Диптауна, мы постоянно держали в уме следующие критерии:

* Кроссплатформенность
* Расширяемость
* Распределенность
* Масштабируемость
* Гибкость
* Модульность

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

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

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

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

В рамках проекта Диптаун была написана своя собственная виртуальная машина [[gide]]. Она написана целиком на нашей платформе и учитывает ее особенности. Для программирования виртуальной машины используется свой язык, похожий на ассемблер, но его применение в практических задачах сильно затруднено (сложность написания программ, а главное их отладки). Было принято решение написать язык высокого уровня, который бы компилировался в gide ассемблер. В результате этого и появился язык К++.

Предисловие

2012-08-23T13:21:34Z

Korvin: Правки DanielBell91 (обсуждение) откачены к версии Korvin

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

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

Однако такие нововведения случаются сравнительно редко. Гораздо чаще происходит своеобразное "изобретение велосипеда", при котором новоиспеченный язык программирования не претендует на место таких "монстров" как С++ или Perl. Взамен, он решает некоторые конкретные проблемы, предлагает свои решения по обеспечению удобства написания кода и его последующей отладки.

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

Язык К++ вобрал в себя строгость Паскаля, лаконичность С++, удобство Ruby, гибкость Perl и в чем-то даже "совершенство в простоте", присущее языку Smalltalk. На самом деле, этот список можно продолжить и дальше, однако наибольшее влияние оказали именно вышеперечисленные языки. Если вы знаете один или несколько из этих языков, то по ходу изложения материала вы, скорее всего, будете подмечать знакомые места. Разумеется, чем больше вы знакомы с программированием на этих языках, тем легче вам будет освоить язык К++.

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

== Роль K++ в проекте Диптаун ==

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

== Почему именно K++? ==

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

'''Примечание:''' Более подробно история создания языка описана [[История создания языка|здесь]].

== Для кого эта книга ==

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

Книга ориентирована на подготовленного читателя; предполагается, что читатель уже знаком с программированием вообще и с объектно-ориентированным программированием в частности, обладает навыками написания программ и некоторыми специальными знаниями.

== Стиль изложения материала ==

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

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

== Тесная взаимосвязь с gide ==

Как уже отмечалось выше, язык К++ является высокоуровневым языком, компилирующимся в байт код [[gide]]. Хорошее понимание процессов, происходящих при компиляции, и умение читать листинги gide ассемблера позволят вам писать более эффективные программы, а так же задействовать все возможности виртуальной машины.

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

== Принятые обозначения ==

Рассмотрим кратко типографские обозначения, принятые в книге. При ее написании, авторы старались придерживаться единого стиля, что должно было обеспечить лучшую читаемость материала и более легкое его восприятие.

Важные места, на которые следует обратить внимание, выделяются '''жирным''' шрифтом, например, так выделяются примечания. Различные термины и определения выделяются ''курсивом'', таким же образом выделяются переменные в ходе описания их использования в тексте (а не в самой программе). Ключевые слова, являющиеся важной частью любого языка и несущие строго определенный смысл, выделяются <tt>'''жирным моноширинным'''</tt> стилем.

Имена полей функций и методов, названия классов и стандартных типов данных выделяются <tt>моноширинным</tt> стилем. Если описываемый класс имеет свою страницу в данной книге или в другом месте, на него будет сделана ссылка. Имена методов записываются вместе с круглыми скобками позади них, чтобы их можно было визуально отличить от свойств.

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

Ниже приведен небольшой пример применения вышеописанных стилей (на самом деле, это вырезка из главы [[Константы]]).

----

...с точки зрения языка, ''константы'' это те же [[переменные]], за исключением того, что однажды установленное их значение нельзя изменять. В остальном они ведут себя так же как обычные [[объекты]]: их можно использовать в арифметических выражениях, передавать в качестве [[Функции#Аргументы|параметров]] [[Функции|функциям]], использовать их [[K++ как объектно-ориентированный язык#Свойства|свойства]] и вызывать [[K++ как объектно-ориентированный язык#Методы|методы]]. Разумеется, только те, которые не изменяют состояние самого объекта.

Объявление любой константы начинается с ключевого слова <tt>'''const'''</tt>, за которым идут тип (можно не указывать), [[идентификатор]] имени константы и выражение-инициализатор.

Вот примеры объявления констант:
<source lang="kpp">
const real e = 2.7182818;
const pi = 3.1415926;
const s = "hello world";
</source>

Тип константы можно либо указать явно, как это происходит в случае константы ''e'', либо неявно. При этом он будет назначен как тип инициализатора: константа ''pi'' будет иметь тип числа с плавающей точкой (<tt>[[Стандартные типы данных#Числа с плавающей точкой|real]]</tt>), а константа ''s'' — строковый тип (<tt>[[Стандартные типы данных#Строки|string]]</tt>).

'''Примечание:''' При объявлении констант следите за тем, чтобы их тип был ясно виден из строки объявления. Если выражение инициализатора представляет собой довольно сложное математическое выражение, либо содержит вызовы функций, лучше всего указать тип константы явно (как в примере с константой ''e''). Иначе, это может вызывать проблемы в будущем, при работе программы или при ее отладке. В целом ситуация такая же, что и с инициализацией переменных ([[Переменные#Типизация при инициализации|см. примечание]]).

Заглавная страница

2009-11-07T15:22:10Z

Korvin: /* Документация */

== Информация ==

* [[О проекте]]
* [[Deeptown SDK]]
* [[Deptown Programming Contest (DPC)]]
* [[Задачи|Текущие задачи]]
* [[Bugzilla]]
* [[Рассылка]]
* [[Release Notes]]
* [[Обратная связь]]

== Документация ==

* [[K++|Язык программирования K++]]
* [[World Engine]]
* [[Платформа Gide]]
* [[Стандартная библиотека gide]]
* [[Туториалы и HOWTO]]
* [[Building and running from source]]
* [[Советы и подсказки]]
* [[Coreutils library]]

Рабочие заметки

2009-10-31T17:09:06Z

Korvin: /* TODO */

== TODO ==

* Описать концепцию <tt>Proc</tt>:
** Отличия от <tt>[[Closure]]</tt>
** Дать ссылки в книге
* Частичная поддержка перегрузки функций
* <s>Ключевое слово <tt>'''ensure'''</tt></s>
* Описать конструкцию (a, b, c) = [x, y, z]
* <s>Переделать все имена исключений в основную форму ESmthError</s>
* Описать механизм примесей и его идеологию
** Зачем нужны
** Чем отличаются от обычного наследования/расширения
** <tt>Comparable</tt>, <tt>Enumerable</tt>, <tt>Operable</tt>
* Добавить строки <tt>:string</tt> и #x в схему подсветки и ключевые слова <tt>'''ensure, to'''</tt>
* Описать необходимость приведения типов (где надо) при работе с динамическими переменными
* Поля в расширениях теперь можно делать (?)
* Пространства имен
* [[Классы и объекты#Расширения]], описать возможность вызова предыдущей копии метода (когда появится возможность)
* <tt>'''break'''</tt> в блоках
* перечисления?
* <tt>MyClass.MY_CONST</tt>
* <s>абстрактные методы</s>
* [[Стандартные типы данных#Потоки]]

== Замечания по самому тексту ==

* Коммент в разделе [[Введение, или краткий обзор#Здравствуй, мир!]]
* [[Классы и объекты#Смотри также]]
* [[Объявление переменных и констант#Смотри также]]
* [[Стандартные типы данных#Указатели]]

* Предупреждение в разделе [[Функции#Перегрузка функций и операторов]]

== TODO компилятора ==

* Возможность объявлять класс до его реализации, аналогично forward declarations функций

== Перевод контента на английский язык ==
<source lang="kpp" line="0">
<random> книжку про К++ переводить?
<Raw_mat> переводи
<dk> ну там по идее поменяется много чего
<dk> потому что она уже малость устарела по сравнению с текущей версией языка
<dk> я бы лучше сказал что надо переводить все что осталось непереведенное из блогов/статей
<dk> уже книжкой стал? | эмм в смысле?
<random> надо план перевода чтобы кто-то координировал (Рав?) именно чтобы переводить то что надо в первую очередь и чтоб оно не менялось
<dk> вообще по хорошему надо не только переводить. А огранизовать процесс по английской версии сайта
<dk> то есть м/б написать какой то материал, который был бы необходим именно там, с учетом на западную аудиторию
<Raw_mat> ранд, переведи интерфейс сайта на европейские языки
<Raw_mat> а еще лучше на китайский или япошский
<random> еще надо определиться как в вики переводные статьи оформлять (шаблон названия и связь с тегом "язык")
<random> могу токо на англиский пока
<Raw_mat> разные поддомены вики языковые
<Raw_mat> какна википедии
<random> я к тому что в ман вики вроде нету яз разделов надо создать тогда можно будет каждому выбирать и переводить, но так чтобы не было разнобоя
<random> и потом корв правильно сказал надо чтоб кто-то организовывал в целом английский имидж сайта с учетом особенностей аудитории
</source>

= Main page =
== Informatoion ==

* [[About this project]]
* [[Deeptown SDK]]
* [[Tasks|Current tasks]]
* [[Bugzilla]]
* [[Our Spam]]
* [[Release Notes]]
* [[Feedback]]

== Docs ==

* [[K++]]
* [[World Engine]]
* [[Gide Platform]]
* [[gide standard lib]]
* [[Tutorials & HOWTO's]]
* [[Building and running from source]]
* [[Tips & Tricks]]

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

2009-10-31T17:06:59Z

Korvin: /* Абстрактные методы */

__TOC__

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
class MyWeirdClass {
var m_x = 0; // поле m_x, изначально проинициализированное нулем
const m_y = 1; // поле-константа m_y

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

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

;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
// коробка
class Box {
// из чего сделана коробка?
public const function string material() { return "Картон"; }

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

// коробка с картошкой
class BoxWithPotatoes extends Box {
public const function string contents() { return "Картошка"; }
}

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

export function main() {
var b1 = new Box;
var b2 = new BoxWithPotatoes;
OutputBox(b1); // Материал: Картон, содержит: Пусто
OutputBox(b2); // Материал: Картон, содержит: Картошка
}
</source>

;2-8: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.

;11-13: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.

;15-17: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).

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

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

== Методы ==

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

При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)
* <tt>'''const'''</tt> — метод не изменяет объект
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять

После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].

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

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

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

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

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

Пример:
<source lang="kpp">
class MyClass {
public static function string Info() { return "Я MyClass!"; }
}

function f() {
// Вызов статического метода:
var myClassInfo = MyClass.Info();
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp">
class Enumerable {
public:
abstract const function each(block b);
abstract const function int compare(const x);

const function bool all(block b = identity_block) {
var result = true;
this.each() { |...|
if (!b.invoke(args())) {
result = false;
break;
}
};
return result;
}

// (Другие методы примеси)
}
</source>

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

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

Таким образом, мы можем использовать примесь в любом классе, который может и не являться коллекцией. В качестве примера можно привести такой код:
<source lang="kpp">
class MyClass extends Enumerable {
public const function each(block b) {
b("hello");
b("to");
b("mixin!!!");
}
}

export function main() {
var c = new MyClass;
var i = 1;
c.collect() { |x| i++ to string + ' ' + x; }.each() { |x| puts(x); }
}
</source>

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

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

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

== Поля ==

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

Объявление поля начинается с одного из трех ключевых слов:
* <tt>'''var'''</tt> — объявление "обычного" поля;
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.

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

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

Тип поля определяется по следующим правилам:
* если тип указан явно, ничего определять не надо;
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

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

== Свойства ==

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

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

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

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

<source lang="cpp">
class MyDevice {
int GetState();
};
</source>

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

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

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

<source lang="kpp">
class MyDevice {
function int GetState();
property int state read GetState;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

----

В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства.

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

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

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

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

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

<source lang="kpp">
class MyClass {
var f = 1;
property int read { f + 1; } write { |v| f = v; };
}
</source>

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

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

== Расширения ==

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

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

В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:

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

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

export function main() {
puts("Factorial of 10 is " + 10.factorial);
}
</source>

;3-11: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.

;14: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. 

: Обратите внимание, что функция <tt>puts()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. В этом нет ничего странного, потому что класс <tt>int</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt>, передается в качестве параметра функции.

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



== Смотри также ==

Рабочие заметки

2009-10-30T19:39:49Z

Korvin: /* TODO */

== TODO ==

* Описать концепцию <tt>Proc</tt>:
** Отличия от <tt>[[Closure]]</tt>
** Дать ссылки в книге
* Частичная поддержка перегрузки функций
* <s>Ключевое слово <tt>'''ensure'''</tt></s>
* Описать конструкцию (a, b, c) = [x, y, z]
* <s>Переделать все имена исключений в основную форму ESmthError</s>
* Описать механизм примесей и его идеологию
** Зачем нужны
** Чем отличаются от обычного наследования/расширения
** <tt>Comparable</tt>, <tt>Enumerable</tt>, <tt>Operable</tt>
* Добавить строки <tt>:string</tt> и #x в схему подсветки и ключевое слово <tt>'''ensure'''</tt>
* Описать необходимость приведения типов (где надо) при работе с динамическими переменными
* Поля в расширениях теперь можно делать (?)
* Пространства имен
* [[Классы и объекты#Расширения]], описать возможность вызова предыдущей копии метода (когда появится возможность)
* <tt>'''break'''</tt> в блоках
* перечисления?
* <tt>MyClass.MY_CONST</tt>
* <s>абстрактные методы</s>
* [[Стандартные типы данных#Потоки]]

== Замечания по самому тексту ==

* Коммент в разделе [[Введение, или краткий обзор#Здравствуй, мир!]]
* [[Классы и объекты#Смотри также]]
* [[Объявление переменных и констант#Смотри также]]
* [[Стандартные типы данных#Указатели]]

* Предупреждение в разделе [[Функции#Перегрузка функций и операторов]]

== TODO компилятора ==

* Возможность объявлять класс до его реализации, аналогично forward declarations функций

== Перевод контента на английский язык ==
<source lang="kpp" line="0">
<random> книжку про К++ переводить?
<Raw_mat> переводи
<dk> ну там по идее поменяется много чего
<dk> потому что она уже малость устарела по сравнению с текущей версией языка
<dk> я бы лучше сказал что надо переводить все что осталось непереведенное из блогов/статей
<dk> уже книжкой стал? | эмм в смысле?
<random> надо план перевода чтобы кто-то координировал (Рав?) именно чтобы переводить то что надо в первую очередь и чтоб оно не менялось
<dk> вообще по хорошему надо не только переводить. А огранизовать процесс по английской версии сайта
<dk> то есть м/б написать какой то материал, который был бы необходим именно там, с учетом на западную аудиторию
<Raw_mat> ранд, переведи интерфейс сайта на европейские языки
<Raw_mat> а еще лучше на китайский или япошский
<random> еще надо определиться как в вики переводные статьи оформлять (шаблон названия и связь с тегом "язык")
<random> могу токо на англиский пока
<Raw_mat> разные поддомены вики языковые
<Raw_mat> какна википедии
<random> я к тому что в ман вики вроде нету яз разделов надо создать тогда можно будет каждому выбирать и переводить, но так чтобы не было разнобоя
<random> и потом корв правильно сказал надо чтоб кто-то организовывал в целом английский имидж сайта с учетом особенностей аудитории
</source>

= Main page =
== Informatoion ==

* [[About this project]]
* [[Deeptown SDK]]
* [[Tasks|Current tasks]]
* [[Bugzilla]]
* [[Our Spam]]
* [[Release Notes]]
* [[Feedback]]

== Docs ==

* [[K++]]
* [[World Engine]]
* [[Gide Platform]]
* [[gide standard lib]]
* [[Tutorials & HOWTO's]]
* [[Building and running from source]]
* [[Tips & Tricks]]

Основные синтаксические конструкции

2009-10-30T12:05:00Z

Korvin: /* Цикл foreach */

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

__TOC__

== Условный оператор ==

Условный оператор — это основа основ любого языка программирования. На основании условия, то есть значения некоторого выражения, принимается решение, куда следует двигаться программе. В основе всех условных операторов лежит булева логика, при которой любое утверждение сводится к двум понятиям: истина и ложь. Если условие истинно, то управление программы движется в одну сторону. Если условие ложно — в другую. Таким образом, в каждый момент времени делается выбор всего из двух направлений. Более сложные условия строятся путем последовательного прохождения элементарных, двоичных условий.

=== Оператор if ===

В языке K++, для проверки условия служит оператор <tt>'''if'''</tt>, так же называемый условным оператором. Синтаксис этого оператора знаком наверное любому человеку, который имеет хоть какое-то представление о языках программирования:
<source lang="kpp">
if (/* выражение условия */) {
/* тело оператора */
}
</source>

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

Истинным, считается любой существующий объект, а так же логические [[Типы операторов#Операторы сравнения|операторы сравнения и отношения]] (такие как <tt>==</tt>, <tt>!=</tt>, <tt><</tt> и т. д), если их значение истинно (то есть, объекты соответствуют указанному отношению), а так же специальное ключевое слово <tt>'''true'''</tt>, которое считается истинным всегда. Исключением является объект типа bool, имеющий в данный момент значение <tt>'''false'''</tt>.

Ложными, соответственно, считаются несозданные объекты (пустые указатели), а так же операторы отношения, если их значение ложно (объекты не соответствуют отношению). Ложными так же считаются объекты, соответствующие ключевым словам <tt>'''false'''</tt> и <tt>'''null'''</tt>. Опять же, исключением является объект типа bool, если он имеет значение <tt>'''true'''</tt>.

Для ясности приведем несколько выражений, а так же укажем соответствующие им логические значения:
<source lang="kpp">
//Выражение булево значение
true true
false false
null false
var x; x false
var y; y = 1; true
var int z; z true
var bool x; false
var bool x; x = true; true
0 true
1 true
"hello world" true
0 == 1 false
5 < 6 true
2 > 3 false
5 >= 5 true
'a' != 'b' true
</source>

Обратите внимание на следующие моменты:
* Неинициализированная динамическая переменная ''x'' считается ложной (равна <tt>'''null'''</tt>)
* Инициализированная динамическая переменная ''y'' считается истинной (объект создан)
* Неинициализированная статическая переменная ''z'' считается истинной (объект создан)
* Переменная типа <tt>bool</tt> имеет значение по умолчанию <tt>'''false'''</tt> (хотя объект создан)
* 0, так же как любой другой созданный объект считается '''истиной''', в отличие от C++.
* условие 5 >= 5 считается истиной, так как формулируется как "5 больше 5 '''или''' равно 5"

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

В языке К++ все наоборот. Все с чем он оперирует — это объекты. Провести грань между стандартными типами данных и пользовательскими невозможно. Числа, что фигурируют в программе так же являются объектами. Даже числовые константы которые записываются в выражениях — это тоже объекты (это уже было показано в [[Введение, или краткий обзор#Расширение классов|кратком обзоре]]). За основу логики языка принимается факт существования объекта. Если объекта не существует — значение ложно, если существует — истинно (кроме описанных выше исключений). Оператор <tt>'''if'''</tt> помимо чистой логики, служит для определения существования объекта. Получается, что при таком подходе, делать для нуля исключение нерационально, и более того — это может привести к ошибкам. Возьмем к примеру код:

<source lang="kpp">
if (x) {
/* код, соответствущий существованию переменной x */
}
</source>

Подразумевается, что тело оператора будет выполнено в случае, если передаваемый объект (вероятнее всего [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]) инициализирован и существует. Но что будет, если мы передадим в качестве объекта динамическую переменную, содержащую объект типа <tt>int</tt>, равный нулю? Если бы реализация языка обрабатывала значение 0 как ложь, то логика оператора <tt>'''if'''</tt> в частости и всей программы в целом, зависела бы от фактического значения переменной, а соответственно была бы неопределенной и даже непредсказуемой. Получалось бы, что для одних переменных, оператор работает одним образом, а для других — другим. Отладка подобной программы может занять многие часы. А все из-за одной условности.

Таким образом, можно заключить, что оператор <tt>'''if'''</tt> следует применять для проверки логического выражения, либо для проверки существования переменной. Если мы хотим проверить равенство переменной нулю, то это необходимо делать явно:
<source lang="kpp">
if (x == 0) {
/* что нужно делать, если x равен 0 */
}
</source>

=== Оператор if-else ===

Если нам необходимо организовать ''ветвление'', то есть в случае истинности, выполнить один участок кода, а в случае ложности другой, то применяется расширенная форма оператора <tt>'''if-else'''</tt>:
<source lang="kpp">
if (/* выражение условия */) {
/* код, соответствущий истине */
} else {
/* код, соответствущий лжи */
}
</source>

Если условие истинно, то будет выполнен первый блок, если ложно то второй.

Условные операторы, подобно многим другим, позволяют организовывать вложения, когда в тело одного условного оператора вкладывается один или несколько других условных операторов, например:
<source lang="kpp">
if (/* условие 1 */) {
/* если условие 1 истинно: */
if (/* условие 2 */) {
/* если условие 2 истинно */
}
if (/* условие 3 */) {
/* если условие 3 истинно */
}
} else {
/* если условие 1 ложно: */
if (/* условие 4 */) {
/* если условие 4 истинно */
} else {
/* код, соответствущий лжи условия 4 */
}
}
</source>
Таким образом можно строить разветвленные деревья условий, которые и реализуют алгоритмы программ.

=== Оператор if-elsif-else ===

Существует так же третья форма условного оператора, которая позволяет проверять несколько условий в единой, более эффективной форме. Это конструкция <tt>'''if-elsif-else'''</tt>:
<source lang="kpp">
if (/* условие 1 */) {
/* код, соответствущий истине условия 1*/
} elsif (/*условие 2*/) {
/* код, соответствущий истине условия 2*/
...
} else {
/* код, соответствущий лжи */
}
</source>
Она работает так: сначала проверяется условие 1. Если оно истинно, то выполняется код в первом блоке, а затем управление выходит за рамки всей связки. Если условие 1 ложно, то проверяется условие 2, и т. д. Таким образом, вышеописанная конструкция функционально эквивалентна следующей конструкции, однако более компактна.

<source lang="kpp">
if (/* условие 1 */) {
/* если условие 1 истинно */
} else {
if (/* условие 2 */) {
/* если условие 2 истинно */
} else {
if (/* условие 3 */) {
/* если условие 3 истинно */
} else {
...
}
}
}
</source>

=== Постфиксные операторы ===

Существует так же более лаконичная форма оператора <tt>'''if'''</tt>, удобная для записи коротких, однострочных условий. При этом, само условие записывается после выражения, которое оно должно проверить:

<source lang="kpp">
/* выражение */ if /* условие */;
</source>

При такой записи, окружать условие скобками не требуется. Проверяемое выражение должно быть единственным, то есть не содержать оператора точка с запятой (<tt>;</tt>). Такие условия занимают меньше места в программе и помогут сделать ваш код более чистым:

<source lang="kpp">
var even_sum = 0;
for (var i = 1; i < 100; i++)
even_sum += i if i % 2 == 0; //сумма всех четных чисел
</source>

Для проверки "невыполнения" условия есть специальная форма постфиксного оператора — <tt>'''unless'''</tt>. Выражение при таком операторе будет выполняться только если условие ложно. Таким образом, смысл оператора прямо противоположен оператору <tt>'''if'''</tt>. Конечно, эти два оператора взаимозаменяемы. Конструкция <tt>do_smth '''if''' x;</tt> делает то же самое что <tt>do_smth '''unless''' !x;</tt>.

Перепишем предыдущий код с использованием оператора <tt>'''unless'''</tt>:

<source lang="kpp">
var even_sum = 0;
for (var i = 1; i < 100; i++)
even_sum += i unless i % 2 != 0; //сумма всех четных чисел
</source>

=== Тернарный условный оператор ===

В некоторых случаях, может возникнуть ситуация, при которой необходимо присвоить значение некоторой переменной на основании условия. То есть, при истинности условия присвоить одно значение, а при ложности — другое. Это можно осуществить двумя способами. Первый способ — использовать обычный условный оператор:
<source lang="kpp">
var x = 5;
var y = 0;
if (x > 3)
y = 3;
else
y = -1;
</source>

Не будем уточнять, зачем кому-то мог понадобиться подобный "гениальный" код, а отметим лишь то, что операция присвоения занимает 4 строки при соблюдении правил форматирования кода. В тех случаях, когда тела условного оператора представляют собой простые выражения "в одну строчку", особенно если, как уже было сказано выше, происходит присвоение, разумно применять специальную форму условного оператора — тернарный оператор <tt>?:</tt>. Тогда, тот же код будет выглядеть так:
<source lang="kpp">
var x = 5;
var y = 0;
y = x > 5 ? 3 : -1;
</source>

Это единственный в языке К++ тернарный оператор, работающий с тремя выражениями сразу. Первое выражение — это условие; оно располагается слева, до знака вопроса. Между знаком вопроса и знаком двоеточия расположено выражение, которое должно подставляться, в случае истинности условия. Последним располагается выражениие, подставляющееся в случае ложности.

Данная форма оператора очень удобна для записи непосредственно внутри выражений, фактических параметров в вызовах функций, либо любых других выражениях. Его даже можно применять в операторе подстановки <tt>#{ }</tt> в строках. Можно его применять и без возврата значения, например так:
<source lang="kpp">
while (true) {
CheckState() != State.OK ? Signal() : Sleep();
}
</source>

'''Примечание:''' Работать такой код будет если и <tt>Signal()</tt> и <tt>Sleep()</tt> возвращают значения.

== Оператор множественного выбора (switch) ==

В тех случаях, когда требуется сравнить значение некоторого выражения с большим количеством возможных значений, применять обычные условные операторы неразумно. Код получится громоздким и трудно читаемым, а самое главное — изменять такой код будет очень сложно. В таких случаях, на помощь программисту приходит оператор множественного выбора, или оператор <tt>'''switch'''</tt>.

Предположим, что перед нами стоит такая задача: функция получает некоторый числовой код ошибки и на основании него должна выполнять различные действия. В частности, выводить соответствующие сообщения. Если от нас требуется только вернуть соответствующую коду ошибки строку, проще всего и эффективнее, разумеется, применять [[Стандартные типы данных#Хеши|хеши]], но мы будем считать что требуется сделать что-то еще.

Конструкция множественного выбора реализуется следующим образом: указывается ключевое слово <tt>'''switch'''</tt>, после которого, в круглых скобках указывается выражение-''селектор'', которое мы будем анализировать. Затем, ставятся фигурные скобки switch-блока, в теле которого могут быть только конструкции, относящиеся непосредственно к оператору. В нашем случае это будет примерно так:
<source lang="kpp">
function ProcessError(const int errno) {
switch (errno) {
/* switch блок */
}
}
</source>

Далее, мы должны определить относящиеся к делу случаи, а именно, перечислить конкретные значения, с которыми мы будем сравнивать код ошибки и на основании этого сравнения будем выполнять некоторые операции. Это осуществляется с помощью подоператора <tt>'''case'''</tt>, который записывается так:
<source lang="kpp">
case /* выражение сравнения */: /* обработчик */
</source>

Выражение сравнения — это любое выражение, которое будет сравниваться с селектором. В качестве такого выражения может быть выбрано не одно, а сразу несколько условий. Тогда они должны отделяться друг от друга запятой:
<source lang="kpp">
case /*условие1*/, /*условие2*/, ... /*условие N*/: /* обработчик */
</source>

В качестве условия может так же быть указан [[Стандартные типы данных#Интервалы|интервал]]. Тогда будет проверяться, попадает ли значение выражения селектора в заданный интервал. Например, если нам необходимо анализировать численное выражение, то один из операторов <tt>'''case'''</tt> может выглядеть так:
<source lang="kpp">
case 1, 2, 5 .. 10, 12: /* обработчик */
</source>

Для срабатывания обработчика достаточно, чтобы сработало хотябы одно из условий, перечисленных в списке; тогда управление будет передано коду обработчика. Обработчиком может быть либо отдельное выражение, либо блок. Во втором случае, его необходимо заключить в фигурные скобки. В отличие от C++, после обработчика управление передается за пределы оператора <tt>'''switch'''</tt>, а не на следующее сравнение. То есть, логика работы более близка к паскалевской конструкции <tt>'''case'''</tt>.

Для безусловного выхода из любого места обработчика, может применяться ключевое слово <tt>'''break'''</tt>. При этом, управление будет передано коду, следующему за оператором <tt>'''switch'''</tt>.

Если требуется рассмотреть отдельный случай, когда ни одно из условий не было удовлетворено (то есть, ни один из операторов <tt>'''case'''</tt> не сработал), применяется ''действие по умолчанию''. Для этого, необходимо записать ключевое слово <tt>'''default'''</tt>, а затем через двоеточие указать обработчик. Естественно, никакого выражения сравнения тут нет.

'''Примечание:''' при использовании обработчиков по умолчанию, следует иметь в виду что:
* на кажый оператор <tt>'''switch'''</tt> может быть указан только один обработчик по умолчанию
* обработчик по умолчанию должен быть записан в самом конце конструкции

Обобщив вышесказанное, напишем наконец, реализацию задуманной нами функции:
<source lang="kpp" line="1">
function ProcessError(const int errno) {
switch (errno) {
case AGAIN: {
Log("требуется повтор операции");
/* запрашиваем у пользователя подтверждение на повтор */
}
case ACCESS_DENIED:
Log("ошибка доступа");
case REQUEST_TIMEOUT, TIMEOUT:
Log("таймаут");
default:
Log("неизвестный код ошибки: #{errno}");
}
}
</source>

;3-6: Поскольку выражение обработчик сложное, то есть состоит более чем из одной конструкции, мы заключили его в фирурные скобки.

;9: Для случаев REQUEST_TIMEOUT и TIMEOUT был использован один обработчик. Подразумевается, что коды, соответствующие данным ошибкам разные, но программист решил их объединить в одно целое.

== Циклы ==

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

=== Цикл while ===

Простейшим из циклов является цикл <tt>'''while'''</tt>, который выглядит следующим образом:
<source lang="kpp">
while (/*условие*/) {
/* тело цикла */
}
</source>

[[Изображение:While_loop.png|thumb|left|Блок схема цикла while]]

Цикл <tt>'''while'''</tt> является циклом с предпроверкой условия, то есть, сначала проверяется значение выражения в условии цикла, а затем выполняется переход на тело цикла (если условие истинно), либо за пределы цикла (если ложно). Схематически, поведение цикла изображено на блочной диаграмме слева.

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

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

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

 

'''Примечание:''' Существует так же постфиксная форма оператора <tt>'''while'''</tt>, принципы использования которой схожи с таковыми в случае [[#Постфиксные операторы|постфиксных условных операторов]]. Например так можно посчитать сумму чисел от одного до ста практически "в одно действие":

<source lang="kpp">
var i = 0, s = 0;
s += i++ while i < 100;
</source>

=== Цикл for ===

[[Изображение:For_loop.png|thumb|left|Блок схема цикла for]]
Более сложным примером является цикл <tt>'''for'''</tt>. Как правило, он применяется в случаях, когда есть некоторая переменная изменяющая свое значение в определенных пределах и сохраняющая свое значение в течение всей итерации. В конструкции цикла <tt>'''for'''</tt> собраны все необходимые операции, что позволяет оперировать переменной более удобным образом. Опять же, исключается возможность ошибки, при которой программист забыл выполнить одну из операций.

Цикл <tt>'''for'''</tt> работает следующим образом. Сначала выполняется код инициализации переменной цикла (ее еще называют управляющей переменной). Как видно из блочной диаграммы, это происходит только один раз, в самом начале. Затем, проверяется условие. Если условие истинно, управление передается телу цикла. Подразумевается, что в нем будут производиться некоторые действия, учиывающие текущее значение переменной цикла. После выполнения тела цикла, производится приращение управляющей переменной. Далее управление опять передается коду проверки условия; так повторяется до тех пор пока значение выражения условия не станет ложным.

 
В отличие от паскаля, цикл <tt>'''for'''</tt> совершенно не обязательно должен работать с числами. В роли управляющей переменной может выступать любой объект. Синтаксис оператора <tt>'''for'''</tt> выглядит так:
<source lang="kpp">
for (/* инициализатор */; /* условие */ ; /* приращение */) {
/* тело цикла */
}
</source>

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

Если требуется объявление, то следует использовать конструкцию объявления переменной, точно такую же как и в обычной практике. То есть, правила объявления переменных и инициализации те же. Выражение-условие содержит некоторое выражение (обычно оператор отношения), которое должно менять свое значение в зависимости от значения управляющей переменной. Наконец, выражение приращения используется для изменения значения управляющей переменной на некоторую атомарную величину. В случае целочисленного типа управляющей переменной, для этого, как правило, используется оператор <tt>++</tt> (поскольку выражение приращения выполняется отдельно от тела, здесь не имеет значения, какую форму оператора использовать).

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

{| width=65% align=center
| <source lang="kpp">
for (var i = 0; i < 10; i++) {
/* тело */

}
</source>
| <source lang="kpp">
var i = 0;
for (; i < 10; i++) {
/* тело */
}
</source>
|-
| <source lang="kpp">
for (var i = 0; ; i++) {
if (i >= 10)
break;
/* тело */
}
</source>
| <source lang="kpp">
for (var i = 0; i < 10; ) {
/* тело */
i++;

}
</source>
|}

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

Ключевое слово <tt>'''break'''</tt> служит для безусловного выхода за пределы цикла, независимо от основного условия и количества "оставшихся" итераций. Оно будет рассмотрено ниже.

'''Примечание:''' Несмотря на то, что синтаксис цикла и логика его работы очень похожи на те, что присутствуют в языке C++, существуют и отличия. В частности, при использовании вложенных циклов, допускается (хоть и не рекомендуется) использование одного и того же имени управляющей переменной. Логика их использования соответствует логике [[Функции#Область видимости|применения локальных переменных в функциях]]:
<source lang="kpp" line=1>
for (var i = 1; i < 10; i++) {
puts("(1) i = #{i}");
for (var i = 1; i < 5; i++)
puts("(2) i = #{i}");
puts("(3) i = #{i}");
}
</source>

Приведем несколько более практичных примеров использования цикла в различных задачах:
<source lang="kpp" line=1>
var s = 0, var i = 1;
var ary = [];
for ( ; i < 10; i++) {
//используется внешняя переменная
s += i;
puts("#{i}: s = #{s}");
ary.push(i);
}

var list lst;
for (var i = 0; i < ary.size(); ) {
lst.push(ary[i]);
i += 2; //приращение вынесено в тело
}

var str = '[';
for (var li = lst.begin(); ; ++i) {
if (li == lst.end()) //условие вынесено в тело
break;
str += "#{li.object}, ";
}
str[str.size()-2] = "]";
puts(str);
</source>

;1-8: Для демонстрации возможности частичного указания выражений цикла, приведен пример, в цикле которого отсутствует выражение-инициализатор. Для работы, цикл использует внешнюю переменную. В теле цикла считается сумма чисел от 0 до 9; результат накапливается опять же, во внешней переменной ''s''. Далее, в массив ''ary'' добавляются текущие значения управляющей переменной, то есть ''i''.

;10-14: В теле этого цикла, мы копируем каждый нечетный элемент массива ''ary'' в список. Обратите внимание на выражение приращения (в данном случае оно вынесено в тело цикла), которое на каждой итерации добавляет к переменной индекса 2.

;16-23: Для отображения содержимого списка в удобной для восприятия форме, мы используем строковую переменную, в котороую последовательно записываются элементы массива, отделенные друг от друга запятой. Здесь, в качестве управляющей переменной, выступает [[итератор]] списка ''lst'', который создается в выражении-инициализаторе как локальная переменная цикла.

=== Цикл foreach ===

В некоторых языках программирования присутствует специальная синтаксическая конструкция цикла <tt>'''foreach'''</tt>. Как правило, она применяется в случаях, когда необходимо перебрать все значения некоторой коллекции и выполнить код, дословно, "для каждого из значений".

Учитывая то, что язык K++ ориентирован на использование [[Блоки|блоков]], непосредственная надобность в такой конструкции отпадает, поскольку ее функционал с успехом может быть реализован и даже превзойден стандартными методами коллекций, такими как <tt>each()</tt>, <tt>each_pair()</tt> и <tt>each_with_index()</tt>. Первый метод делает ровно то же самое что и традиционная конструкция <tt>'''foreach'''</tt>, второй вызывает блок, передавая ему пару из индекса и соответствующему индексу элемента из коллекции. Третий метод передает только сам индекс.

Тем не менее, в целях удобства программистов, была создана системная функция, с названием <tt>foreach()</tt>, которая ведет себя подобно оператору. На деле она всего лишь вызывает метод <tt>each()</tt> у передаваемой ей коллекции:
<source lang="kpp">
function void foreach(const collection, block b) {
collection.each(b);
}
</source>

Как видите, в качестве первого аргумента передается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]], которая используется для вызова соответствующего метода. В целом, рекомендуется использовать прямой вызов метода, тем более что он является более эффективным, и позволяет писать составные конструкции прямо в одном выражении (см. примеры в главе [[Блоки]]).

'''Примечание:''' поскольку, с точки зрения языка К++, <tt>'''foreach'''</tt> не является синтаксической конструкцией, ее следует вызывать подобно функции. Это значит, что после закрывающей фигурной скобки должна стоять точка с запятой:
<source lang="kpp">
var ary = [1, 2, 3];
var p = 1;
foreach (ary) { |x|
p *= x;
};
</source>

=== Управление циклами ===

Как уже было сказано ранее, в некоторых случаях может потребоваться изменить поведение циклов по умолчанию. Это реализуется с помощью ключевых слов <tt>'''break'''</tt> и <tt>'''continue'''</tt>.

Ключевое слво <tt>'''break'''</tt> применяется для принудительного завершения выполнения цикла и передачи управления коду, следующему за циклом. Напротив, ключевое слво <tt>'''continue'''</tt> применяется для прерывания текущей итерации и мгновенного перехода к началу следующей. В случае цикла <tt>'''while'''</tt>, это просто будет означать переход на код проверки условия; в случае цикла <tt>'''for'''</tt> — переход на код приращения управляющей переменной, с последующим переходом на код проверки условия.

Например, цикл <tt>'''for'''</tt> по умолчанию является циклом с предпроверкой условия. То есть, сначала проверяется условие, а затем либо выполняется очередная итерация, либо управление переходит за пределы цикла. Чтобы сделать из него цикл с постпроверкой условия, достаточно вынести код проверки условия в конец тела цикла:
<source lang="kpp">
for (/*инициализатор*/; ; /*приращение*/) {
/* тело цикла */
if (/*условие*/)
break;
}
</source>

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

=== Понятие бесконечного цикла ===

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

Для реализации подобных алгоритмов, применяют ''бесконечные циклы'', которые образуются из обычных, ''конечных'' путем изменения условия их выполнения:
<source lang="kpp">
//бесконечный цикл while:
while (true) {
/* тело бесконечного цикла */
}

//бесконечный цикл for:
for (;;) {
/* тело бесконечного цикла */
}
</source>

В первом случае, мы видим, что выражение условия цикла <tt>'''while'''</tt> представляет собой булеву константу <tt>'''true'''</tt>. Разумеется, ее значение постоянно и соответствует истине. Поскольку цикл <tt>'''while'''</tt> повторяется до тех пор, пока значение условного выражения истинно, получается, что этот цикл будет выполняться бесконечно.

То же самое происходит и с циклом <tt>'''for'''</tt>. Как уже было сказано выше, пустое выражение условия цикла соответствует истине, поэтому этот цикл тоже никогда не завершится.

Разумеется, подлинно бесконечные циклы никому не нужны. Компьютеры хоть редко, но все же выключаются, например для обновления программного обеспечения, или улучшения материальной базы. Соответственно программы должны иметь возможность "аккуратного" выключения своими силами. Для этого, в тело бесконечных циклов добавляется код, проверяющий некоторое внешнее условие, которое становится истинным тогда, когда требуется завершить выполнение, и прерывающий цикл с помощью ключевого слова <tt>'''break'''</tt>.

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

# Действительно ли требуется бесконечный цикл? Возможно задача может быть решена обычным, итеративным образом.
# Реализован ли корректный код прерывания цикла? Изменяется ли где-то проверочное условие? Бывает, что программисты либо забывают реализовать код прерывания цикла, либо забывают установить условие прерывания где то в другой части программы, что в конечном счете, приводит к неуправляемым программам.
# Насколько "прожорлив" код, выполняющийся в теле цикла? Может получиться так, что код находящийся в теле цикла, будет захватывать все доступные вычислительные ресурсы системы, поскольку не ограничен в потребностях. В таком случае, вся система станет нестабильной и будет плохо реагировать на действия пользователя. Чтобы этого избежать, необходимо реализовывать дополнительные механизмы, вроде механизма событий (код ожидает некоторое событие после чего продолжает работу), либо вставлять задержку, достаточную, чтобы другие процессы могли своевременно выполняться.

=== Взаимозаменяемость циклических структур ===

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

То же самое относится и к циклам. Фактически, низкоуровневая реализация любого цикла сводится к операциям вычисления значений и соответствующим переходам. В этом смысле, цикл <tt>'''for'''</tt> отличается от цикла <tt>'''while'''</tt> только тем, что в его синтаксисе уже заранее предусмотрены некоторые типовые операции, присущие большинству циклов.

Приведем примеры, показывающие взаимозаменяемость циклов:
{| width=65% align=center
| <source lang=kpp>
var s = 0;
for (var i = 0; i < 10; ++i)
s += i;

var myObject = new MyClass;
while (!myObject.Compacted)
myObject.Compact();

//бесконечный цикл while
while (true) {
var need_stop = ProcessEvents();
if (need_stop)
break;
}
</source>
| <source lang=kpp>
//цикл while в роли цикла for:
var i = 0;
var s = 0;
while (i < 10)
s += i++;

//цикл for в роли цикла while
var myObject = new MyClass;
for ( ; !myObject.Compacted; )
myObject.Compact();

//бесконечный цикл for
for (;;) {
var need_stop = ProcessEvents();
if (need_stop)
break;
}
</source>
|}

Мы видим, что один и тот же алгоритм можно реализовать как с помощью цикла <tt>'''while'''</tt>, так и с помощью <tt>'''for'''</tt>. Конечно, некоторые из указанных примеров выглядят, мягко говоря, странно. Это и понятно, — каждый из циклов создавался для решения определенных задач и был ориентирован именно на них. Цикл <tt>'''for'''</tt> создавался для задач, в которых присутствует управляющая переменнаяя, в то время как цикл <tt>'''while'''</tt> — для задач общей логики. Какой из циклов применять в каждом случае, и какой из них в этом случае является удобнее, должен решать сам программист.

Основные синтаксические конструкции

2009-10-30T12:03:43Z

Korvin: /* Цикл foreach */

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

__TOC__

== Условный оператор ==

Условный оператор — это основа основ любого языка программирования. На основании условия, то есть значения некоторого выражения, принимается решение, куда следует двигаться программе. В основе всех условных операторов лежит булева логика, при которой любое утверждение сводится к двум понятиям: истина и ложь. Если условие истинно, то управление программы движется в одну сторону. Если условие ложно — в другую. Таким образом, в каждый момент времени делается выбор всего из двух направлений. Более сложные условия строятся путем последовательного прохождения элементарных, двоичных условий.

=== Оператор if ===

В языке K++, для проверки условия служит оператор <tt>'''if'''</tt>, так же называемый условным оператором. Синтаксис этого оператора знаком наверное любому человеку, который имеет хоть какое-то представление о языках программирования:
<source lang="kpp">
if (/* выражение условия */) {
/* тело оператора */
}
</source>

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

Истинным, считается любой существующий объект, а так же логические [[Типы операторов#Операторы сравнения|операторы сравнения и отношения]] (такие как <tt>==</tt>, <tt>!=</tt>, <tt><</tt> и т. д), если их значение истинно (то есть, объекты соответствуют указанному отношению), а так же специальное ключевое слово <tt>'''true'''</tt>, которое считается истинным всегда. Исключением является объект типа bool, имеющий в данный момент значение <tt>'''false'''</tt>.

Ложными, соответственно, считаются несозданные объекты (пустые указатели), а так же операторы отношения, если их значение ложно (объекты не соответствуют отношению). Ложными так же считаются объекты, соответствующие ключевым словам <tt>'''false'''</tt> и <tt>'''null'''</tt>. Опять же, исключением является объект типа bool, если он имеет значение <tt>'''true'''</tt>.

Для ясности приведем несколько выражений, а так же укажем соответствующие им логические значения:
<source lang="kpp">
//Выражение булево значение
true true
false false
null false
var x; x false
var y; y = 1; true
var int z; z true
var bool x; false
var bool x; x = true; true
0 true
1 true
"hello world" true
0 == 1 false
5 < 6 true
2 > 3 false
5 >= 5 true
'a' != 'b' true
</source>

Обратите внимание на следующие моменты:
* Неинициализированная динамическая переменная ''x'' считается ложной (равна <tt>'''null'''</tt>)
* Инициализированная динамическая переменная ''y'' считается истинной (объект создан)
* Неинициализированная статическая переменная ''z'' считается истинной (объект создан)
* Переменная типа <tt>bool</tt> имеет значение по умолчанию <tt>'''false'''</tt> (хотя объект создан)
* 0, так же как любой другой созданный объект считается '''истиной''', в отличие от C++.
* условие 5 >= 5 считается истиной, так как формулируется как "5 больше 5 '''или''' равно 5"

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

В языке К++ все наоборот. Все с чем он оперирует — это объекты. Провести грань между стандартными типами данных и пользовательскими невозможно. Числа, что фигурируют в программе так же являются объектами. Даже числовые константы которые записываются в выражениях — это тоже объекты (это уже было показано в [[Введение, или краткий обзор#Расширение классов|кратком обзоре]]). За основу логики языка принимается факт существования объекта. Если объекта не существует — значение ложно, если существует — истинно (кроме описанных выше исключений). Оператор <tt>'''if'''</tt> помимо чистой логики, служит для определения существования объекта. Получается, что при таком подходе, делать для нуля исключение нерационально, и более того — это может привести к ошибкам. Возьмем к примеру код:

<source lang="kpp">
if (x) {
/* код, соответствущий существованию переменной x */
}
</source>

Подразумевается, что тело оператора будет выполнено в случае, если передаваемый объект (вероятнее всего [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]) инициализирован и существует. Но что будет, если мы передадим в качестве объекта динамическую переменную, содержащую объект типа <tt>int</tt>, равный нулю? Если бы реализация языка обрабатывала значение 0 как ложь, то логика оператора <tt>'''if'''</tt> в частости и всей программы в целом, зависела бы от фактического значения переменной, а соответственно была бы неопределенной и даже непредсказуемой. Получалось бы, что для одних переменных, оператор работает одним образом, а для других — другим. Отладка подобной программы может занять многие часы. А все из-за одной условности.

Таким образом, можно заключить, что оператор <tt>'''if'''</tt> следует применять для проверки логического выражения, либо для проверки существования переменной. Если мы хотим проверить равенство переменной нулю, то это необходимо делать явно:
<source lang="kpp">
if (x == 0) {
/* что нужно делать, если x равен 0 */
}
</source>

=== Оператор if-else ===

Если нам необходимо организовать ''ветвление'', то есть в случае истинности, выполнить один участок кода, а в случае ложности другой, то применяется расширенная форма оператора <tt>'''if-else'''</tt>:
<source lang="kpp">
if (/* выражение условия */) {
/* код, соответствущий истине */
} else {
/* код, соответствущий лжи */
}
</source>

Если условие истинно, то будет выполнен первый блок, если ложно то второй.

Условные операторы, подобно многим другим, позволяют организовывать вложения, когда в тело одного условного оператора вкладывается один или несколько других условных операторов, например:
<source lang="kpp">
if (/* условие 1 */) {
/* если условие 1 истинно: */
if (/* условие 2 */) {
/* если условие 2 истинно */
}
if (/* условие 3 */) {
/* если условие 3 истинно */
}
} else {
/* если условие 1 ложно: */
if (/* условие 4 */) {
/* если условие 4 истинно */
} else {
/* код, соответствущий лжи условия 4 */
}
}
</source>
Таким образом можно строить разветвленные деревья условий, которые и реализуют алгоритмы программ.

=== Оператор if-elsif-else ===

Существует так же третья форма условного оператора, которая позволяет проверять несколько условий в единой, более эффективной форме. Это конструкция <tt>'''if-elsif-else'''</tt>:
<source lang="kpp">
if (/* условие 1 */) {
/* код, соответствущий истине условия 1*/
} elsif (/*условие 2*/) {
/* код, соответствущий истине условия 2*/
...
} else {
/* код, соответствущий лжи */
}
</source>
Она работает так: сначала проверяется условие 1. Если оно истинно, то выполняется код в первом блоке, а затем управление выходит за рамки всей связки. Если условие 1 ложно, то проверяется условие 2, и т. д. Таким образом, вышеописанная конструкция функционально эквивалентна следующей конструкции, однако более компактна.

<source lang="kpp">
if (/* условие 1 */) {
/* если условие 1 истинно */
} else {
if (/* условие 2 */) {
/* если условие 2 истинно */
} else {
if (/* условие 3 */) {
/* если условие 3 истинно */
} else {
...
}
}
}
</source>

=== Постфиксные операторы ===

Существует так же более лаконичная форма оператора <tt>'''if'''</tt>, удобная для записи коротких, однострочных условий. При этом, само условие записывается после выражения, которое оно должно проверить:

<source lang="kpp">
/* выражение */ if /* условие */;
</source>

При такой записи, окружать условие скобками не требуется. Проверяемое выражение должно быть единственным, то есть не содержать оператора точка с запятой (<tt>;</tt>). Такие условия занимают меньше места в программе и помогут сделать ваш код более чистым:

<source lang="kpp">
var even_sum = 0;
for (var i = 1; i < 100; i++)
even_sum += i if i % 2 == 0; //сумма всех четных чисел
</source>

Для проверки "невыполнения" условия есть специальная форма постфиксного оператора — <tt>'''unless'''</tt>. Выражение при таком операторе будет выполняться только если условие ложно. Таким образом, смысл оператора прямо противоположен оператору <tt>'''if'''</tt>. Конечно, эти два оператора взаимозаменяемы. Конструкция <tt>do_smth '''if''' x;</tt> делает то же самое что <tt>do_smth '''unless''' !x;</tt>.

Перепишем предыдущий код с использованием оператора <tt>'''unless'''</tt>:

<source lang="kpp">
var even_sum = 0;
for (var i = 1; i < 100; i++)
even_sum += i unless i % 2 != 0; //сумма всех четных чисел
</source>

=== Тернарный условный оператор ===

В некоторых случаях, может возникнуть ситуация, при которой необходимо присвоить значение некоторой переменной на основании условия. То есть, при истинности условия присвоить одно значение, а при ложности — другое. Это можно осуществить двумя способами. Первый способ — использовать обычный условный оператор:
<source lang="kpp">
var x = 5;
var y = 0;
if (x > 3)
y = 3;
else
y = -1;
</source>

Не будем уточнять, зачем кому-то мог понадобиться подобный "гениальный" код, а отметим лишь то, что операция присвоения занимает 4 строки при соблюдении правил форматирования кода. В тех случаях, когда тела условного оператора представляют собой простые выражения "в одну строчку", особенно если, как уже было сказано выше, происходит присвоение, разумно применять специальную форму условного оператора — тернарный оператор <tt>?:</tt>. Тогда, тот же код будет выглядеть так:
<source lang="kpp">
var x = 5;
var y = 0;
y = x > 5 ? 3 : -1;
</source>

Это единственный в языке К++ тернарный оператор, работающий с тремя выражениями сразу. Первое выражение — это условие; оно располагается слева, до знака вопроса. Между знаком вопроса и знаком двоеточия расположено выражение, которое должно подставляться, в случае истинности условия. Последним располагается выражениие, подставляющееся в случае ложности.

Данная форма оператора очень удобна для записи непосредственно внутри выражений, фактических параметров в вызовах функций, либо любых других выражениях. Его даже можно применять в операторе подстановки <tt>#{ }</tt> в строках. Можно его применять и без возврата значения, например так:
<source lang="kpp">
while (true) {
CheckState() != State.OK ? Signal() : Sleep();
}
</source>

'''Примечание:''' Работать такой код будет если и <tt>Signal()</tt> и <tt>Sleep()</tt> возвращают значения.

== Оператор множественного выбора (switch) ==

В тех случаях, когда требуется сравнить значение некоторого выражения с большим количеством возможных значений, применять обычные условные операторы неразумно. Код получится громоздким и трудно читаемым, а самое главное — изменять такой код будет очень сложно. В таких случаях, на помощь программисту приходит оператор множественного выбора, или оператор <tt>'''switch'''</tt>.

Предположим, что перед нами стоит такая задача: функция получает некоторый числовой код ошибки и на основании него должна выполнять различные действия. В частности, выводить соответствующие сообщения. Если от нас требуется только вернуть соответствующую коду ошибки строку, проще всего и эффективнее, разумеется, применять [[Стандартные типы данных#Хеши|хеши]], но мы будем считать что требуется сделать что-то еще.

Конструкция множественного выбора реализуется следующим образом: указывается ключевое слово <tt>'''switch'''</tt>, после которого, в круглых скобках указывается выражение-''селектор'', которое мы будем анализировать. Затем, ставятся фигурные скобки switch-блока, в теле которого могут быть только конструкции, относящиеся непосредственно к оператору. В нашем случае это будет примерно так:
<source lang="kpp">
function ProcessError(const int errno) {
switch (errno) {
/* switch блок */
}
}
</source>

Далее, мы должны определить относящиеся к делу случаи, а именно, перечислить конкретные значения, с которыми мы будем сравнивать код ошибки и на основании этого сравнения будем выполнять некоторые операции. Это осуществляется с помощью подоператора <tt>'''case'''</tt>, который записывается так:
<source lang="kpp">
case /* выражение сравнения */: /* обработчик */
</source>

Выражение сравнения — это любое выражение, которое будет сравниваться с селектором. В качестве такого выражения может быть выбрано не одно, а сразу несколько условий. Тогда они должны отделяться друг от друга запятой:
<source lang="kpp">
case /*условие1*/, /*условие2*/, ... /*условие N*/: /* обработчик */
</source>

В качестве условия может так же быть указан [[Стандартные типы данных#Интервалы|интервал]]. Тогда будет проверяться, попадает ли значение выражения селектора в заданный интервал. Например, если нам необходимо анализировать численное выражение, то один из операторов <tt>'''case'''</tt> может выглядеть так:
<source lang="kpp">
case 1, 2, 5 .. 10, 12: /* обработчик */
</source>

Для срабатывания обработчика достаточно, чтобы сработало хотябы одно из условий, перечисленных в списке; тогда управление будет передано коду обработчика. Обработчиком может быть либо отдельное выражение, либо блок. Во втором случае, его необходимо заключить в фигурные скобки. В отличие от C++, после обработчика управление передается за пределы оператора <tt>'''switch'''</tt>, а не на следующее сравнение. То есть, логика работы более близка к паскалевской конструкции <tt>'''case'''</tt>.

Для безусловного выхода из любого места обработчика, может применяться ключевое слово <tt>'''break'''</tt>. При этом, управление будет передано коду, следующему за оператором <tt>'''switch'''</tt>.

Если требуется рассмотреть отдельный случай, когда ни одно из условий не было удовлетворено (то есть, ни один из операторов <tt>'''case'''</tt> не сработал), применяется ''действие по умолчанию''. Для этого, необходимо записать ключевое слово <tt>'''default'''</tt>, а затем через двоеточие указать обработчик. Естественно, никакого выражения сравнения тут нет.

'''Примечание:''' при использовании обработчиков по умолчанию, следует иметь в виду что:
* на кажый оператор <tt>'''switch'''</tt> может быть указан только один обработчик по умолчанию
* обработчик по умолчанию должен быть записан в самом конце конструкции

Обобщив вышесказанное, напишем наконец, реализацию задуманной нами функции:
<source lang="kpp" line="1">
function ProcessError(const int errno) {
switch (errno) {
case AGAIN: {
Log("требуется повтор операции");
/* запрашиваем у пользователя подтверждение на повтор */
}
case ACCESS_DENIED:
Log("ошибка доступа");
case REQUEST_TIMEOUT, TIMEOUT:
Log("таймаут");
default:
Log("неизвестный код ошибки: #{errno}");
}
}
</source>

;3-6: Поскольку выражение обработчик сложное, то есть состоит более чем из одной конструкции, мы заключили его в фирурные скобки.

;9: Для случаев REQUEST_TIMEOUT и TIMEOUT был использован один обработчик. Подразумевается, что коды, соответствующие данным ошибкам разные, но программист решил их объединить в одно целое.

== Циклы ==

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

=== Цикл while ===

Простейшим из циклов является цикл <tt>'''while'''</tt>, который выглядит следующим образом:
<source lang="kpp">
while (/*условие*/) {
/* тело цикла */
}
</source>

[[Изображение:While_loop.png|thumb|left|Блок схема цикла while]]

Цикл <tt>'''while'''</tt> является циклом с предпроверкой условия, то есть, сначала проверяется значение выражения в условии цикла, а затем выполняется переход на тело цикла (если условие истинно), либо за пределы цикла (если ложно). Схематически, поведение цикла изображено на блочной диаграмме слева.

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

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

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

 

'''Примечание:''' Существует так же постфиксная форма оператора <tt>'''while'''</tt>, принципы использования которой схожи с таковыми в случае [[#Постфиксные операторы|постфиксных условных операторов]]. Например так можно посчитать сумму чисел от одного до ста практически "в одно действие":

<source lang="kpp">
var i = 0, s = 0;
s += i++ while i < 100;
</source>

=== Цикл for ===

[[Изображение:For_loop.png|thumb|left|Блок схема цикла for]]
Более сложным примером является цикл <tt>'''for'''</tt>. Как правило, он применяется в случаях, когда есть некоторая переменная изменяющая свое значение в определенных пределах и сохраняющая свое значение в течение всей итерации. В конструкции цикла <tt>'''for'''</tt> собраны все необходимые операции, что позволяет оперировать переменной более удобным образом. Опять же, исключается возможность ошибки, при которой программист забыл выполнить одну из операций.

Цикл <tt>'''for'''</tt> работает следующим образом. Сначала выполняется код инициализации переменной цикла (ее еще называют управляющей переменной). Как видно из блочной диаграммы, это происходит только один раз, в самом начале. Затем, проверяется условие. Если условие истинно, управление передается телу цикла. Подразумевается, что в нем будут производиться некоторые действия, учиывающие текущее значение переменной цикла. После выполнения тела цикла, производится приращение управляющей переменной. Далее управление опять передается коду проверки условия; так повторяется до тех пор пока значение выражения условия не станет ложным.

 
В отличие от паскаля, цикл <tt>'''for'''</tt> совершенно не обязательно должен работать с числами. В роли управляющей переменной может выступать любой объект. Синтаксис оператора <tt>'''for'''</tt> выглядит так:
<source lang="kpp">
for (/* инициализатор */; /* условие */ ; /* приращение */) {
/* тело цикла */
}
</source>

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

Если требуется объявление, то следует использовать конструкцию объявления переменной, точно такую же как и в обычной практике. То есть, правила объявления переменных и инициализации те же. Выражение-условие содержит некоторое выражение (обычно оператор отношения), которое должно менять свое значение в зависимости от значения управляющей переменной. Наконец, выражение приращения используется для изменения значения управляющей переменной на некоторую атомарную величину. В случае целочисленного типа управляющей переменной, для этого, как правило, используется оператор <tt>++</tt> (поскольку выражение приращения выполняется отдельно от тела, здесь не имеет значения, какую форму оператора использовать).

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

{| width=65% align=center
| <source lang="kpp">
for (var i = 0; i < 10; i++) {
/* тело */

}
</source>
| <source lang="kpp">
var i = 0;
for (; i < 10; i++) {
/* тело */
}
</source>
|-
| <source lang="kpp">
for (var i = 0; ; i++) {
if (i >= 10)
break;
/* тело */
}
</source>
| <source lang="kpp">
for (var i = 0; i < 10; ) {
/* тело */
i++;

}
</source>
|}

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

Ключевое слово <tt>'''break'''</tt> служит для безусловного выхода за пределы цикла, независимо от основного условия и количества "оставшихся" итераций. Оно будет рассмотрено ниже.

'''Примечание:''' Несмотря на то, что синтаксис цикла и логика его работы очень похожи на те, что присутствуют в языке C++, существуют и отличия. В частности, при использовании вложенных циклов, допускается (хоть и не рекомендуется) использование одного и того же имени управляющей переменной. Логика их использования соответствует логике [[Функции#Область видимости|применения локальных переменных в функциях]]:
<source lang="kpp" line=1>
for (var i = 1; i < 10; i++) {
puts("(1) i = #{i}");
for (var i = 1; i < 5; i++)
puts("(2) i = #{i}");
puts("(3) i = #{i}");
}
</source>

Приведем несколько более практичных примеров использования цикла в различных задачах:
<source lang="kpp" line=1>
var s = 0, var i = 1;
var ary = [];
for ( ; i < 10; i++) {
//используется внешняя переменная
s += i;
puts("#{i}: s = #{s}");
ary.push(i);
}

var list lst;
for (var i = 0; i < ary.size(); ) {
lst.push(ary[i]);
i += 2; //приращение вынесено в тело
}

var str = '[';
for (var li = lst.begin(); ; ++i) {
if (li == lst.end()) //условие вынесено в тело
break;
str += "#{li.object}, ";
}
str[str.size()-2] = "]";
puts(str);
</source>

;1-8: Для демонстрации возможности частичного указания выражений цикла, приведен пример, в цикле которого отсутствует выражение-инициализатор. Для работы, цикл использует внешнюю переменную. В теле цикла считается сумма чисел от 0 до 9; результат накапливается опять же, во внешней переменной ''s''. Далее, в массив ''ary'' добавляются текущие значения управляющей переменной, то есть ''i''.

;10-14: В теле этого цикла, мы копируем каждый нечетный элемент массива ''ary'' в список. Обратите внимание на выражение приращения (в данном случае оно вынесено в тело цикла), которое на каждой итерации добавляет к переменной индекса 2.

;16-23: Для отображения содержимого списка в удобной для восприятия форме, мы используем строковую переменную, в котороую последовательно записываются элементы массива, отделенные друг от друга запятой. Здесь, в качестве управляющей переменной, выступает [[итератор]] списка ''lst'', который создается в выражении-инициализаторе как локальная переменная цикла.

=== Цикл foreach ===

В некоторых языках программирования присутствует специальная синтаксическая конструкция цикла <tt>'''foreach'''</tt>. Как правило, она применяется в случаях, когда необходимо перебрать все значения некоторой коллекции и выполнить код, дословно, "для каждого из значений".

Учитывая то, что язык K++ ориентирован на использование [[Блоки|блоков]], непосредственная надобность в такой конструкции отпадает, поскольку ее функционал с успехом может быть реализован и даже превзойден стандартными методами коллекций, такими как <tt>each()</tt>, <tt>each_pair()</tt> и <tt>each_with_index()</tt>. Первый метод делает ровно то же самое что и традиционная конструкция <tt>'''foreach'''</tt>, второй вызывает блок, передавая ему пару из индекса и соответствующему индексу элемента из коллекции. Третий метод передает только сам индекс.

Тем не менее, в целях удобства программистов, была создана системная функция, с названием <tt>foreach()</tt>, которая ведет себя подобно оператору. На деле она всего лишь вызывает метод <tt>each()</tt> у передаваемой ей коллекции:
<source lang="kpp">
function void foreach(collection, block b) {
collection.each(b);
}
</source>

Как видите, в качестве первого аргумента передается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]], которая используется для вызова соответствующего метода. В целом, рекомендуется использовать прямой вызов метода, тем более что он является более эффективным, и позволяет писать составные конструкции прямо в одном выражении (см. примеры в главе [[Блоки]]).

'''Примечание:''' поскольку, с точки зрения языка К++, <tt>'''foreach'''</tt> не является синтаксической конструкцией, ее следует вызывать подобно функции. Это значит, что после закрывающей фигурной скобки должна стоять точка с запятой:
<source lang="kpp">
var ary = [1, 2, 3];
var p = 1;
foreach (ary) { |x|
p *= x;
};
</source>

=== Управление циклами ===

Как уже было сказано ранее, в некоторых случаях может потребоваться изменить поведение циклов по умолчанию. Это реализуется с помощью ключевых слов <tt>'''break'''</tt> и <tt>'''continue'''</tt>.

Ключевое слво <tt>'''break'''</tt> применяется для принудительного завершения выполнения цикла и передачи управления коду, следующему за циклом. Напротив, ключевое слво <tt>'''continue'''</tt> применяется для прерывания текущей итерации и мгновенного перехода к началу следующей. В случае цикла <tt>'''while'''</tt>, это просто будет означать переход на код проверки условия; в случае цикла <tt>'''for'''</tt> — переход на код приращения управляющей переменной, с последующим переходом на код проверки условия.

Например, цикл <tt>'''for'''</tt> по умолчанию является циклом с предпроверкой условия. То есть, сначала проверяется условие, а затем либо выполняется очередная итерация, либо управление переходит за пределы цикла. Чтобы сделать из него цикл с постпроверкой условия, достаточно вынести код проверки условия в конец тела цикла:
<source lang="kpp">
for (/*инициализатор*/; ; /*приращение*/) {
/* тело цикла */
if (/*условие*/)
break;
}
</source>

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

=== Понятие бесконечного цикла ===

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

Для реализации подобных алгоритмов, применяют ''бесконечные циклы'', которые образуются из обычных, ''конечных'' путем изменения условия их выполнения:
<source lang="kpp">
//бесконечный цикл while:
while (true) {
/* тело бесконечного цикла */
}

//бесконечный цикл for:
for (;;) {
/* тело бесконечного цикла */
}
</source>

В первом случае, мы видим, что выражение условия цикла <tt>'''while'''</tt> представляет собой булеву константу <tt>'''true'''</tt>. Разумеется, ее значение постоянно и соответствует истине. Поскольку цикл <tt>'''while'''</tt> повторяется до тех пор, пока значение условного выражения истинно, получается, что этот цикл будет выполняться бесконечно.

То же самое происходит и с циклом <tt>'''for'''</tt>. Как уже было сказано выше, пустое выражение условия цикла соответствует истине, поэтому этот цикл тоже никогда не завершится.

Разумеется, подлинно бесконечные циклы никому не нужны. Компьютеры хоть редко, но все же выключаются, например для обновления программного обеспечения, или улучшения материальной базы. Соответственно программы должны иметь возможность "аккуратного" выключения своими силами. Для этого, в тело бесконечных циклов добавляется код, проверяющий некоторое внешнее условие, которое становится истинным тогда, когда требуется завершить выполнение, и прерывающий цикл с помощью ключевого слова <tt>'''break'''</tt>.

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

# Действительно ли требуется бесконечный цикл? Возможно задача может быть решена обычным, итеративным образом.
# Реализован ли корректный код прерывания цикла? Изменяется ли где-то проверочное условие? Бывает, что программисты либо забывают реализовать код прерывания цикла, либо забывают установить условие прерывания где то в другой части программы, что в конечном счете, приводит к неуправляемым программам.
# Насколько "прожорлив" код, выполняющийся в теле цикла? Может получиться так, что код находящийся в теле цикла, будет захватывать все доступные вычислительные ресурсы системы, поскольку не ограничен в потребностях. В таком случае, вся система станет нестабильной и будет плохо реагировать на действия пользователя. Чтобы этого избежать, необходимо реализовывать дополнительные механизмы, вроде механизма событий (код ожидает некоторое событие после чего продолжает работу), либо вставлять задержку, достаточную, чтобы другие процессы могли своевременно выполняться.

=== Взаимозаменяемость циклических структур ===

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

То же самое относится и к циклам. Фактически, низкоуровневая реализация любого цикла сводится к операциям вычисления значений и соответствующим переходам. В этом смысле, цикл <tt>'''for'''</tt> отличается от цикла <tt>'''while'''</tt> только тем, что в его синтаксисе уже заранее предусмотрены некоторые типовые операции, присущие большинству циклов.

Приведем примеры, показывающие взаимозаменяемость циклов:
{| width=65% align=center
| <source lang=kpp>
var s = 0;
for (var i = 0; i < 10; ++i)
s += i;

var myObject = new MyClass;
while (!myObject.Compacted)
myObject.Compact();

//бесконечный цикл while
while (true) {
var need_stop = ProcessEvents();
if (need_stop)
break;
}
</source>
| <source lang=kpp>
//цикл while в роли цикла for:
var i = 0;
var s = 0;
while (i < 10)
s += i++;

//цикл for в роли цикла while
var myObject = new MyClass;
for ( ; !myObject.Compacted; )
myObject.Compact();

//бесконечный цикл for
for (;;) {
var need_stop = ProcessEvents();
if (need_stop)
break;
}
</source>
|}

Мы видим, что один и тот же алгоритм можно реализовать как с помощью цикла <tt>'''while'''</tt>, так и с помощью <tt>'''for'''</tt>. Конечно, некоторые из указанных примеров выглядят, мягко говоря, странно. Это и понятно, — каждый из циклов создавался для решения определенных задач и был ориентирован именно на них. Цикл <tt>'''for'''</tt> создавался для задач, в которых присутствует управляющая переменнаяя, в то время как цикл <tt>'''while'''</tt> — для задач общей логики. Какой из циклов применять в каждом случае, и какой из них в этом случае является удобнее, должен решать сам программист.

Объявление переменных и констант

2009-10-28T14:30:13Z

Korvin: /* Конструкция группового объявления */

Про объявление как переменных так и констант уже достаточно много говорилось в предыдущих главах этой книги. Вероятно, Читатель уже хорошо себе представляет что такое [[переменные]], чем они отличаются от [[Константы|констант]] и как следует их [[Переменные#Типизация при инициализации|инициализировать]]. Читатель уже должен представлять себе, что такое [[Переменные#Понятие переменной, тип переменной|тип]] переменной или константы, и чем статически типированные переменные отличаются от нетипированных, [[Переменные#Нетипированные (динамические) переменные|динамических переменных]]. В этой главе мы не будем уделять много внимания философским вопросам, касающимся переменных и констант, а опишем только сами синтаксические конструкции объявления.

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

<source lang="kpp" line="1">
var x;
var x = "hello";
var x, y;
var x, y = 0;
var int x, y;
var int x, real y;
var int x = "1", y = 1.5;
</source>

При объявлении переменных важно понимать, что при явном указании типа переменной, он сопостовляется только идентификатору идущему сразу после него. Таким образом, строка 5 объявляет переменную ''x'' типа <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, в то время как переменная ''y'' будет иметь [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

То же самое относится и к инициализаторам, которые ставятся в соответствие только той переменной, которая стоит слева от оператора "=". К примеру, выражение в строке 4 будет инициализировать только переменную ''y'', в то время как переменная ''x'' не будет иметь инициализатора; то есть для переменной ''x'' объявление эквивалентно тому что записано в строке 1.

Обратите внимание на строку 7: переменная ''x'' имеет инициализатор типа <tt>string</tt>, но ввиду того что тип переменной указан явным образом, переменная будет иметь тип <tt>int</tt>. При этом, тип инициализатора будет ''приведен'' к типу переменной. Если же типы переменной и инициализатора ''неприводимы'', — будет выдано сообщение об ошибке.

Приведем еще раз те же самые примеры, но оформим их в виде таблицы, дополнив сведениями о типах переменых:

<source lang="kpp">
//Строка объявления Тип x Тип y Инициализатор x Инициализатор y

var x; динамика
var x = "hello"; string "hello"
var x, y; динамика динамика
var x, y = 0; динамика int 0
var int x, y; int динамика
var int x, real y; int real
var int x = "1", y = 1.5; int real "1" as int 1.5
</source>

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

<source lang="kpp">
var x = 0;
var y;
y = 0;
</source>

В результате выполнения этого кода и переменная ''x'', и переменная ''y'' будут иметь значение равное 0. Более того, типы переменных в этот момент будут совпадать и равны <tt>int</tt>. Однако, переменная ''x'' будет иметь статический тип, в то время как переменная ''y'' — [[Переменные#Нетипированные (динамические) переменные|динамический]]. Если же мы попытаемся присвоить этим переменным другие значения, заведомо неприводимого типа, то произойдет следующее:

<source lang="kpp">
x = { |x| return x + 1; };
y = [1, 2, 3];
</source>

В случае переменной ''x'' будет сгенерирована ошибка еще на этапе компиляции, поскольку тип переменной был назначен статически при инициализации и не может быть изменен в ходе работы программы. В случае переменной ''y'' никакой ошибки не произойдет, поскольку это динамическая переменная. В ходе присваивания, она просто изменит свой тип на <tt>[[Стандартные типы данных#Массивы и списки|array]]</tt> и будет представлять собой уже массив из трех чисел.

----

Объявления констант вместо <tt>'''var'''</tt>, начинаются с ключевого слова <tt>'''const'''</tt> и синтаксически ничем не отличаются от объявления переменных, за исключением того, что константы обязательно должны инициализироваться:

<source lang="kpp">
const x; //неверно. требуется инициализатор
const x = "hello"; //верно
const x, y = 0; //неверно. константа x не инициализируется
const int x = "1", y = 1.5; //верно
</source>

== Конструкция группового объявления ==

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

<source lang="kpp">
var (x, y, z) = [1, '2', true];
</source>

Будут объявлены три динамических переменных, инициализованные соответствующими элементами из массива. Размер массива должен быть не меньше количества объявляемых переменных. Если это не так, то переменные, которым не хватило элементов массива, не будут инициализированы.

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

Пример использования:
<source lang="kpp">
class QueryResult {
var FName, FAddress, FPhone;
public:
property string name read FName;
property string address read FAddresss;
property string phoneNumber read FPhone;
operator new(_name, _addr, _phone) {
(FName, FAddress, FPhone) = [_name, _addr, _phone];
}
}

function SearchByName(const string Name) {
// ... код обращения к БД ...
// предположим, были возвращены следующие данные:
var result = new QueryResult( 'Vassily Pupkin',
'Бобруйская область, село Урюпинское, д. 13', '223-322');
return result;
}

function main() {
// ...
var result = SearchByName('%Pupkin%'); // делаем запрос
// работаем с результатами, используя result.name, result.address и result.phoneNumber
puts("Телефон Васи Пупкина: #{result.phoneNumber}");
}
</source>

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

С использованием конструкции группового объявления, задача передачи и разбора параметров становится намного проще:
<source lang="kpp">
function SearchByName(const string Name) {
// ... код обращения к БД ...
// ... 'Vassily Pupkin', 'Бобруйская область, село Урюпинское, д. 13', '223-322'
return [ name, addr, phone ];
}

function main() {
// ...
var (name, addr, phone) = SearchByName('%Pupkin%'); // делаем запрос
puts("Телефон Васи Пупкина: #{phone}");
}
</source>

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

А вот простой способ разделить входную строку на подстроки и назначить каждой из них свою переменную:
<source lang="kpp">
var record = System.shellExecute("head -1 /etc/passwd"); // строка вида 'root:x:0:0:root:/root:/bin/bash'
var (account, password, UID, GID, info, homedir, shell) = record.split(':');
puts("Пользователь #{account} с номером #{UID} пользуется оболочкой #{shell} и хранит свои данные в #{homedir}");
</source>

Метод [[string#split]] возвращает массив подстрок, поэтому зная результат выполнения метода мы можем произвести нашу операцию объявления переменных. Это намного удобнее, чем обращаться к элементам по индексам, тем самым избегая ошибок и опять же делая код более читаемым.

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

<source lang="kpp">
var x = 1, y = 2; // объявление переменных
(x, y) = [3, 4]; // групповое присваивание
(x, y) = [y, x]; // простой способ обменять значения местами
</source>

== Смотри также ==

Объявление переменных и констант

2009-10-28T12:03:29Z

Korvin: /* Конструкция группового объявления */

Объявление переменных и констант

2009-10-28T11:59:00Z

Korvin: Конструкция группового объявления

Про объявление как переменных так и констант уже достаточно много говорилось в предыдущих главах этой книги. Вероятно, Читатель уже хорошо себе представляет что такое [[переменные]], чем они отличаются от [[Константы|констант]] и как следует их [[Переменные#Типизация при инициализации|инициализировать]]. Читатель уже должен представлять себе, что такое [[Переменные#Понятие переменной, тип переменной|тип]] переменной или константы, и чем статически типированные переменные отличаются от нетипированных, [[Переменные#Нетипированные (динамические) переменные|динамических переменных]]. В этой главе мы не будем уделять много внимания философским вопросам, касающимся переменных и констант, а опишем только сами синтаксические конструкции объявления.

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

<source lang="kpp" line="1">
var x;
var x = "hello";
var x, y;
var x, y = 0;
var int x, y;
var int x, real y;
var int x = "1", y = 1.5;
</source>

При объявлении переменных важно понимать, что при явном указании типа переменной, он сопостовляется только идентификатору идущему сразу после него. Таким образом, строка 5 объявляет переменную ''x'' типа <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, в то время как переменная ''y'' будет иметь [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

То же самое относится и к инициализаторам, которые ставятся в соответствие только той переменной, которая стоит слева от оператора "=". К примеру, выражение в строке 4 будет инициализировать только переменную ''y'', в то время как переменная ''x'' не будет иметь инициализатора; то есть для переменной ''x'' объявление эквивалентно тому что записано в строке 1.

Обратите внимание на строку 7: переменная ''x'' имеет инициализатор типа <tt>string</tt>, но ввиду того что тип переменной указан явным образом, переменная будет иметь тип <tt>int</tt>. При этом, тип инициализатора будет ''приведен'' к типу переменной. Если же типы переменной и инициализатора ''неприводимы'', — будет выдано сообщение об ошибке.

Приведем еще раз те же самые примеры, но оформим их в виде таблицы, дополнив сведениями о типах переменых:

<source lang="kpp">
//Строка объявления Тип x Тип y Инициализатор x Инициализатор y

var x; динамика
var x = "hello"; string "hello"
var x, y; динамика динамика
var x, y = 0; динамика int 0
var int x, y; int динамика
var int x, real y; int real
var int x = "1", y = 1.5; int real "1" as int 1.5
</source>

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

<source lang="kpp">
var x = 0;
var y;
y = 0;
</source>

В результате выполнения этого кода и переменная ''x'', и переменная ''y'' будут иметь значение равное 0. Более того, типы переменных в этот момент будут совпадать и равны <tt>int</tt>. Однако, переменная ''x'' будет иметь статический тип, в то время как переменная ''y'' — [[Переменные#Нетипированные (динамические) переменные|динамический]]. Если же мы попытаемся присвоить этим переменным другие значения, заведомо неприводимого типа, то произойдет следующее:

<source lang="kpp">
x = { |x| return x + 1; };
y = [1, 2, 3];
</source>

В случае переменной ''x'' будет сгенерирована ошибка еще на этапе компиляции, поскольку тип переменной был назначен статически при инициализации и не может быть изменен в ходе работы программы. В случае переменной ''y'' никакой ошибки не произойдет, поскольку это динамическая переменная. В ходе присваивания, она просто изменит свой тип на <tt>[[Стандартные типы данных#Массивы и списки|array]]</tt> и будет представлять собой уже массив из трех чисел.

----

Объявления констант вместо <tt>'''var'''</tt>, начинаются с ключевого слова <tt>'''const'''</tt> и синтаксически ничем не отличаются от объявления переменных, за исключением того, что константы обязательно должны инициализироваться:

<source lang="kpp">
const x; //неверно. требуется инициализатор
const x = "hello"; //верно
const x, y = 0; //неверно. константа x не инициализируется
const int x = "1", y = 1.5; //верно
</source>

== Конструкция группового объявления ==

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

<source lang="kpp">
var (x, y, z) = [1, '2', true];
</source>

Будут объявлены три динамических переменных, инициализованные соответствующими элементами из массива. Размер массива должен быть не меньше количества объявляемых переменных. Если это не так, то переменные, которым не хватило элементов массива, не будут инициализированы.

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

Пример использования:
<source lang="kpp">
class QueryResult {
var FName, FAddress, FPhone;
public:
property string name read FName;
property string address read FAddresss;
property string phoneNumber read FPhone;
operator new(_name, _addr, _phone) {
(FName, FAddress, FPhone) = [_name, _addr, _phone];
}
}

function SearchByName(const string Name) {
// ... код обращения к БД ...
// предположим, были возвращены следующие данные:
var result = new QueryResult( 'Vassily Pupkin',
'Бобруйская область, село Урюпинское, д. 13', '223-322');
return result;
}

function main() {
// ...
var result = SearchByName('%Pupkin%'); // делаем запрос
// работаем с результатами, используя result.name, result.address и result.phoneNumber
puts("Телефон Васи Пупкина: #{result.phoneNumber}");
}
</source>

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

С использованием конструкции группового объявления, задача передачи и разбора параметров становится намного проще:
<source lang="kpp">
function SearchByName(const string Name) {
// ... код обращения к БД ...
// ... 'Vassily Pupkin', 'Бобруйская область, село Урюпинское, д. 13', '223-322'
return [ name, addr, phone ];
}

function main() {
// ...
var (name, addr, phone) = SearchByName('%Pupkin%'); // делаем запрос
puts("Телефон Васи Пупкина: #{phone}");
}
</source>

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

А вот простой способ разделить входную строку на подстроки и назначить каждой из них свою переменную:
<source lang="kpp">
var record = System.shellExecute("head -1 /etc/passwd"); // строка вида 'root:x:0:0:root:/root:/bin/bash'
var (account, password, UID, GID, info, directory, shell) = record.split(':');
</source>

Метод [[string#split]] возвращает массив подстрок, поэтому зная результат выполнения метода мы можем произвести нашу операцию объявления переменных. Это намного удобнее, чем обращаться к элементам по индексам, тем самым избегая ошибок и опять же делая код более читаемым.

== Смотри также ==

Рабочие заметки

2009-10-28T10:14:04Z

Korvin: /* TODO */

== TODO ==

* Описать концепцию <tt>Proc</tt>:
** Отличия от <tt>[[Closure]]</tt>
** Дать ссылки в книге
* Частичная поддержка перегрузки функций
* <s>Ключевое слово <tt>'''ensure'''</tt></s>
* Описать конструкцию (a, b, c) = [x, y, z]
* Переделать все иемна исключений в основную форму ESmthError
* Описать механизм примесей и его идеологию
** Зачем нужны
** Чем отличаются от обычного наследования/расширения
** <tt>Comparable</tt>, <tt>Enumerable</tt>, <tt>Operable</tt>
* Добавить строки <tt>:string</tt> и #x в схему подсветки и ключ слово <tt>'''ensure'''</tt>
* Описать необходимость приведения типов (где надо) при работе с динамическими переменными
* Поля в расширениях теперь можно делать (?)
* Пространства имен
* [[Классы и объекты#Расширения]], описать возможность вызова предыдущей копии метода (когда появится возможность)
* <tt>'''break'''</tt> в блоках
* перечисления?
* <tt>MyClass.MY_CONST</tt>
* <s>абстрактные методы</s>
* [[Стандартные типы данных#Потоки]]

== Замечания по самому тексту ==

* Коммент в разделе [[Введение, или краткий обзор#Здравствуй, мир!]]
* [[Классы и объекты#Смотри также]]
* [[Объявление переменных и констант#Смотри также]]
* [[Стандартные типы данных#Указатели]]

* Предупреждение в разделе [[Функции#Перегрузка функций и операторов]]

== TODO компилятора ==

* Возможность объявлять класс до его реализации, аналогично forward declarations функций

== Перевод контента на английский язык ==
<source lang="kpp" line="0">
<random> книжку про К++ переводить?
<Raw_mat> переводи
<dk> ну там по идее поменяется много чего
<dk> потому что она уже малость устарела по сравнению с текущей версией языка
<dk> я бы лучше сказал что надо переводить все что осталось непереведенное из блогов/статей
<dk> уже книжкой стал? | эмм в смысле?
<random> надо план перевода чтобы кто-то координировал (Рав?) именно чтобы переводить то что надо в первую очередь и чтоб оно не менялось
<dk> вообще по хорошему надо не только переводить. А огранизовать процесс по английской версии сайта
<dk> то есть м/б написать какой то материал, который был бы необходим именно там, с учетом на западную аудиторию
<Raw_mat> ранд, переведи интерфейс сайта на европейские языки
<Raw_mat> а еще лучше на китайский или япошский
<random> еще надо определиться как в вики переводные статьи оформлять (шаблон названия и связь с тегом "язык")
<random> могу токо на англиский пока
<Raw_mat> разные поддомены вики языковые
<Raw_mat> какна википедии
<random> я к тому что в ман вики вроде нету яз разделов надо создать тогда можно будет каждому выбирать и переводить, но так чтобы не было разнобоя
<random> и потом корв правильно сказал надо чтоб кто-то организовывал в целом английский имидж сайта с учетом особенностей аудитории
</source>

= Main page =
== Informatoion ==

* [[About this project]]
* [[Deeptown SDK]]
* [[Tasks|Current tasks]]
* [[Bugzilla]]
* [[Our Spam]]
* [[Release Notes]]
* [[Feedback]]

== Docs ==

* [[K++]]
* [[World Engine]]
* [[Gide Platform]]
* [[gide standard lib]]
* [[Tutorials & HOWTO's]]
* [[Building and running from source]]
* [[Tips & Tricks]]

Заглавная страница

2009-10-28T06:25:03Z

Korvin: Защищена страница «Заглавная страница» ([edit=sysop] (бессрочно) [move=sysop] (бессрочно))

== Информация ==

* [[О проекте]]
* [[Deeptown SDK]]
* [[Deptown Programming Contest (DPC)]]
* [[Задачи|Текущие задачи]]
* [[Bugzilla]]
* [[Рассылка]]
* [[Release Notes]]
* [[Обратная связь]]

== Документация ==

* [[K++]]
* [[World Engine]]
* [[Платформа Gide]]
* [[Стандартная библиотека gide]]
* [[Туториалы и HOWTO]]
* [[Building and running from source]]
* [[Советы и подсказки]]
* [[Coreutils library]]

Обработка исключений

2009-10-28T05:32:49Z

Korvin:

Как уже было отмечено во [[Идеология языка#Понятие исключения|введении]], исключения — это мощный механизм, позволяющий в разы сократить время, требуемое на написание программ и значительно повысить их качество. В основном, это достигается за счет того что, программист пишет более простой код, не отвлекаясь от основной задачи на разного рода рутинные операции, вроде обработки ошибок, а значит, его внимание сконцентрировано на самой проблеме. В итоге, это приводит к написанию более качественного кода. В этой главе будет рассмотрена сущность механизма исключений, а так же способы их применения на практике. Будут даны типовые схемы разработки программ и даны соответствующие пояснения.

== Идеология исключений ==

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

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

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

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

В некоторых местах, где заранее предусматривается возможность проявления ошибки (например при открытии файла), вставляется специальная конструкция исключения. Она состоит из основного блока и одного или нескольких блоков — перехватчиков исключений. Выглядит эта конструкция так:
<source lang="kpp">
try {
/* try-блок (основное тело) */
} catch (/* переменная для объекта исключения 1 */) {
/* код перехватчика 1 */
} catch (/* переменная для объекта исключения 2 */) {
/* код перехватчика 2 */
}
</source>

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

== Объект исключения ==

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

== Генерация исключения ==

Код, который первым обнаруживает исключительную ситуацию (то есть, стоит у ее истоков) и желающий сообщить о ней "наверх", должен создать объект исключения и "выбросить" его. Создается объект так же, как и любой другой объект в языке К++: либо с помощью оператора <tt>'''new'''</tt>, либо с помощью [[Классы и объекты#Конструкторы|конструктора]] (если он предусмотрен). "Выбрасывание" объекта осуществляется с помощью специального оператора <tt>'''throw'''</tt>, который принимает объект в качестве параметра. Обычно, эти операции совмещают в одном действии.

Приведем пример некоторой функции, которая проверяет правильность передаваемых ей данных и выбрасывает исключение в случае несоответствия:
<source lang="kpp">
function Process(const int idx) {
if (! idx in 5 .. 10)
throw "индекс должен быть в диапазоне от 5 до 10";
/* нормальный код обработки */
}
</source>

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

На практике применяются специальные классы распространенных исключений, которые объявлены в [[Стандартная библиотека Gide|стандартной библиотеке]]. Таким образом, все языки использующие стандартную библиотеку и умеющие работать с исключениями, смогут успешно взаимодействовать с помощью этого механизма.

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

::{| width=60%
| <tt>EInvalidCall</tt> || неверный вызов (входные данные неверны)
|-
| <tt>EFailed</tt> || операция не удалась (и все тут)
|-
| <tt>EAagain</tt> || по тем или иным причинам требуется повтор операции
|-
| <tt>EDenied </tt> || действие запрещено!
|-
| <tt>ECancelled </tt> || операция была отменена (например пользователем)
|-
| <tt>EAlready</tt> || операция уже была выполнена
|-
| <tt>ERangeError</tt> || ошибка диапазона (выход значения за допустимые границы)
|-
| <tt>EDivisionByZero</tt> || арифметическая ошибка деления на ноль
|-
| <tt>ETimeout </tt> || истекло время ожидания чего-либо
|-
| <tt>EStreamError</tt> || ошибка [[потока]]
|-
| <tt>ERegexpError</tt> || ошибка при разборе [[регулярного выражения]]
|-
| <tt>EAbstractError</tt> || попытка вызова [[Классы и объекты#Методы|абстрактного метода]]
|}

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

Например, в описанном выше случае, наиболее подходящим классом ошибки будет <tt>ERangeError</tt>. Соответственно, код генерации ошибки можно написать так:
<source lang="kpp">
throw ERangeError.create("индекс должен быть в диапазоне от 5 до 10");
</source>

== Перехват исключений ==

Для обработки возникающих исключений используется конструкция перехвата. Она начинается с ключевого слова <tt>'''catch'''</tt>, следом за которым, в круглых скобках, идет описание переменной исключения, а затем, собственно, блок обработчика. Например, так мог бы выглядеть код вызова вышеописанной функции <tt>Process()</tt> и обработки возникающего исключения, если бы оно имело место:
<source lang=kpp>
try {
Process(/*выражение задающее индекс*/);
/* другой код */
} catch (e) {
print("Ошибка обработки индекса. #{e.name}: #{e.description}\n");
/* код обработки исключения */
}
</source>

Для того чтобы сослаться на объект исключения используется переменная ''e''. Все системные классы исключений имеют свойства <tt>name</tt> и <tt>description</tt>. Первое содержит имя исключения, а второе — описание ошибки.

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

<source lang=kpp>
try {
/* защищаемый код */
} catch (/*класс 1*/ /*имя объекта 1*/) {
/* код обработки исключения 1 */
} catch (/*класс 2*/ /*имя объекта 2*/) {
/* код обработки исключения 2 */
...
}
</source>

Таким образом, при объявлении переменной исключения, мы можем указывать ее тип и потом ссылаться на
специфические поля объектов, соответствущих этому типу:
<source lang=kpp>
try {
/* защищаемый код */
} catch (EAgain e) {
/* запрос у пользователя на повторение операции */
} catch (ERangeError e) {
/* отображение ошибки */
} catch (e) {
/* запись в лог файл */
}
</source>

В вышеприведенном коде используются три обработчика исключений: первые два перехватывают исключения определенного типа, а третий — все оставшиеся. Структура обработчиков исключений чем-то напоминает конструкцию <tt>'''[[Основные синтаксические конструкции#Оператор множественного выбора (switch)|switch]]'''</tt>.

'''Примечание 1:''' следует помнить, что правильность разбора исключений по классам, зависит от очередности расположения блоков перехватчиков в конструкции. При перехвате исключения выбор обработчика происходит по принципу первого совпадения, при котором проверяется, имеет ли объект исключения в своей иерархии класс, указанный в перехватчике. Если скажем, перехватчик <tt>'''catch''' (e)</tt> будет указан первым, то он и будет собирать все исключения, поскольку он сработает на любой класс объекта исключения. Вообще, нужно стараться располагать перехватчики по убыванию степени абстракции — от пользовательских классов до системных и далее, до общего перехватчика.

== Ловить или не ловить? ==

Блоки перехвата исключений должны вставляться только в тех местах, где вы точно знаете, как надо поступить при возникновении исключения. Если такой уверенности нет — смело пропускайте исключение "мимо ушей". Рано или поздно оно будет словлено там, где программа располагает бо́льшими сведениями относительно дальнейшей модели поведения.

То есть, не стоит ловить исключение только потому что это можно сделать. Смысл всей технологии в том, что ошибки обрабатываются в тех местах, где их можно исправить. 
== Исключения и работа с ресурсами ==

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

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

Разумеется, грамотно написанная программа должна освобождать ресурсы как можно быстрее (не путать с обычными объектами). Обычно это осуществляется вызовом специального unmanaged метода, который и производит все необходимые манипуляции на низком уровне. Тогда код работы с ресурсом может выглядеть как-то так:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
resource.bla(bla); // работаем с ресурсом
foo(resource);
//...
resource.release(); // освобождаем ресурс
</source>

В приведенном выше примере, метод <tt>release()</tt> является финализатором, который освобождает ресурс. Логическая ошибка такого кода в том, что он будет корректно рабоать только в случае нормальной работы программы. В случае если код работы с ресурсом возбудит исключение, управление будет передано "наверх" минуя оставшуюся часть кода, в том числе и оператор финализации. В результате, ассоциированные с этим блоком кода ресурсы не будут освобождены тогда, когда этого хотелось разработчику.

В принципе, можно попробовать схитрить и обернуть данный код в <tt>'''try'''</tt> блок, а в блоке перехвата исключений проводить принудительную финализацию ресурса. Тогда код будет выглядеть как-то так:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
try {
resource.bla(bla); // работаем с ресурсом
foo(resource);
//...
resource.release(); // освобождаем ресурс
} catch (Exception e) {
resource.release(); // освобождаем ресурс
throw e; // вторично выбрасываем исключение
}
</source>

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

Для того чтобы сказать компилятору, что некоторый код необходимо выполнить в любом случае, независимо от того что произошло выше, необходимо использовать ключевое слово <tt>'''ensure'''</tt>. Тогда вышеприведенный код примет следующий вид:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
try {
resource.bla(bla); // работаем с ресурсом
foo(resource);
// ...
} ensure {
resource.release(); // освобождаем ресурс
}
</source>

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

Конструкция работает следующим образом: сначала вызвается инициализатор ресурса, то есть первая строка. Затем управление передается в защищаемый блок. Если все прошло гладко и исключений выброшено не было, то после защищаемого блока вызывается <tt>'''ensure'''</tt> блок а затем управление передается дальше по коду.

Если же где то в защищаемом коде было выброшено исключение, управление сперва передается в <tt>'''ensure'''</tt> блок, а потом выброшенное исключение передается "наверх"; то есть управление будет переданно ближайшему <tt>'''catch'''</tt> блоку, способному обработать данный класс исключений. Самое главное заключается в том, что освобождение ресурса гарантируется в любом случае.

Обработка исключений

2009-10-28T04:54:29Z

Korvin: /* Исключения и работа с ресурсами */

Как уже было отмечено во [[Идеология языка#Понятие исключения|введении]], исключения — это мощный механизм, позволяющий в разы сократить время, требуемое на написание программ и значительно повысить их качество. В основном, это достигается за счет того что, программист пишет более простой код, не отвлекаясь от основной задачи на разного рода рутинные операции, вроде обработки ошибок, а значит, его внимание сконцентрировано на самой проблеме. В итоге, это приводит к написанию более качественного кода. В этой главе будет рассмотрена сущность механизма исключений, а так же способы их применения на практике. Будут даны типовые схемы разработки программ и даны соответствующие пояснения.

== Идеология исключений ==

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

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

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

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

В некоторых местах, где заранее предусматривается возможность проявления ошибки (например при открытии файла), вставляется специальная конструкция исключения. Она состоит из основного блока и одного или нескольких блоков — перехватчиков исключений. Выглядит эта конструкция так:
<source lang="kpp">
try {
/* try-блок (основное тело) */
} catch (/* переменная для объекта исключения 1 */) {
/* код перехватчика 1 */
} catch (/* переменная для объекта исключения 2 */) {
/* код перехватчика 2 */
}
</source>

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

== Объект исключения ==

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

== Генерация исключения ==

Код, который первым обнаруживает исключительную ситуацию (то есть, стоит у ее истоков) и желающий сообщить о ней "наверх", должен создать объект исключения и "выбросить" его. Создается объект так же, как и любой другой объект в языке К++: либо с помощью оператора <tt>'''new'''</tt>, либо с помощью [[Классы и объекты#Конструкторы|конструктора]] (если он предусмотрен). "Выбрасывание" объекта осуществляется с помощью специального оператора <tt>'''throw'''</tt>, который принимает объект в качестве параметра. Обычно, эти операции совмещают в одном действии.

Приведем пример некоторой функции, которая проверяет правильность передаваемых ей данных и выбрасывает исключение в случае несоответствия:
<source lang="kpp">
function Process(const int idx) {
if (! idx in 5 .. 10)
throw "индекс должен быть в диапазоне от 5 до 10";
/* нормальный код обработки */
}
</source>

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

На практике применяются специальные классы распространенных исключений, которые объявлены в [[Стандартная библиотека Gide|стандартной библиотеке]]. Таким образом, все языки использующие стандартную библиотеку и умеющие работать с исключениями, смогут успешно взаимодействовать с помощью этого механизма.

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

::{| width=60%
| <tt>EInvalidCall</tt> || неверный вызов (входные данные неверны)
|-
| <tt>EFailed</tt> || операция не удалась (и все тут)
|-
| <tt>EAagain</tt> || по тем или иным причинам требуется повтор операции
|-
| <tt>EDenied </tt> || действие запрещено!
|-
| <tt>ECancelled </tt> || операция была отменена (например пользователем)
|-
| <tt>EAlready</tt> || операция уже была выполнена
|-
| <tt>ERangeError</tt> || ошибка диапазона (выход значения за допустимые границы)
|-
| <tt>EDivisionByZero</tt> || арифметическая ошибка деления на ноль
|-
| <tt>ETimeout </tt> || истекло время ожидания чего-либо
|-
| <tt>EStreamError</tt> || ошибка [[потока]]
|-
| <tt>ERegexpError</tt> || ошибка при разборе [[регулярного выражения]]
|-
| <tt>EAbstractError</tt> || попытка вызова [[Классы и объекты#Методы|абстрактного метода]]
|}

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

Например, в описанном выше случае, наиболее подходящим классом ошибки будет <tt>ERangeError</tt>. Соответственно, код генерации ошибки можно написать так:
<source lang="kpp">
throw ERangeError.create("индекс должен быть в диапазоне от 5 до 10");
</source>

== Перехват исключений ==

Для обработки возникающих исключений используется конструкция перехвата. Она начинается с ключевого слова <tt>'''catch'''</tt>, следом за которым, в круглых скобках, идет описание переменной исключения, а затем, собственно, блок обработчика. Например, так мог бы выглядеть код вызова вышеописанной функции <tt>Process()</tt> и обработки возникающего исключения, если бы оно имело место:
<source lang=kpp>
try {
Process(/*выражение задающее индекс*/);
/* другой код */
} catch (e) {
print("Ошибка обработки индекса. #{e.name}: #{e.description}\n");
/* код обработки исключения */
}
</source>

Для того чтобы сослаться на объект исключения используется переменная ''e''. Все системные классы исключений имеют свойства <tt>name</tt> и <tt>description</tt>. Первое содержит имя исключения, а второе — описание ошибки.

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

<source lang=kpp>
try {
/* защищаемый код */
} catch (/*класс 1*/ /*имя объекта 1*/) {
/* код обработки исключения 1 */
} catch (/*класс 2*/ /*имя объекта 2*/) {
/* код обработки исключения 2 */
...
}
</source>

Таким образом, при объявлении переменной исключения, мы можем указывать ее тип и потом ссылаться на
специфические поля объектов, соответствущих этому типу:
<source lang=kpp>
try {
/* защищаемый код */
} catch (EAgain e) {
/* запрос у пользователя на повторение операции */
} catch (ERangeError e) {
/* отображение ошибки */
} catch (e) {
/* запись в лог файл */
}
</source>

В вышеприведенном коде используются три обработчика исключений: первые два перехватывают исключения определенного типа, а третий — все оставшиеся. Структура обработчиков исключений чем-то напоминает конструкцию <tt>'''[[Основные синтаксические конструкции#Оператор множественного выбора (switch)|switch]]'''</tt>.

'''Примечание 1:''' следует помнить, что правильность разбора исключений по классам, зависит от очередности расположения блоков перехватчиков в конструкции. При перехвате исключения выбор обработчика происходит по принципу первого совпадения, при котором проверяется, имеет ли объект исключения в своей иерархии класс, указанный в перехватчике. Если скажем, перехватчик <tt>'''catch''' (e)</tt> будет указан первым, то он и будет собирать все исключения, поскольку он сработает на любой класс объекта исключения. Вообще, нужно стараться располагать перехватчики по убыванию степени абстракции — от пользовательских классов до системных и далее, до общего перехватчика.

== Исключения и работа с ресурсами ==

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

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

Разумеется, грамотно написанная программа должна освобождать ресурсы как можно быстрее (не путать с обычными объектами). Обычно это осуществляется вызовом специального unmanaged метода, который и производит все необходимые манипуляции на низком уровне. Тогда код работы с ресурсом может выглядеть как-то так:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
resource.bla(bla); // работаем с ресурсом
foo(resource);
//...
resource.release(); // освобождаем ресурс
</source>

В приведенном выше примере, метод <tt>release()</tt> является финализатором, который освобождает ресурс. Логическая ошибка такого кода в том, что он будет корректно рабоать только в случае нормальной работы программы. В случае если код работы с ресурсом возбудит исключение, управление будет передано "наверх" минуя оставшуюся часть кода, в том числе и оператор финализации. В результате, ассоциированные с этим блоком кода ресурсы не будут освобождены тогда, когда этого хотелось разработчику.

В принципе, можно попробовать схитрить и обернуть данный код в <tt>'''try'''</tt> блок, а в блоке перехвата исключений проводить принудительную финализацию ресурса. Тогда код будет выглядеть как-то так:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
try {
resource.bla(bla); // работаем с ресурсом
foo(resource);
//...
resource.release(); // освобождаем ресурс
} catch (Exception e) {
resource.release(); // освобождаем ресурс
throw e; // вторично выбрасываем исключение
}
</source>

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

Для того чтобы сказать компилятору, что некоторый код необходимо выполнить в любом случае, независимо от того что произошло выше, необходимо использовать ключевое слово <tt>'''ensure'''</tt>. Тогда вышеприведенный код примет следующий вид:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
try {
resource.bla(bla); // работаем с ресурсом
foo(resource);
// ...
} ensure {
resource.release(); // освобождаем ресурс
}
</source>

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

Конструкция работает следующим образом: сначала вызвается инициализатор ресурса, то есть первая строка. Затем управление передается в защищаемый блок. Если все прошло гладко и исключений выброшено не было, то после защищаемого блока вызывается <tt>'''ensure'''</tt> блок а затем управление передается дальше по коду.

Если же где то в защищаемом коде было выброшено исключение, управление сперва передается в <tt>'''ensure'''</tt> блок, а потом выброшенное исключение передается "наверх"; то есть управление будет переданно ближайшему <tt>'''catch'''</tt> блоку, способному обработать данный класс исключений. Самое главное заключается в том, что освобождение ресурса гарантируется в любом случае.

== Ловить или не ловить? ==

Блоки перехвата исключений должны вставляться только в тех местах, где вы точно знаете, как надо поступить при возникновении исключения. Если такой уверенности нет — смело пропускайте исключение "мимо ушей". Рано или поздно оно будет словлено там, где программа располагает бо́льшими сведениями относительно дальнейшей модели поведения.

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

Обработка исключений

2009-10-28T04:45:44Z

Korvin: /* Ловить или не ловить? */

Как уже было отмечено во [[Идеология языка#Понятие исключения|введении]], исключения — это мощный механизм, позволяющий в разы сократить время, требуемое на написание программ и значительно повысить их качество. В основном, это достигается за счет того что, программист пишет более простой код, не отвлекаясь от основной задачи на разного рода рутинные операции, вроде обработки ошибок, а значит, его внимание сконцентрировано на самой проблеме. В итоге, это приводит к написанию более качественного кода. В этой главе будет рассмотрена сущность механизма исключений, а так же способы их применения на практике. Будут даны типовые схемы разработки программ и даны соответствующие пояснения.

== Идеология исключений ==

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

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

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

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

В некоторых местах, где заранее предусматривается возможность проявления ошибки (например при открытии файла), вставляется специальная конструкция исключения. Она состоит из основного блока и одного или нескольких блоков — перехватчиков исключений. Выглядит эта конструкция так:
<source lang="kpp">
try {
/* try-блок (основное тело) */
} catch (/* переменная для объекта исключения 1 */) {
/* код перехватчика 1 */
} catch (/* переменная для объекта исключения 2 */) {
/* код перехватчика 2 */
}
</source>

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

== Объект исключения ==

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

== Генерация исключения ==

Код, который первым обнаруживает исключительную ситуацию (то есть, стоит у ее истоков) и желающий сообщить о ней "наверх", должен создать объект исключения и "выбросить" его. Создается объект так же, как и любой другой объект в языке К++: либо с помощью оператора <tt>'''new'''</tt>, либо с помощью [[Классы и объекты#Конструкторы|конструктора]] (если он предусмотрен). "Выбрасывание" объекта осуществляется с помощью специального оператора <tt>'''throw'''</tt>, который принимает объект в качестве параметра. Обычно, эти операции совмещают в одном действии.

Приведем пример некоторой функции, которая проверяет правильность передаваемых ей данных и выбрасывает исключение в случае несоответствия:
<source lang="kpp">
function Process(const int idx) {
if (! idx in 5 .. 10)
throw "индекс должен быть в диапазоне от 5 до 10";
/* нормальный код обработки */
}
</source>

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

На практике применяются специальные классы распространенных исключений, которые объявлены в [[Стандартная библиотека Gide|стандартной библиотеке]]. Таким образом, все языки использующие стандартную библиотеку и умеющие работать с исключениями, смогут успешно взаимодействовать с помощью этого механизма.

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

::{| width=60%
| <tt>EInvalidCall</tt> || неверный вызов (входные данные неверны)
|-
| <tt>EFailed</tt> || операция не удалась (и все тут)
|-
| <tt>EAagain</tt> || по тем или иным причинам требуется повтор операции
|-
| <tt>EDenied </tt> || действие запрещено!
|-
| <tt>ECancelled </tt> || операция была отменена (например пользователем)
|-
| <tt>EAlready</tt> || операция уже была выполнена
|-
| <tt>ERangeError</tt> || ошибка диапазона (выход значения за допустимые границы)
|-
| <tt>EDivisionByZero</tt> || арифметическая ошибка деления на ноль
|-
| <tt>ETimeout </tt> || истекло время ожидания чего-либо
|-
| <tt>EStreamError</tt> || ошибка [[потока]]
|-
| <tt>ERegexpError</tt> || ошибка при разборе [[регулярного выражения]]
|-
| <tt>EAbstractError</tt> || попытка вызова [[Классы и объекты#Методы|абстрактного метода]]
|}

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

Например, в описанном выше случае, наиболее подходящим классом ошибки будет <tt>ERangeError</tt>. Соответственно, код генерации ошибки можно написать так:
<source lang="kpp">
throw ERangeError.create("индекс должен быть в диапазоне от 5 до 10");
</source>

== Перехват исключений ==

Для обработки возникающих исключений используется конструкция перехвата. Она начинается с ключевого слова <tt>'''catch'''</tt>, следом за которым, в круглых скобках, идет описание переменной исключения, а затем, собственно, блок обработчика. Например, так мог бы выглядеть код вызова вышеописанной функции <tt>Process()</tt> и обработки возникающего исключения, если бы оно имело место:
<source lang=kpp>
try {
Process(/*выражение задающее индекс*/);
/* другой код */
} catch (e) {
print("Ошибка обработки индекса. #{e.name}: #{e.description}\n");
/* код обработки исключения */
}
</source>

Для того чтобы сослаться на объект исключения используется переменная ''e''. Все системные классы исключений имеют свойства <tt>name</tt> и <tt>description</tt>. Первое содержит имя исключения, а второе — описание ошибки.

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

<source lang=kpp>
try {
/* защищаемый код */
} catch (/*класс 1*/ /*имя объекта 1*/) {
/* код обработки исключения 1 */
} catch (/*класс 2*/ /*имя объекта 2*/) {
/* код обработки исключения 2 */
...
}
</source>

Таким образом, при объявлении переменной исключения, мы можем указывать ее тип и потом ссылаться на
специфические поля объектов, соответствущих этому типу:
<source lang=kpp>
try {
/* защищаемый код */
} catch (EAgain e) {
/* запрос у пользователя на повторение операции */
} catch (ERangeError e) {
/* отображение ошибки */
} catch (e) {
/* запись в лог файл */
}
</source>

В вышеприведенном коде используются три обработчика исключений: первые два перехватывают исключения определенного типа, а третий — все оставшиеся. Структура обработчиков исключений чем-то напоминает конструкцию <tt>'''[[Основные синтаксические конструкции#Оператор множественного выбора (switch)|switch]]'''</tt>.

'''Примечание 1:''' следует помнить, что правильность разбора исключений по классам, зависит от очередности расположения блоков перехватчиков в конструкции. При перехвате исключения выбор обработчика происходит по принципу первого совпадения, при котором проверяется, имеет ли объект исключения в своей иерархии класс, указанный в перехватчике. Если скажем, перехватчик <tt>'''catch''' (e)</tt> будет указан первым, то он и будет собирать все исключения, поскольку он сработает на любой класс объекта исключения. Вообще, нужно стараться располагать перехватчики по убыванию степени абстракции — от пользовательских классов до системных и далее, до общего перехватчика.

== Исключения и работа с ресурсами ==

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

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

Разумеется, грамотно написанная программа должна освобождать ресурсы как можно быстрее (не путать с обычными объектами). Обычно это осуществляется вызовом специального unmanaged метода, который и производит все необходимые манипуляции на низком уровне. Тогда код работы с ресурсом может выглядеть как-то так:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
resource.bla(bla); // работаем с ресурсом
foo(resource);
//...
resource.release(); // освобождаем ресурс
</source>

В приведенном выше примере, метод <tt>release()</tt> является финализатором, который освобождает ресурс. Логическая ошибка такого кода в том, что он будет корректно рабоать только в случае нормальной работы программы. В случае если код работы с ресурсом возбудит исключение, управление будет передано "наверх" минуя оставшуюся часть кода, в том числе и оператор финализации. В результате, ассоциированные с этим блоком кода ресурсы не будут освобождены тогда, когда это хотелось разработчику.

Разумеется, можно попробовать схитрить и обернуть данный код в <tt>'''try'''</tt> блок, а в блоке перехвата исключений проводить принудительную финализацию ресурса. Тогда код будет выглядеть как-то так:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
try {
resource.bla(bla);
foo(resource); // работаем с ресурсом
//...
resource.release(); // освобождаем ресурс
} catch (Exception e) {
resource.release(); // освобождаем ресурс
throw e; // вторично выбрасываем исключение
}
</source>

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

Для того чтобы сказать компилятору, что некоторый код необходимо выполнить в любом случае, независимо от того что произошло выше, необходимо использовать ключевое слово <tt>'''ensure'''</tt>. Тогда вышеприведенный код примет следующий вид:
<source lang="kpp">
var resource = MyResource.open("some initial data"); // создаем ресурс
try {
resource.bla(bla); // работаем с ресурсом
foo(resource);
// ...
} ensure {
resource.release(); // освобождаем ресурс
}
</source>

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

Конструкция работает следующим образом: сначала вызвается инициализатор ресурса, то есть первая строка. Затем управление передается в защищаемый блок. Если все прошло гладко и исключений выброшено не было, то после защищаемого блока вызывается <tt>'''ensure'''</tt> блок а затем управление передается дальше по коду.

Если же где то в защищаемом коде было выброшено исключение, управление сперва передается в <tt>'''ensure'''</tt> блок, а потом выброшенное исключение передается "наверх"; то есть управление будет переданно ближайшему <tt>'''catch'''</tt> блоку, способному обработать данный класс исключений. Самое главное заключается в том, что освобождение ресурса гарантируется в любом случае.

== Ловить или не ловить? ==

Блоки перехвата исключений должны вставляться только в тех местах, где вы точно знаете, как надо поступить при возникновении исключения. Если такой уверенности нет — смело пропускайте исключение "мимо ушей". Рано или поздно оно будет словлено там, где программа располагает бо́льшими сведениями относительно дальнейшей модели поведения.

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

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

2009-10-26T17:13:46Z

Korvin: /* Абстрактные методы */

__TOC__

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
class MyWeirdClass {
var m_x = 0; // поле m_x, изначально проинициализированное нулем
const m_y = 1; // поле-константа m_y

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

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

;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
// коробка
class Box {
// из чего сделана коробка?
public const function string material() { return "Картон"; }

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

// коробка с картошкой
class BoxWithPotatoes extends Box {
public const function string contents() { return "Картошка"; }
}

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

export function main() {
var b1 = new Box;
var b2 = new BoxWithPotatoes;
OutputBox(b1); // Материал: Картон, содержит: Пусто
OutputBox(b2); // Материал: Картон, содержит: Картошка
}
</source>

;2-8: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.

;11-13: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.

;15-17: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).

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

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

== Методы ==

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

При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)
* <tt>'''const'''</tt> — метод не изменяет объект
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять

После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].

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

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

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

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

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

Пример:
<source lang="kpp">
class MyClass {
public static function string Info() { return "Я MyClass!"; }
}

function f() {
// Вызов статического метода:
var myClassInfo = MyClass.Info();
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp">
/* Примесь Enumerable предоставляет классам коллекций несколько методов для итерации по элементам,
выбору, поиску и возможности сортировки.

Класс испольщующий примесь должен объявить у себя метод each(),
который вызывает переданный блок последовательно передавая ему элементы коллекции

Если требуется использовать методы Enumerable::max, min или алгоритм сортировки, то необходимо
также реализовать соответствующий метод compare() */

var identity_block = { |x| x; };

class Enumerable {
public:
abstract const function each(block b);
abstract const function int compare(const x);

const function bool all(block b = identity_block) {
var result = true;
this.each() { |...|
if (!b.invoke(args())) {
result = false;
break;
}
};
return result;
}

// Другие методы примеси
}
</source>

== Поля ==

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

Объявление поля начинается с одного из трех ключевых слов:
* <tt>'''var'''</tt> — объявление "обычного" поля;
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.

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

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

Тип поля определяется по следующим правилам:
* если тип указан явно, ничего определять не надо;
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

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

== Свойства ==

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

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

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

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

<source lang="cpp">
class MyDevice {
int GetState();
};
</source>

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

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

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

<source lang="kpp">
class MyDevice {
function int GetState();
property int state read GetState;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

----

В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства.

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

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

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

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

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

<source lang="kpp">
class MyClass {
var f = 1;
property int read { f + 1; } write { |v| f = v; };
}
</source>

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

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

== Расширения ==

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

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

В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:

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

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

export function main() {
puts("Factorial of 10 is " + 10.factorial);
}
</source>

;3-11: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.

;14: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. 

: Обратите внимание, что функция <tt>puts()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. В этом нет ничего странного, потому что класс <tt>int</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt>, передается в качестве параметра функции.

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



== Смотри также ==

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

2009-10-26T17:12:48Z

Korvin: /* Абстрактные методы */

__TOC__

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
class MyWeirdClass {
var m_x = 0; // поле m_x, изначально проинициализированное нулем
const m_y = 1; // поле-константа m_y

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

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

;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
// коробка
class Box {
// из чего сделана коробка?
public const function string material() { return "Картон"; }

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

// коробка с картошкой
class BoxWithPotatoes extends Box {
public const function string contents() { return "Картошка"; }
}

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

export function main() {
var b1 = new Box;
var b2 = new BoxWithPotatoes;
OutputBox(b1); // Материал: Картон, содержит: Пусто
OutputBox(b2); // Материал: Картон, содержит: Картошка
}
</source>

;2-8: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.

;11-13: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.

;15-17: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).

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

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

== Методы ==

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

При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)
* <tt>'''const'''</tt> — метод не изменяет объект
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять

После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].

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

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

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

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

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

Пример:
<source lang="kpp">
class MyClass {
public static function string Info() { return "Я MyClass!"; }
}

function f() {
// Вызов статического метода:
var myClassInfo = MyClass.Info();
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp">
/* Примесь Enumerable предоставляет классам коллекций несколько методов для итерации по элементам,
выбору, поиску и возможности сортировки.

Класс испольщующий примесь должен объявить у себя метод each(),
который вызывает переданный блок последовательно передавая ему элементы коллекции

Если требуется использовать методы Enumerable::max, min или алгоритм сортировки, то необходимо
также реализовать соответствующий метод compare() */

var identity_block = { |x| x; };

class Enumerable {
public:
abstract const function each(block b);
abstract const function int compare(const x);

const function bool all(block b = identity_block) {
var result = true;
this.each() { |...|
if (!b.invoke(args())) {
result = false;
break;
}
};
return result;
}

// Другие методы примеси
}
</code>

== Поля ==

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

Объявление поля начинается с одного из трех ключевых слов:
* <tt>'''var'''</tt> — объявление "обычного" поля;
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.

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

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

Тип поля определяется по следующим правилам:
* если тип указан явно, ничего определять не надо;
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

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

== Свойства ==

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

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

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

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

<source lang="cpp">
class MyDevice {
int GetState();
};
</source>

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

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

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

<source lang="kpp">
class MyDevice {
function int GetState();
property int state read GetState;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

----

В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства.

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

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

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

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

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

<source lang="kpp">
class MyClass {
var f = 1;
property int read { f + 1; } write { |v| f = v; };
}
</source>

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

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

== Расширения ==

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

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

В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:

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

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

export function main() {
puts("Factorial of 10 is " + 10.factorial);
}
</source>

;3-11: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.

;14: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. 

: Обратите внимание, что функция <tt>puts()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. В этом нет ничего странного, потому что класс <tt>int</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt>, передается в качестве параметра функции.

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



== Смотри также ==

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

2009-10-26T11:40:47Z

Korvin: /* Абстрактные методы */

__TOC__

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
class MyWeirdClass {
var m_x = 0; // поле m_x, изначально проинициализированное нулем
const m_y = 1; // поле-константа m_y

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

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

;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
// коробка
class Box {
// из чего сделана коробка?
public const function string material() { return "Картон"; }

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

// коробка с картошкой
class BoxWithPotatoes extends Box {
public const function string contents() { return "Картошка"; }
}

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

export function main() {
var b1 = new Box;
var b2 = new BoxWithPotatoes;
OutputBox(b1); // Материал: Картон, содержит: Пусто
OutputBox(b2); // Материал: Картон, содержит: Картошка
}
</source>

;2-8: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.

;11-13: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.

;15-17: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).

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

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

== Методы ==

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

При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)
* <tt>'''const'''</tt> — метод не изменяет объект
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять

После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].

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

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

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

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

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

Пример:
<source lang="kpp">
class MyClass {
public static function string Info() { return "Я MyClass!"; }
}

function f() {
// Вызов статического метода:
var myClassInfo = MyClass.Info();
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание: Использование в примесях

== Поля ==

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

Объявление поля начинается с одного из трех ключевых слов:
* <tt>'''var'''</tt> — объявление "обычного" поля;
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.

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

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

Тип поля определяется по следующим правилам:
* если тип указан явно, ничего определять не надо;
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

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

== Свойства ==

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

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

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

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

<source lang="cpp">
class MyDevice {
int GetState();
};
</source>

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

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

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

<source lang="kpp">
class MyDevice {
function int GetState();
property int state read GetState;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

----

В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства.

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

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

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

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

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

<source lang="kpp">
class MyClass {
var f = 1;
property int read { f + 1; } write { |v| f = v; };
}
</source>

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

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

== Расширения ==

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

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

В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:

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

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

export function main() {
puts("Factorial of 10 is " + 10.factorial);
}
</source>

;3-11: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.

;14: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. 

: Обратите внимание, что функция <tt>puts()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. В этом нет ничего странного, потому что класс <tt>int</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt>, передается в качестве параметра функции.

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



== Смотри также ==

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

2009-10-26T11:39:53Z

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

__TOC__

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Последним шагом к современному пониманию программ явились концепции [http://ru.wikipedia.org/wiki/Полиморфизм_(программирование) полиморфизма], [http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование) инкапсуляции] и [http://ru.wikipedia.org/wiki/Наследование_(программирование) наследования]. Не будем пока углубляться в суть этих понятий, отметим только, что их введение сформировало современное понимание объектно-ориентированного программирования.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
class MyWeirdClass {
var m_x = 0; // поле m_x, изначально проинициализированное нулем
const m_y = 1; // поле-константа m_y

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

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

;1: Как у любого нормального разумного существа, у класса есть "голова" и "тело". Ключевое слово <tt>'''class'''</tt> начинает объявление класса. Далее за ним следует [[идентификатор]] имени класса, после чего идет тело класса.

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

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

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

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

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

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

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

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

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

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

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

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

<source lang="kpp" line="1">
// коробка
class Box {
// из чего сделана коробка?
public const function string material() { return "Картон"; }

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

// коробка с картошкой
class BoxWithPotatoes extends Box {
public const function string contents() { return "Картошка"; }
}

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

export function main() {
var b1 = new Box;
var b2 = new BoxWithPotatoes;
OutputBox(b1); // Материал: Картон, содержит: Пусто
OutputBox(b2); // Материал: Картон, содержит: Картошка
}
</source>

;2-8: В этом примере мы создаем класс <tt>Box</tt>, который представляет собой некоторую коробку. Мы определяем ее свойства, такие как ''материал'' и ''содержимое''.

;11-13: Далее мы определяем класс <tt>BoxWithPotatoes</tt> (''коробка с картошкой''), который наследуется от класса <tt>Box</tt>, и тем самым заимствует свойства материала и содержимого, но первое он переопределяет (в случае методов это называется ''перекрытием'') собственным методом.

;15-17: Мы определяем некоторую [[Функции|функцию]] для работы с нашими классами, которая будет отображать их состояние. Заметьте, что в качестве [[Функции#Аргументы|аргумента функции]] передается экземпляр класса <tt>Box</tt>, то есть класса-родителя. При этом мы предполагаем, что любой класс, унаследованный от базового класса, будет обладать необходимым нам интерфейсом, а именно методами получения информации о свойствах (аксессорами мы их не называем, потому что они не связаны с конкретным полем; это было бы неверно).

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

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

== Методы ==

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

При объявлении метода могут быть указаны следующие ключевые слова, в указанном порядке:
* <tt>'''private'''</tt>, <tt>'''protected'''</tt> или <tt>'''public'''</tt> — определяют область видимости метода
* <tt>'''static'''</tt> — указывает, что метод является ''статическим'' (см. ниже)
* <tt>'''const'''</tt> — метод не изменяет объект
* <tt>'''function'''</tt>, <tt>'''operator'''</tt> или <tt>'''constructor'''</tt> указывает, что объявляется: ''метод'', ''[[Операторы|оператор]]'' или ''конструктор'' (см. ниже)
* <tt>'''const'''</tt> — метод возвращает результат, который нельзя изменять

После этого указывается тип, возвращаемый методом. Если он опущен — возвращается [[Переменные#Нетипированные (динамические) переменные|динамическая переменная]]; если вместо типа указано ключевое слово <tt>'''void'''</tt> — метод не возвращает результата. Следом за типом идет имя метода, затем — перечисление [[Функции#Аргументы|аргументов]] в скобках. Подробнее об объявлении функций и передаче параметров, можно прочитать в главе [[Функции]].

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

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

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

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

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

Пример:
<source lang="kpp">
class MyClass {
public static function string Info() { return "Я MyClass!"; }
}

function f() {
// Вызов статического метода:
var myClassInfo = MyClass.Info();
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание: Использование в примесях

== Поля ==

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

Объявление поля начинается с одного из трех ключевых слов:
* <tt>'''var'''</tt> — объявление "обычного" поля;
* <tt>'''const'''</tt> — данное поле является константой и не может быть изменено;
* <tt>'''mutable'''</tt> — значение данного поля не влияет на состояние объекта, и его можно менять даже в методах, объявленных константными.

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

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

Тип поля определяется по следующим правилам:
* если тип указан явно, ничего определять не надо;
* если тип не указан, но при объявлении использован инициализатор — типом становится тип результата инициализатора;
* в противном случае, для поля устанавливается [[Переменные#Нетипированные (динамические) переменные|динамический тип]].

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

== Свойства ==

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

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

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

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

<source lang="cpp">
class MyDevice {
int GetState();
};
</source>

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

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

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

<source lang="kpp">
class MyDevice {
function int GetState();
property int state read GetState;
}
</source>

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

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

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

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

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

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

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

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

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

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

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

----

В заключение, кратко опишем синтаксис объявления свойства и поясним его. Итак, объявление любого свойства начинается с указания ключевого слова <tt>'''property'''</tt>, после которого идет [[идентификатор]] типа свойства. Тип может быть опущен, тогда для свойства будет определен [[Переменные#Нетипированные (динамические) переменные|динамический тип]]. Затем указывается идентификатор имени свойства.

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

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

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

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

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

<source lang="kpp">
class MyClass {
var f = 1;
property int read { f + 1; } write { |v| f = v; };
}
</source>

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

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

== Расширения ==

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

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

В качестве примера приведем код, расширяющий функциональность класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt> с помощью свойства <tt>factorial</tt>. Расширения объявляются путем указания ключевого слова <tt>'''extend'''</tt>, после которого указывается [[идентификатор]] имени класса, который следует расширить. Затем идет тело расширения, такое же, как при описании классов:

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

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

export function main() {
puts("Factorial of 10 is " + 10.factorial);
}
</source>

;3-11: Мы объявляем расширение класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>, реализованного в [[Стандартная библиотека gide|стандартной библиотеке]]. Добавляется частный метод <tt>GetFactorial()</tt>, и свойство <tt>factorial</tt>, связанное с методом. Как видно из названия, метод рассчитывает факториал числа, которое содержится в объекте. В данном контексте, специальная переменная ''this'' имеет тип <tt>int</tt> и ссылается на сам объект. Таким образом, для числа 10 переменная ''this'' будет равна 10.

;14: Здесь мы видим применение расширения в действии. Константа 10 на момент компиляции преобразуется в [[Константы#Константные объекты|константный объект]] класса <tt>int</tt>, который подобно любому другому объекту этого же класса будет иметь свойство <tt>factorial</tt>, которое мы и используем. При попытке чтения из этого свойства будет вызван метод <tt>GetFactorial()</tt>, результат выполнения которого возвращается как значение свойства, то есть как факториал числа. 

: Обратите внимание, что функция <tt>puts()</tt>, принимает в качестве параметра [[Стандартные типы данных#Строки|строку]], в то время как тип свойства определен как <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. В этом нет ничего странного, потому что класс <tt>int</tt> имеет [[Типы операторов#Операторы приведения типов|оператор приведения типа]] к классу <tt>[[Стандартные типы данных#Строки|string]]</tt>, который вызывается компилятором автоматически. Таким образом, при вычислении значения выражения в скобках, сперва значение факториала ''приводится'' к типу строки, которая складываясь со строкой слева от оператора <tt>+</tt>, передается в качестве параметра функции.

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



== Смотри также ==

K++

2009-10-26T11:15:57Z

Korvin: /* Синтаксис языка */

__NOTOC__
[[Изображение:head.png]]

По мере разработки платформы Диптаун, нами была осознана необходимость создания удобного и универсального средства для управления платформой. Изначально, мы хотели реализовать ее так, чтобы платформа была максимально гибкой и расширяемой; чтобы она позволяла вносить изменения практически в любую ее часть без необходимости пересмотра и переработки системы в целом. Неотъемлемой частью существующей реализации является [[виртуальная машина Gide]], которая берет на себя большую часть задач по управлению различными частями платформы и организации их взаимодействия. Gide применяется практически во всех задачах: начиная от генерации процедурных текстур и до пользовательского интерфейса; от управления аватарами и до программирования объектов виртуального пространства.

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

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

Исключительными правами на язык К++ и на документацию к нему обладают его авторы. Копирование, распространение, а так же использование в других целях программ, текстов документации или любых их частей возможно только по письменному разрешению авторов.
* © Дмитрий Кашицын, 2007-2009
* © Дмитрий Роот, 2007-2009

== Введение ==

# [[Предисловие]]
## [[Предисловие#Роль K++ в проекте Диптаун|Роль K++ в проекте Диптаун]]
## [[Предисловие#Почему именно K++?|Почему именно K++?]]
## [[Предисловие#Для кого эта книга|Для кого эта книга]]
## [[Предисловие#Стиль изложения материала|Стиль изложения материала]]
## [[Предисловие#Тесная взаимосвязь с gide|Тесная взаимосвязь с gide]]
## [[Предисловие#Принятые обозначения|Принятые обозначения]]
# [[История создания языка]]
# [[Идеология языка]]
## [[Идеология языка#Немного теории о языках программирования|Немного теории о языках программирования]]
## [[Идеология языка#Компиляторы и интерпретаторы|Компиляторы и интерпретаторы]]
## [[Идеология языка#Парадигменность|Парадигменность]]
## [[Идеология языка#Понятие о типизации|Понятие о типизации]]
## [[Идеология языка#Управление памятью|Управление памятью]]
## [[Идеология языка#Понятие исключения|Понятие исключения]]

== Основы языка ==

# [[Введение, или краткий обзор]]
## [[Введение, или краткий обзор#Здравствуй, мир!|Здравствуй, мир!]]
## [[Введение, или краткий обзор#Более сложный пример|Более сложный пример]]
## [[Введение, или краткий обзор#Использование блоков|Использование блоков]]
## [[Введение, или краткий обзор#Расширение классов|Расширение классов]]
# [[Переменные]]
## [[Переменные#Понятие переменной, тип переменной|Понятие переменной, тип переменной]]
## [[Переменные#Статическая типизация на примере C++|Статическая типизация на примере C++]]
## [[Переменные#Динамическая типизация на примере Ruby|Динамическая типизация на примере Ruby]]
## [[Переменные#Полудинамическая типизация|Полудинамическая типизация]]
## [[Переменные#Типизация при объявлении|Типизация при объявлении]]
## [[Переменные#Типизация при инициализации|Типизация при инициализации]]
## [[Переменные#Нетипированные (динамические) переменные|Нетипированные (динамические) переменные]]
## [[Переменные#О важности инициализации переменных|О важности инициализации переменных]]
# [[Константы]]
## [[Константы#Понятие константы|Понятие константы]]
## [[Константы#Константные объекты|Константные объекты]]
## [[Константы#Константные функции|Константные функции]]
# [[Замечания об эффективности кода]]
## [[Замечания об эффективности кода#О пользе типов|О пользе типов]]
## [[Замечания об эффективности кода#О пользе спецификаторов доступа|О пользе спецификаторов доступа]]
# [[Приведение типов]]

== Синтаксис языка ==

# [[Классы и объекты]]
## [[Классы и объекты#История развития ООП|История развития ООП]]
### [[Классы и объекты#Возникновение языков программирования|Возникновение языков программирования]]
### [[Классы и объекты#Появление ассемблера|Появление ассемблера]]
### [[Классы и объекты#Концепция языка высокого уровня|Концепция языка высокого уровня]]
### [[Классы и объекты#Структурное программирование|Структурное программирование]]
### [[Классы и объекты#Объектно-ориентированное программирование|Объектно-ориентированное программирование]]
## [[Классы и объекты#Понятие класса|Понятие класса]]
## [[Классы и объекты#Понятие объекта|Понятие объекта]]
## [[Классы и объекты#Наследование|Наследование]]
## [[Классы и объекты#Методы|Методы]]
### [[Классы и объекты#Статические методы|Статические методы]]
### [[Классы и объекты#Конструкторы|Конструкторы]]
### [[Классы и объекты#Конструкторы|Абстрактные методы]]
## [[Классы и объекты#Поля|Поля]]
## [[Классы и объекты#Свойства|Свойства]]
## [[Классы и объекты#Расширения|Расширения]]
# [[Объявление переменных и констант]]
# [[Выражения]]
## [[Выражения#Арифметические операции|Арифметические операции]]
## [[Выражения#Вызов функций|Вызов функций]]
## [[Выражения#Доступ к полям|Доступ к полям]]
## [[Выражения#Операторы|Операторы]]
# [[Стандартные типы данных]]
## [[Стандартные типы данных#Целые числа|Целые числа]]
## [[Стандартные типы данных#Числа с плавающей точкой|Числа с плавающей точкой]]
## [[Стандартные типы данных#Строки|Строки]]
## [[Стандартные типы данных#Интервалы|Интервалы]]
## [[Стандартные типы данных#Массивы и списки|Массивы и списки]]
## [[Стандартные типы данных#Хеши|Хеши]]
## [[Стандартные типы данных#Указатели|Указатели]]
# [[Функции]]
## [[Функции#Объявление|Объявление]]
## [[Функции#Аргументы|Аргументы]]
### [[Функции#Типизация аргументов|Типизация аргументов]]
### [[Функции#Инициализаторы аргументов (значения по умолчанию)|Инициализаторы аргументов (значения по умолчанию)]]
### [[Функции#Модификаторы и копирование|Модификаторы и копирование]]
### [[Функции#Функции с переменным списком аргументов|Функции с переменным списком аргументов]]
## [[Функции#Возврат значения|Возврат значения]]
## [[Функции#Локальные переменные|Локальные переменные]]
### [[Функции#Объявление|Объявление]]
### [[Функции#Область видимости|Область видимости]]
## [[Функции#Экспортирование функций|Экспортирование функций]]
## [[Функции#Перегрузка функций и операторов|Перегрузка функций и операторов]]
### [[Функции#Особенности применения|Особенности применения]]
### [[Функции#Применение перегрузки в расширениях|Применение перегрузки в расширениях]]
# [[Блоки]]
## [[Блоки#Применение блоков|Применение блоков]]
## [[Блоки#Отличие от функций|Отличие от функций]]
## [[Блоки#Типизация параметров|Типизация параметров]]
## [[Блоки#Встроенные блоки|Встроенные блоки]]
# [[Основные синтаксические конструкции]]
## [[Основные синтаксические конструкции#Условный оператор|Условный оператор]]
### [[Основные синтаксические конструкции#Оператор if|Оператор if]]
### [[Основные синтаксические конструкции#Оператор if-else|Оператор if-else]]
### [[Основные синтаксические конструкции#Оператор if-elsif-else|Оператор if-elsif-else]]
### [[Основные синтаксические конструкции#Постфиксные операторы|Постфиксные операторы]]
### [[Основные синтаксические конструкции#Тернарный условный оператор|Тернарный условный оператор]]
## [[Основные синтаксические конструкции#Оператор множественного выбора (switch)|Оператор множественного выбора (switch)]]
## [[Основные синтаксические конструкции#Циклы|Циклы]]
### [[Основные синтаксические конструкции#Цикл while|Цикл while]]
### [[Основные синтаксические конструкции#Цикл for|Цикл for]]
### [[Основные синтаксические конструкции#Цикл foreach|Цикл foreach]]
### [[Основные синтаксические конструкции#Управление циклами|Управление циклами]]
### [[Основные синтаксические конструкции#Понятие бесконечного цикла|Понятие бесконечного цикла]]
### [[Основные синтаксические конструкции#Взаимозаменяемость циклических структур|Взаимозаменяемость циклических структур]]
# [[Обработка исключений]]
## [[Обработка исключений#Идеология исключений|Идеология исключений]]
## [[Обработка исключений#Объект исключения|Объект исключения]]
## [[Обработка исключений#Генерация исключения|Генерация исключения]]
## [[Обработка исключений#Перехват исключений|Перехват исключений]]
# [[Управление пакетами]]
## [[Управление пакетами#Принципы организации кода|Принципы организации кода]]
## [[Управление пакетами#Импортирование библиотек, ключевое слово import|Импортирование библиотек, ключевое слово import]]
## [[Управление пакетами#Ключевое слово package|Ключевое слово package]]
## [[Управление пакетами#Спецификаторы доступа|Спецификаторы доступа]]
# [[Пространства имен]]

== Регулярные выражения ==
# [[История создания регулярных выражений]]
# [[Применение регулярных выражений]]
## [[Применение регулярных выражений#Зачем нужны регулярные выражения|Зачем нужны регулярные выражения]]
## [[Применение регулярных выражений#Преимущества регулярных выражений|Преимущества регулярных выражений]]
## [[Применение регулярных выражений#Применение регулярных выражений на примере разбора лог файла|Применение регулярных выражений на примере разбора лог файла]]
# [[Синтаксис регулярных выражений]]
## [[Синтаксис регулярных выражений#Классы символов|Классы символов]]
## [[Синтаксис регулярных выражений#Заполнители|Заполнители]]
## [[Синтаксис регулярных выражений#Квантификаторы|Квантификаторы]]

== Операторы ==

# [[Обзор операторов]]
# [[Типы операторов]]
## [[Типы операторов#Арифметические|Арифметические]]
## [[Типы операторов#Операторы сравнения|Операторы сравнения]]
## [[Типы операторов#Операторы присваивания|Операторы присваивания]]
## [[Типы операторов#Операторы приведения типов|Операторы приведения типов]]
## [[Типы операторов#Оператор индексного доступа|Оператор индексного доступа]]
## [[Типы операторов#Оператор вызова функции|Оператор вызова функции]]
## [[Типы операторов#Аксессоры и мутаторы|Аксессоры и мутаторы]]
# [[Использование операторов]]

== Системная библиотека ==

== GIDE ==

# [[Идеология gide]]
# [[Виртуальная машина gide]]
# [[Стандартная библиотека gide]]

[[Рабочие заметки]]

Обработка исключений

2009-10-24T13:00:46Z

Korvin: /* Перехват исключений */

Как уже было отмечено во [[Идеология языка#Понятие исключения|введении]], исключения — это мощный механизм, позволяющий в разы сократить время, требуемое на написание программ и значительно повысить их качество. В основном, это достигается за счет того что, программист пишет более простой код, не отвлекаясь от основной задачи на разного рода рутинные операции, вроде обработки ошибок, а значит, его внимание сконцентрировано на самой проблеме. В итоге, это приводит к написанию более качественного кода. В этой главе будет рассмотрена сущность механизма исключений, а так же способы их применения на практике. Будут даны типовые схемы разработки программ и даны соответствующие пояснения.

== Идеология исключений ==

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

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

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

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

В некоторых местах, где заранее предусматривается возможность проявления ошибки (например при открытии файла), вставляется специальная конструкция исключения. Она состоит из основного блока и одного или нескольких блоков — перехватчиков исключений. Выглядит эта конструкция так:
<source lang="kpp">
try {
/* try-блок (основное тело) */
} catch (/* переменная для объекта исключения 1 */) {
/* код перехватчика 1 */
} catch (/* переменная для объекта исключения 2 */) {
/* код перехватчика 2 */
}
</source>

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

== Объект исключения ==

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

== Генерация исключения ==

Код, который первым обнаруживает исключительную ситуацию (то есть, стоит у ее истоков) и желающий сообщить о ней "наверх", должен создать объект исключения и "выбросить" его. Создается объект так же, как и любой другой объект в языке К++: либо с помощью оператора <tt>'''new'''</tt>, либо с помощью [[Классы и объекты#Конструкторы|конструктора]] (если он предусмотрен). "Выбрасывание" объекта осуществляется с помощью специального оператора <tt>'''throw'''</tt>, который принимает объект в качестве параметра. Обычно, эти операции совмещают в одном действии.

Приведем пример некоторой функции, которая проверяет правильность передаваемых ей данных и выбрасывает исключение в случае несоответствия:
<source lang="kpp">
function Process(const int idx) {
if (! idx in 5 .. 10)
throw "индекс должен быть в диапазоне от 5 до 10";
/* нормальный код обработки */
}
</source>

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

На практике применяются специальные классы распространенных исключений, которые объявлены в [[Стандартная библиотека Gide|стандартной библиотеке]]. Таким образом, все языки использующие стандартную библиотеку и умеющие работать с исключениями, смогут успешно взаимодействовать с помощью этого механизма.

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

::{| width=60%
| <tt>EInvalidCall</tt> || неверный вызов (входные данные неверны)
|-
| <tt>EFailed</tt> || операция не удалась (и все тут)
|-
| <tt>EAagain</tt> || по тем или иным причинам требуется повтор операции
|-
| <tt>EDenied </tt> || действие запрещено!
|-
| <tt>ECancelled </tt> || операция была отменена (например пользователем)
|-
| <tt>EAlready</tt> || операция уже была выполнена
|-
| <tt>ERangeError</tt> || ошибка диапазона (выход значения за допустимые границы)
|-
| <tt>EDivisionByZero</tt> || арифметическая ошибка деления на ноль
|-
| <tt>ETimeout </tt> || истекло время ожидания чего-либо
|-
| <tt>EStreamError</tt> || ошибка [[потока]]
|-
| <tt>ERegexpError</tt> || ошибка при разборе [[регулярного выражения]]
|-
| <tt>EAbstractError</tt> || попытка вызова [[Классы и объекты#Методы|абстрактного метода]]
|}

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

Например, в описанном выше случае, наиболее подходящим классом ошибки будет <tt>ERangeError</tt>. Соответственно, код генерации ошибки можно написать так:
<source lang="kpp">
throw ERangeError.create("индекс должен быть в диапазоне от 5 до 10");
</source>

== Перехват исключений ==

Для обработки возникающих исключений используется конструкция перехвата. Она начинается с ключевого слова <tt>'''catch'''</tt>, следом за которым, в круглых скобках, идет описание переменной исключения, а затем, собственно, блок обработчика. Например, так мог бы выглядеть код вызова вышеописанной функции <tt>Process()</tt> и обработки возникающего исключения, если бы оно имело место:
<source lang=kpp>
try {
Process(/*выражение задающее индекс*/);
/* другой код */
} catch (e) {
print("Ошибка обработки индекса. #{e.name}: #{e.description}\n");
/* код обработки исключения */
}
</source>

Для того чтобы сослаться на объект исключения используется переменная ''e''. Все системные классы исключений имеют свойства <tt>name</tt> и <tt>description</tt>. Первое содержит имя исключения, а второе — описание ошибки.

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

<source lang=kpp>
try {
/* защищаемый код */
} catch (/*класс 1*/ /*имя объекта 1*/) {
/* код обработки исключения 1 */
} catch (/*класс 2*/ /*имя объекта 2*/) {
/* код обработки исключения 2 */
...
}
</source>

Таким образом, при объявлении переменной исключения, мы можем указывать ее тип и потом ссылаться на
специфические поля объектов, соответствущих этому типу:
<source lang=kpp>
try {
/* защищаемый код */
} catch (EAgain e) {
/* запрос у пользователя на повторение операции */
} catch (ERangeError e) {
/* отображение ошибки */
} catch (e) {
/* запись в лог файл */
}
</source>

В вышеприведенном коде используются три обработчика исключений: первые два перехватывают исключения определенного типа, а третий — все оставшиеся. Структура обработчиков исключений чем-то напоминает конструкцию <tt>'''[[Основные синтаксические конструкции#Оператор множественного выбора (switch)|switch]]'''</tt>.

'''Примечание 1:''' следует помнить, что правильность разбора исключений по классам, зависит от очередности расположения блоков перехватчиков в конструкции. При перехвате исключения выбор обработчика происходит по принципу первого совпадения, при котором проверяется, имеет ли объект исключения в своей иерархии класс, указанный в перехватчике. Если скажем, перехватчик <tt>'''catch''' (e)</tt> будет указан первым, то он и будет собирать все исключения, поскольку он сработает на любой класс объекта исключения. Вообще, нужно стараться располагать перехватчики по убыванию степени абстракции — от пользовательских классов до системных и далее, до общего перехватчика.

== Ловить или не ловить? ==

Блоки перехвата исключений должны вставляться только в тех местах, где вы точно знаете, как надо поступить при возникновении исключения. Если такой уверенности нет — смело пропускайте исключение "мимо ушей". Рано или поздно оно будет словлено там, где программа располагает бо́льшими сведениями относительно дальнейшей модели поведения.

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

Обработка исключений

2009-10-24T12:44:20Z

Korvin: /* Генерация исключения */

Bytea

2009-06-25T15:31:16Z

Korvin: /* оператор + */

Класс <tt>bytea</tt> (от англ. ''byte array'' — массив байтов) используется для работы с данными, как с потоком байтов. Класс во многом похож на класс <tt>[[string]]</tt>. Отличие заключается в том, что <tt>[[string]]</tt> ориентируется на строковые данные в кодировке '''UTF-8''', в то время как <tt>bytea</tt> ориентируется на байты.

Например, в случае строки "hello world" методы <tt>[[#length|bytea:length]]</tt> и <tt>[[string#length|string:length]]</tt> вернут одно и то же число, поскольку байтовое представление будет одинаковым. В случае строки "привет мир", длины уже не будут совпадать, поскольку в кодировке '''UTF-8''' символы кирилицы будут представляться уже двумя байтами.

'''Родители''': <tt>[[Object]]</tt> 
'''Методы''': <tt>
[[#empty|empty]]
[[#length|length]]
[[#resize|resize]]
[[#clear|clear]]
[[#substr|substr]]
[[#replace|replace]]
[[#replace_all|replace_all]]
[[#insert|insert]]
[[#erase|erase]]
[[#find|find]]
[[#find_first_of|find_first_of]]
[[#find_first_not_of|find_first_not_of]]</tt>
'''Приводится к типам''': <tt>[[int]] [[real]] [[uid]] [[string]]</tt> 
'''Реализует операторы''':
<tt>[[#оператор +|+]]</tt>,
<tt>[[#оператор +=|+=]]</tt>,
<tt>[[#оператор <<|<<]]</tt>,
[[#индексные операторы|индексного доступа]],
[[оператор присваивания|присваивания]],
[[операторы сравнения|сравнения]] 

__NOTOC__

== индексные операторы ==

operator <nowiki>[]</nowiki> (''индекс'': <tt>int</tt>) 
'''Возвращает''': <tt>int</tt> 

Оператор индексного чтения служит для получения значения некоторого байта расположенного по указанному индексу. Если указан индекс, выходящий за текущие границы массива, будет сгенерировано исключение [[Классы исключений#ERangeError|ERangeError]].

operator <nowiki>[]=</nowiki> (''индекс'': <tt>int</tt>, ''значение'': <tt>int</tt>) 
'''Возвращает''': <tt>int</tt> 

Оператор индексной записи, напротив, служит для установки значения байта расположенного по соответствующему индексу. Если указан индекс, выходящий за текущие границы массива, будет сгенерировано исключение [[Классы исключений#ERangeError|ERangeError]].

'''Примечание''': Имеет значение только самый младший байт переданного числа, то есть значения в диапазоне от 0 до 255.

== оператор + ==

operator + (''слагаемое'': <tt>bytea</tt>) 
'''Возвращает''': <tt>bytea</tt> 

Метод возвращает новый байт-массив, полученный путем конкатенации (сложения) текущего и переданного массивов. Размер внутреннего буфера увеличивается автоматически, однако в случае большого количества последовательных (циклических) конкатенаций, возможен предварительный вызов метода <tt>[[#resie|resize]]</tt>, для повышения быстродействия и уменьшения числа промежуточных операций копирования.

== оператор += ==

operator += (''слагаемое'': <tt>bytea</tt>) 
'''Возвращает''': текущий объект 

Метод изменяет текущий массив, дописывая ему в конец массив, переданный в качестве параметра. Размер внутреннего буфера увеличивается автоматически, однако в случае большого количества последовательных (циклических) конкатенаций, возможен предварительный вызов метода <tt>[[#resie|resize]]</tt> для повышения быстродействия и уменьшения числа промежуточных операций копирования.

== оператор << ==

Эквивалент оператора <tt>[[#оператор +|+]]</tt>.

== empty ==

'''Возвращает''': [[логическое значение]] 

Метод возвращает истину, если массив непуст.

== length ==

'''Возвращает''': <tt>[[int]]</tt> 

Метод возвращает текущий размер данных в байтах.

== resize ==

resize(''новый размер в байтах'': <tt>[[int]]</tt>) 
'''Возвращает''': текущий объект 

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

== clear ==

'''Возвращает''': текущий объект 

Очищает массив содержимого и сбрасывает внутренний буфер. После этого строка считается пустой.

== substr ==

substr(''начальная позиция:'' <tt>[[int]]</tt>, ''количество байт'': <tt>[[int]]</tt>) 
'''Возвращает''': <tt>bytea</tt> 

Метод возвращает байт-массив, содержащий подмассив текущих данных, начиная с указанной позиции.

== replace ==

replace(''начальная позиция'': <tt>[[int]]</tt>, ''количество байт'': <tt>[[int]]</tt>, ''блок замены'': <tt>bytea</tt>) 
'''Возвращает''': текущий объект 

Метод заменяет указанное количество байт с начальной позиции на блок замены.

== replace_all ==

replace_all(''блок поиска'': <tt>bytea</tt>, ''блок замены'': <tt>bytea</tt>) 
'''Возвращает''': текущий объект 

Метод находит все включения блока поиска в исходном массиве и заменяет их на блок замены.

== insert ==

insert(''позиция'': <tt>[[int]]</tt>, ''данные'': <tt>bytea</tt>) 
'''Возвращает''': текущий объект 

Метод вставляет переданные данные в исходныый массив, в указаную позицию, "раздвигая" имеющиеся данные.

== erase ==

erase_int(''начальная позиция:'' <tt>[[int]]</tt>, ''количество байт'': <tt>[[int]]</tt>) 
'''Возвращает''': текущий объект 

Метод вырезает из текущих данных указанный блок.

== find ==

find(''блок поиска'': <tt>string</tt> [, ''начальная позиция'': <tt>[[int]]</tt>]) 
'''Возвращает''': <tt>[[int]]</tt> 

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

== find_first_of ==

== find_first_not_of ==

Object

2009-06-18T14:27:07Z

Korvin: /* inspect */

Класс <tt>Object</tt> является сердцем всей стандартной библиотеки и ее центральным классом. Все остальные классы, прямо или косвенно наследуются от <tt>Object</tt>, что позволяет реализовывать централизованное управление и сбор информации об объектах. Данный класс имеет набор методов которые реализуют механизм рефлексии, который заключается в том, что объекты могут динамически получать информацию о других объектах (включая самих себя). Например, объект A может узнать, какие методы имеет объект B, и на основании этой информации выполнять те или иные действия.

Класс <tt>Object</tt> вводит понятие инспектирования объектов, которое позволяет получать сведения о содержимом объектов в удобной для восприятия форме (это может быть особенно полезно при отладке и трассировке программ).

'''Родители''': <tt>Object</tt> 
'''Методы''': <tt>[[#class|class]] [[#className|className]] [[#instanceOf|instanceOf]] [[#call|call]] [[#invoke|invoke]] [[#freeze|freeze]] [[#frozen|frozen]] [[#clone|clone]] [[#dup|dup]] [[#inspect|inspect]] [[#equals|equals]] [[#hasMethod|hasMethod]] [[#getMethod|getMethod]] [[#methods|methods]]</tt> 
'''Реализует операторы''': <tt>[[#equals|==]]</tt>

__NOTOC__

== class ==

'''Возвращает''': <tt>[[Class]]</tt> 

Метод возвращает инстанцию класса <tt>[[Class]]</tt>, соответствующую классу данного объекта. Например:
<source lang="kpp">
var x = 1; //переменная типа int
var c = x.class; //переменная типа Class
puts(c.name); //выведет на экран строку "int"
</source>

== className ==

'''Возвращает''': <tt>[[string]]</tt> 

Эквивалент операции <tt>x.class.name</tt>, только работает быстрее (без создания промежуточного объекта)

== instanceOf ==

instanceOf(''имя класса:'' <tt>[[string]]</tt>) 
instanceOf(''класс:'' <tt>[[Class]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий объект инстанцией указанного класса.

== call ==

call(''имя метода:'' <tt>[[string]]</tt>, <tt>'''...'''</tt>) 
'''Возвращает''': динамическую переменную 

Метод позволяет вызывать методы объектов динамически, по их имени. При этом, вызываемому методу передаются все последующие параметры (если таковые имеются). Естественно, никакой проверки типов фактических параметров не производится. Всю работу по приведению типов программист должен осуществлять сам. Пример:
<source lang="kpp">
var ary = new array;
ary.call(:push, 1, 2, 3);
puts(ary.inspect); // [1, 2, 3]
</source>

== invoke ==

invoke(''имя метода:'' <tt>[[string]]</tt>, ''параметры:'' <tt>[[array]]</tt>) 
'''Возвращает''': динамическую переменную 

Метод аналогичен по смыслу методу <tt>[[#call|call]]</tt>, за исключением того, что последующие параметры передаются в массиве. При вызове этот массив будет "развернут", как если бы все параметры были записаны через запятую:
<source lang="kpp">
var ary = new array;
ary.invoke(:push, [1, 2, 3]);
puts(ary.inspect); // [1, 2, 3]
</source>

== freeze ==

'''Возвращает''': текущий объект 

Метод "замораживает" текущий объект, после чего он становится доступным только для чтения. Обратной операции не существует, так что разморозить однажды замороженный объект нельзя.

== frozen ==

'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий объект замороженным.

== clone ==

'''Возвращает''': копию текущего объекта 

Метод служит для создания копии текущего объекта, используя оператор "<tt>=</tt>". Если объект (или его класс) располагает таким методом, будет создана пустая инстанция класса, которой будет присвоено значение текущего объекта.

'''Примечание:''' В случае с контейнерами копирование происходит только в том случае, если данный элемент обладает оператором "<tt>=</tt>"; в противном случае, в копии контейнера будет лежать тот же объект:
<source lang="kpp">
var ary = new array;
ary.push(5);
ary.push(Stream.open(...));
var copy = ary.clone;
</source>

В этом примере, переменная ''copy'' будет содержать копию оригинального массива ''ary''. Однако скопирован будет только нулевой элемент массива, то есть объект соответствующий константе 5. Инстанция потока будет передана "как есть".

== dup ==

== inspect ==

'''Возвращает''': <tt>[[string]]</tt> 

Метод преобразует и возвращает информацию об объекте в удобном для восприятия виде. Переопределяется в классах-потомках для отображения более детальной информации. Во многих случаях является аналогом оператора приведения к строке, однако не всегда. Например, в случае K++, для класса строки оператор приведения к типу <tt>[[string]]</tt> возвращает саму строку, тогда как метод <tt>inspect</tt> возвращает строку с восстановленными спецсимволами и заключенную в кавычки:
<source lang="kpp">
var hello = "hello\tworld\n";
puts(hello); //вывод: hello world
puts(hello as string); //вывод: hello world
puts(hello.inspect); //вывод: "hello\tworld\n"
</source>

Другие классы, такие как контейнеры, переопределяют метод для отображения своего содержимого. При этом, в коде метода рекурсивно вызывается метод <tt>inspect</tt> самих элементов для отображения их значения:
<source lang="kpp">
var ary = [1, [2,'3'], :x, { :a => 1 }];
puts(ary.inspect); //вывод: [1, [2, "3"], "x", { "a" => 1 }]
</source>

== equals ==

equals(''объект сравнения'') 
operator == (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

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

<source lang="kpp">
var x = 5;
var b1 = x.equals(x);
var y = 4 + 1;
var b2 = x.equals(y);
</source>

В этом примере переменная ''b1'' будет истинной, в то время как переменная ''b2'' ложной. Несмотря на то, что переменные ''x'' и ''y'' равны численно — они представлены разными объектами.

'''Примечание:''' В случае с классом <tt>Object</tt> для тех же целей может применяться и оператор <tt>==</tt>, однако предполагается что он должен переопределяться дочерними классами для достижения собственных целей. Сам же метод <tt>equals</tt> переопределяться не должен никогда (для обеспечения оригинального функционала).

== hasMethod ==

hasMethod(''имя метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, имеет ли объект указанный метод.

== getMethod ==

getMethod(''имя метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': <tt>[[Method]]</tt> 

Данный метод возвращает метод объекта в виде объекта метода =) Впоследствии, этот объект может использоваться для удаленного вызова метода, либо для получения дополнительной информации. При попытке получения несуществующего метода будет возбуждено исключение <tt>[[Классы исключений#ENotFound|ENotFound]]</tt>.

Пример использования:
<source lang="kpp">
var ary = new array;
var p = ary.getMethod(:push);
p(1, 2, 3);
ary.inspect; //значение: [1, 2, 3]
</source>

== methods ==

'''Возвращает''': <tt>[[array]]<[[string]]></tt> 

Метод возвращает массив имен методов.

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

Правила оформления кода

2009-05-18T14:53:42Z

Korvin: /* Правила именования */

== Введение ==

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

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

В первом разделе приводятся общие правила для всех языков программирования и разметки; в последующих разделах они конкретизируются для различных языков.

== Общие правила ==

=== Язык и кодировка ===

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

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

=== Подход к написанию кода ===

Самое главное правило: код должен быть легкочитаем и красив.

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

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

Очень советуем прочитать статью про [http://ru.wikipedia.org/wiki/%D0%90%D0%BD%D1%82%D0%B8-%D0%BF%D0%B0%D1%82%D1%82%D0%B5%D1%80%D0%BD анти-паттерны] в википедии.

=== Комментарии ===

Код должен быть откомментирован так, чтобы обеспечить его читаемость, но и не должен быть перегружен комментариями.

Обычно для выполнения этого условия достаточно написать небольшие пояснения к каждому классу и методу в этом классе.

Комментарии должны объяснять, '''как''' работает код, но не '''что''' он делает. Ответ на второй вопрос должен содержаться в документации, а не в коде; мы не используем в проекте системы вроде doxygen для создания документации из кода, поскольку убеждены, что документация в коде загромождает этот код и делает его трудночитаемым.

Кроме того, '''все комментарии должны быть на английском языке'''. У этого правила несколько причин, самые главные из которых - возможность чтения кода иностранцами и в любом редакторе. Комментарии транслитом также не допускаются.

=== Комментарий в начале файла ===

В начале каждого исходного файла должна содержаться следующая информация:

//
// project : <project name>
// date : <current date>
// author : <author name>
// e-mail : <author email>
// licence : <licence name>
//

Имя проекта - это название задания в списке задач, переведенное на английский язык, например, - '''console programs'''. Дата - текущая дата в формате yyyy-mm-dd. Имя автора записывается в форме '''Имя Фамилия''' (также по-английски), например: '''Vasily Petrov''' (но не Petrov Vasily). E-mail - это актуальный адрес автора, который может быть использован для писем по вопросам работоспособности данного кода.

Лицензия - это либо название одной из применяемых в проекте лицензий ('''MIT''', '''LGPL''' etc), либо имя файла с лицензией. Персональные лицензии должны храниться в файлах, содержащих имя автора в имени файла, например '''licence-petrov-vasily.txt'''. Все такие лицензии будут добавлены в репозиторий с кодом.

После этого комментария может идти текст лицензии или какие-либо лицензионные предупреждения (некоторые лицензии это требуют). Но такой текст должен идти ПОСЛЕ заголовка, а не до него.

Поля author и e-mail могут быть записаны несколько раз, в случае если авторов/адресов несколько.

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

Пример заголовочного комментария:

//
// project : mysql database driver
// date : 2008-11-30
// author : Ivan Ivanov
// e-mail : ivan.ivanov@example.com
// licence : MIT
//

=== Отступы в коде ===

Прежде всего, в качестве отступов нельзя использовать символы табуляции. Они по-разному отображаются в различных программах просмотра/редакторах, что затрудняет чтение кода. В качестве отступов следует использовать четыре символа "пробел".

=== Использование операторных скобок { } ===

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

while(...) {
// some stuff
}

Кроме того, специальное исключение делается для конструкции if ... else:

if(...) {
// stuff...
} else {
// more stuff...
}

Исключение также применимо только для не слишком длинных конструкций.

== Правила для K++ кода ==

=== Правила именования ===

(жирным отмечены обязательные правила, остальные - желательны, но не обязательны).

# '''Модули именуются в стиле MyModuleName''';
# '''Имена файлов в точности совпадают с именами модулей'''. Например, модуль Proto::HTTP должен находиться в файле Proto/HTTP.kpp;
# '''Классы именуются в стиле MyClassName''', без каких-либо префиксов;
# '''Публичные методы и свойства именуются в стиле someMethodName''';
# '''Аргументы функций именуются в стиле argument_name''';
# '''Все публичные имена должны быть говорящими, желательно без сокращений, но при этом не слишком длинными'''. Примерное ограничение по длине имени - 20 символов;
# Приватные методы и свойства именуются аналогично публичным;
# Локальные переменные именуются в стиле variable_name (все буквы - строчные, символы подчеркивания между словами);
# Поля класса именуются аналогично локальным переменным, но с префиксом '''m_'''.

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

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

== Правила для C++ кода ==

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

=== Переносимость кода ===

Весь код проекта должен компилироваться, собираться и работать на любой
системе, будь то Windows, Mac, UNIX, Solaris и другие. Использование
библиотек также ограничено лишь лицензионными соглашениями и переносимостью
их на другие системы. В некоторых случаях допускаются исключения: код может
быть написан в нескольких вариантах для разных систем. Но в конечном итоге,
должна быть возможность сборки кода на любой системе.

=== Схемы разыменовывания ===

Далее по тексту используются следующие определения для имен различных
объектов:
* ''произвольная'' - объект может быть назван произвольно.
* ''прописная слитная'' - объект должен быть назван прописными буквами, слова не должны отделяться друг от друга. Например, OBJECTNAME.
* ''прописная [раздельная]'' - объект должен быть назван прописными буквами, слова отделяются друг от друга знаком подчеркивания: OBJECT_NAME.
* ''строчная слитная'', ''строчная [раздельная]'' - аналогично: objectname и object_name соответственно.
* ''основная'' - название должно начинаться с прописной буквы, и каждое слово должно начинаться с прописной буквы. Остальные буквы - строчные: ObjectName.

=== Файловая структура верхнего уровня ===

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

Таким образом, за каждым подпроектом закрепляется его уникальный идентификатор -
это путь к подпроекту относительно корневого каталога проекта.

=== Разыменовывание файлов ===

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

=== Разбиение файлов по каталогам ===

Все файлы модуля разбиваются по каталогам следующим образом:
* все публичные включаемые файлы должны находиться в корневом каталоге модуля;
* все внутренние включаемые файлы должны находиться в подкаталоге ''impl'';
* все исходные файлы должны находиться в каталоге ''source''.

=== Разбиение функций и классов по файлам ===

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

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

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

Реализация каждого класса должна быть вынесена в отдельный исходный файл, имя
которого совпадает с именем класса.

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

=== Пространства имен ===

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

=== Стражи включения ===

Все файлы заголовков должны быть защищены стражем включения. Имя стража
включения дается следующему шаблону: __PRFX_FILENAME_H_INCLUDED.

Здесь PRFX - префикс модуля и его части (см. п. 4.1), FILENAME - имя
заголовочного файла, записанное прописными буквами.

Пример:

#ifndef __SEST_INDEXBUFFER_H_INCLUDED
#define __SEST_INDEXBUFFER_H_INCLUDED
// ...
// ...
#endif
// EOF

=== Правила именования сущностей ===

Применяются следующие правила разыменовывания:

* Определения препроцессора именуются по прописной схеме. Кроме того, для всех определений препроцессора ставится два префикса. Первый соответствует модулю и его части (4 символа), второй - смыслу определения. Префиксы отделяются друг от друга и от имени знаком подчеркивания. Пример: '''SEST_IBS_LOADED''' (Soung Engine, STreaming module; Index Buffer State).
* Интерфейсы (классы, в которых все методы - абстрактные) именуются по стандартной схеме, ставится префикс '''I''' (ISomeName).
* Классы именуются по стандартной схеме, ставится префикс '''C''' (CClassName).
* Структуры именуются по стандартной схеме (StructName).
* Функции и методы классов также именуются по стандартной схеме.
* Закрытые поля и локальные переменные именуются произвольно.
* Публичные поля классов и аргументы функций именуются по следующей схеме: имя переменной записываеися по основной схеме; добавляется префикс, соответствующий типу переменной (pszIndexName). К публичным полям класса также добавляется префикс m_ (m_pszIndexName).

Префиксы для стандартных типов:
* [unsigned] int: i, u, n
* unsigned char, byte: b
* char: c
* char*, char[] (в смысле строки): sz
* [unsigned] short, word: w
* dword: dw
* qword: qw
* любой указатель: p

Для нестандартных типов, префикс выбирается в соответствии с именем типа.
Длина префикса - от одного до двух символов.

Кроме того:
# Публичные имена следует давать осмысленными - из имени должно быть ясно, зачем нужна переменная (функция, ...).
# Предпочтительный диапазон длины имени - от 4 до 20 символов.
# Предпочтительное количество слов, из которых составлено имя - от 1 до 3.
# Имена в объявлении класса не должны содержать имя класса. Например, в объявлении класса CFile не должно быть поля m_dwFileSize; следует использовать имя m_dwSize.

=== Правила оформления операторов ===

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

# Каждому оператору выделяется новая строка.
# Круглые скобки не выделяются пробелами.
# Максимальная длина строки - 80 символов. Если требуется больше, остаток оператора переносится на следующую строку, к нему (остатку) добавляется дополнительный отступ.
# Если тело оператора if или цикла состоит из одного оператора, операторные скобки не ставятся, а оператор записывается с новой строки с дополнительным отступом.
# На использование пробелов ограничений не накладывается.

=== Запрещенные конструкции ===

Запрещается использование оператора goto. Единственное исключение - выход из циклов с несколькими уровнями вложенности.

Конструкцию do { ... } while(...); крайне не рекомендуется использовать, особенно если тело цикла больше 10 строк.

Deptown Programming Contest (DPC)

2009-05-17T21:23:36Z

Korvin: /* Текущее положение дел */

Здравствуй Гость! Ты попал на страничку программерского соревнования в рамках проекта Диптаун =)

DPC это соревнование, участие в котором принимают роботы, находящиеся в виртуальном пространстве диптауна. Управляет роботом программа, написанная на языке [[K++]].

Идея соревнования была заимствована из проекта [http://robocode.sourceforge.net/ Robocode] и адаптирована под текущие реалии и специфику платформы Диптаун.

== Для чего это нужно? ==

Если говорить откровенно, то мы еще сами не знаем зачем все это и что из этого может получиться :)

Но на самом деле, у DPC целей много. Во-первых, популяризация самого проекта Диптаун и наглядная демонстрация возможностей платформы Диптауна. Во-вторых, это отличный способ изучить язык [[K++]] в игровой обстановке, а так же попробовать себя в решении нечетких задач и умения находить нестандартные решения. В-третьих, лучший способ отладить некую систему, это начать активно ее использовать. Заодно, мы сможем лучше представить, какие функции более всего востребованы разработчиками, что использовать удобно, а что требуется изменить, ну и так далее.

Наконец, это просто забавно и жутко интересно :)

== Основная идея ==

Есть некая арена, в пространстве которой существуют боевые роботы. Каждый робот принадлежит одному из участников. На каждом роботе крутится программа управления этим роботом. Цель -- победить соперников и остаться в живых. Третьего не дано :)

== Правила соревнований ==

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

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

== Вариант первый: Sumo Challenge ==

[[Изображение:DPC.png|right]]
В этом варианте соревнований самые простые правила и роботы. Однако это не значит что победить в нем легко. Наоборот, мне кажется что это лучший из вариантов, поскольку все зависит от тактики робота и качества программы.

=== Арена ===

Арена -- это пространство для соревнования. Арена зависит от типа проводимого соревнования. В данном случае это площадка без ограждений, размерами скажем 10 на 10 метров. Сама площадка может висеть над пустотой или просто являться возвыщением.

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

=== Роботы ===

Sumo это простейший вид соревнований, соответственно и роботы должны быть простые :) На данный момент планируется 2 вида роботов: четырех колесные и трехколесные. Первый имеет два рулевых колсеса являющиеся так же ведущими (машина с передним приводом), второй -- два ведущих и одно рулевое (трайк).

Трехколесный робот более маневренный, однако и менее устойчивый. Четырехколесный более устойчивый, но управлять им сложнее.

=== Управление ===

Независимо от конструкции, все роботы обладают следущим набором систем:
* Приводы колес (моторы). Можно задавать скорость вращения и угол поворота (для ведущих колес).
* Сенсор краев -- с его помощью можнно определять положение робота на площадке
* Радар -- служит для слежения за роботом противника. Дает информацию о его скорости и направлении движения.

Дополнительно, сам робот знает скорость своего движения и свое положение в пространстве арены.

=== Стратегии ===

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

==== Берсерк ====

Наверное самая ломовая стратегия :) Просто фиксируем положение противника и гоним в него, в надежде что так мы его скинем с площадки.

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

==== Трус ====

Стратегия, обратная "берсерку". Стараемся всячески избегать противника и находиться от него подальше.

* Плюсы: выиграть сложно, но зато сам не улетишь. При определенных условиях, грамотно написанный "трус", будет выигрывать у "берсерка", поскольку последний сам улетит :)
* Минусы: если ваш противник не берсерк, то выиграть будет практически невозможно

==== Тормоз ====

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

* Плюсы: если ваша цель -- ничья, то можно подумать об этом варианте :)
* Минусы: умрем раньше, чем два "тормоза" на арене завершат бой

==== А что дальше? ====

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

В общем случае стратегий можно придумать бесконечное количество :) Все ограничивается лишь вашей фантазией, временем и желанием :)

=== Очки ===

За каждую победу начисляется одно очко, за поражение ноль.

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

== Вариант второй -- классическая Robocode ==

Здесь на первое место выходит зрелищность :) Действие происходит на поле, на котором может находиться сразу несколько соперников. Каждый соперник представлен танком, имеющим пушку и радар. По условиям, танки так же идентичны.

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

Возможных вариантов стратегий здесь еще больше чем в Sumo. Описывать их все не хватит времени, тем более что по этой теме есть масса материалов на [http://robocode.sourceforge.net/ официальном сайте].

== Текущее положение дел ==

--[[Участник:Velaar|Velaar]] 02:56, 18 мая 2009 (NOVST)
Всех желающих принять участие в реализации проекта просим в [http://ding.deeptown.org Deeptown DING project].

Как только перейдем к этому проекту, появится соотвествующая новость и запись здесь.

Заглавная страница

2009-05-17T19:26:42Z

Korvin: /* Информация */

== Информация ==

* [[О проекте]]
* [[Deeptown SDK]]
* [[Deptown Programming Contest (DPC)]]
* [[Задачи|Текущие задачи]]
* [[Bugzilla]]
* [[Рассылка]]
* [[Release Notes]]
* [[Обратная связь]]

== Документация ==

* [[K++]]
* [[World Engine]]
* [[Платформа Gide]]
* [[Стандартная библиотека gide]]
* [[Туториалы и HOWTO]]
* [[Building and running from source]]
* [[Советы и подсказки]]

Deptown Programming Contest (DPC)

2009-05-17T17:36:16Z

Korvin: /* Для чего это нужно? */

Deptown Programming Contest (DPC)

2009-05-17T17:33:52Z

Korvin:

Здравствуй Гость! Ты попал на страничку программерского соревнования в рамках проекта Диптаун =)

DPC это соревнование, участие в котором принимают роботы, находящиеся в виртуальном пространстве диптауна. Управляет роботом программа, написанная на языке [[K++]].

Идея соревнования была заимствована из проекта [http://robocode.sourceforge.net/ Robocode] и адаптирована под текущие реалии и специфику платформы Диптаун.

== Для чего это нужно? ==

А если говорить откровенно, то мы еще сами не знаем зачем все это и что из этого может получиться :)

Но на самом деле, у DPC целей много. Во-первых, популяризация самого проекта Диптаун и наглядная демонстрация возможностей платформы Диптауна. Во-вторых, это отличный способ изучить язык [[K++]] в игровой обстановке, а так же попробовать себя в решении нечетких задач и умения находить нестандартные решения. В-третьих, лучший способ отладить некую систему, это начать активно ее использовать. Заодно, мы сможем лучше представить, какие функции более всего востребованы разработчиками, что использовать удобно, а что требуется изменить, ну и так далее.

Наконец, это просто забавно и жутко интересно :)

== Основная идея ==

Есть некая арена, в пространстве которой существуют боевые роботы. Каждый робот принадлежит одному из участников. На каждом роботе крутится программа управления этим роботом. Цель -- победить соперников и остаться в живых. Третьего не дано :)

== Правила соревнований ==

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

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

== Вариант первый: Sumo Challenge ==

[[Изображение:DPC.png|right]]
В этом варианте соревнований самые простые правила и роботы. Однако это не значит что победить в нем легко. Наоборот, мне кажется что это лучший из вариантов, поскольку все зависит от тактики робота и качества программы.

=== Арена ===

Арена -- это пространство для соревнования. Арена зависит от типа проводимого соревнования. В данном случае это площадка без ограждений, размерами скажем 10 на 10 метров. Сама площадка может висеть над пустотой или просто являться возвыщением.

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

=== Роботы ===

Sumo это простейший вид соревнований, соответственно и роботы должны быть простые :) На данный момент планируется 2 вида роботов: четырех колесные и трехколесные. Первый имеет два рулевых колсеса являющиеся так же ведущими (машина с передним приводом), второй -- два ведущих и одно рулевое (трайк).

Трехколесный робот более маневренный, однако и менее устойчивый. Четырехколесный более устойчивый, но управлять им сложнее.

=== Управление ===

Независимо от конструкции, все роботы обладают следущим набором систем:
* Приводы колес (моторы). Можно задавать скорость вращения и угол поворота (для ведущих колес).
* Сенсор краев -- с его помощью можнно определять положение робота на площадке
* Радар -- служит для слежения за роботом противника. Дает информацию о его скорости и направлении движения.

Дополнительно, сам робот знает скорость своего движения и свое положение в пространстве арены.

=== Стратегии ===

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

==== Берсерк ====

Наверное самая ломовая стратегия :) Просто фиксируем положение противника и гоним в него, в надежде что так мы его скинем с площадки.

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

==== Трус ====

Стратегия, обратная "берсерку". Стараемся всячески избегать противника и находиться от него подальше.

* Плюсы: выиграть сложно, но зато сам не улетишь. При определенных условиях, грамотно написанный "трус", будет выигрывать у "берсерка", поскольку последний сам улетит :)
* Минусы: если ваш противник не берсерк, то выиграть будет практически невозможно

==== Тормоз ====

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

* Плюсы: если ваша цель -- ничья, то можно подумать об этом варианте :)
* Минусы: умрем раньше, чем два "тормоза" на арене завершат бой

==== А что дальше? ====

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

В общем случае стратегий можно придумать бесконечное количество :) Все ограничивается лишь вашей фантазией, временем и желанием :)

=== Очки ===

За каждую победу начисляется одно очко, за поражение ноль.

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

== Вариант второй -- классическая Robocode ==

Здесь на первое место выходит зрелищность :) Действие происходит на поле, на котором может находиться сразу несколько соперников. Каждый соперник представлен танком, имеющим пушку и радар. По условиям, танки так же идентичны.

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

Возможных вариантов стратегий здесь еще больше чем в Sumo. Описывать их все не хватит времени, тем более что по этой теме есть масса материалов на [http://robocode.sourceforge.net/ официальном сайте].

== Текущее положение дел ==

Deptown Programming Contest (DPC)

2009-05-17T17:20:09Z

Korvin: Новая: Здравствуй Гость! Ты попал на страничку программерского соревнования в рамках проекта Диптаун =) DPC э...

Здравствуй Гость! Ты попал на страничку программерского соревнования в рамках проекта Диптаун =)

DPC это соревнование, участие в котором принимают роботы, находящиеся в виртуальном пространстве диптауна. Управляет роботом программа, написанная на языке [[K++]].

Идея соревнования была заимствована из проекта [http://robocode.sourceforge.net/ Robocode] и адаптирована под текущие реалии и специфику платформы Диптаун.

== Для чего это нужно? ==

А если говорить откровенно, то мы еще сами не знаем зачем все это и что из этого может получиться :)

Но на самом деле, у DPC целей много. Во-первых, популяризация самого проекта Диптаун и наглядная демонстрация возможностей платформы Диптауна. Во-вторых, это отличный способ изучить язык [[K++]] в игровой обстановке, а так же попробовать себя в решении нечетких задач и умения находить нестандартные решения. В-третьих, лучший способ отладить некую систему, это начать активно ее использовать. Заодно, мы сможем лучше представить, какие функции более всего востребованы разработчиками, что использовать удобно, а что требуется изменить, ну и так далее.

Наконец, это просто забавно и жутко интересно :)

== Основная идея ==

Есть некая арена, в пространстве которой существуют боевые роботы. Каждый робот принадлежит одному из участников. На каждом роботе крутится программа управления этим роботом. Цель -- победить соперников и остаться в живых. Третьего не дано :)

== Правила соревнований ==

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

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

== Вариант первый: Sumo Challenge ==

[[Изображение:DPC.png|right]]
В этом варианте соревнований самые простые правила и роботы. Однако это не значит что победить в нем легко. Наоборот, мне кажется что это лучший из вариантов, поскольку все зависит от тактики робота и качества программы.

=== Арена ===

Арена -- это пространство для соревнования. Арена зависит от типа проводимого соревнования. В данном случае это площадка без ограждений, размерами скажем 10 на 10 метров. Сама площадка может висеть над пустотой или просто являться возвыщением.

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

=== Роботы ===

Sumo это простейший вид соревнований, соответственно и роботы должны быть простые :) На данный момент планируется 2 вида роботов: четырех колесные и трехколесные. Первый имеет два рулевых колсеса являющиеся так же ведущими (машина с передним приводом), второй -- два ведущих и одно рулевое (трайк).

Трехколесный робот более маневренный, однако и менее устойчивый. Четырехколесный более устойчивый, но управлять им сложнее.

=== Управление ===

Независимо от конструкции, все роботы обладают следущим набором систем:
* Приводы колес (моторы). Можно задавать скорость вращения и угол поворота (для ведущих колес).
* Сенсор краев -- с его помощью можнно определять положение робота на площадке
* Радар -- служит для слежения за роботом противника. Дает информацию о его скорости и направлении движения.

Дополнительно, сам робот знает скорость своего движения и свое положение в пространстве арены.

=== Стратегии ===

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

==== Берсерк ====

Наверное самая ломовая стратегия :) Просто фиксируем положение противника и гоним в него, в надежде что так мы его скинем с площадки.

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

==== Трус ====

Стратегия, обратная "берсерку". Стараемся всячески избегать противника и находиться от него подальше.

* Плюсы: выиграть сложно, но зато сам не улетишь. При определенных условиях, грамотно написанный "трус", будет выигрывать у "берсерка", поскольку последний сам улетит :)
* Минусы: если ваш противник не берсерк, то выиграть будет практически невозможно

==== Тормоз ====

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

* Плюсы: если ваша цель -- ничья, то можно подумать об этом варианте :)
* Минусы: умрем раньше, чем два "тормоза" на арене завершат бой

==== А что дальше? ====

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

В общем случае стратегий можно придумать бесконечное количество :) Все ограничивается лишь вашей фантазией, временем и желанием :)

=== Очки ===

За каждую победу начисляется одно очко, за поражение ноль.

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

== Текущее положение дел ==

Файл:DPC.png

2009-05-17T16:44:26Z

Korvin: Площадка для Sumo Challenge

Площадка для Sumo Challenge

Задачи

2009-05-17T15:36:39Z

Korvin:

В данном разделе мы публикуем текущий список задач Deeptown SDK. Большая часть задач — это разработка тех или иных модулей/программ на языке [[K++]]. Некоторые задачи предполагают реализацию на C++.

Данный раздел будет пополняться со временем. Особо важные изменения будут отмечаться в [[Рассылка|рассылке]].

== Информация ==

=== Для кого этот раздел ===

Браться за выполнение задач может абсолютно любой желающий. В том числе и Вы, дорогой читатель ;)

Для простых задач потребуются только базовые навыки программирования и знание [[K++]], который [[K++|подробно описан]] на этом сайте. Категории сложности задач обозначены в их описаниях.

Однако будьте готовы к тому, что мы не примем некачественный код. Мы следим за качеством нашей системы. Перед тем, как приступать, пожалуйста, ознакомьтесь с [[Правила оформления кода|правилами оформления кода]].

=== Оформление данного раздела ===

В данном разделе задачи разбиты на несколько категорий. Каждая задача — это подраздел в своей категории. Простые задачи описываются прямо в тексте; для более сложных даются ссылки на отдельные страницы описаний. Новые задачи всегда добавляются наверх своего раздела.

Для каждой задачи приводится следующая служебная информация:
* '''сложность''' — уровень сложности задачи: простая, средняя, сложная
* '''технологии''' — список технологий (языков, библиотек, etc), которые потребуются для выполнения задачи
* '''приоритет''' — степень важности задачи: низкий, средний, высокий
* '''автор''' — подпись автора задачи
* '''примечания''' — технические примечания автора
* '''исполнитель''' — контактная информация исполнителя
* '''срок''' — срок завершения, обозначенный исполнителем

=== Порядок выполнения задач ===

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

После того как выбор сделан, вставьте информацию об исполнителе и о сроке.

В информации об исполнителе должно указываться какое-нибудь средство связи с Вами: e-mail, ICQ или jabber. Вы можете написать свои контактные данные в "мою страницу" вики, а в графу "исполнитель" просто поставить подпись.

Срок введен для того, чтобы отсекать "призраков". Представьте что кто-то взял задачу и пропал на долгое время. С одной стороны передавать эту задачу кому-то другому нельзя, потому что она уже занята; с другой — работа стоит.

Срок — это не строгое поле. Если Вы активно работаете над задачей, но не успеваете в срок — Вы всегда можете его отодвинуть. Главное для нас то, что процесс идет.

В поле "срок" следует вписать предполагаемую дату завершения. Максимальный срок, который Вы можете установить — это текущая дата плюс 2 недели, если иное не указано в примечаниях к задаче.

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

=== Порядок приема задач ===

На данный момент у нас нет (публичного) централизованного обменника исходными кодами. Поэтому, высылайте свои труды в архиве на адрес developers (гав) deeptown.org. Либо Вы можете выложить их куда-нибудь в интернет, и выслать ссылку по этому адресу.

=== Условия лицензирования ===

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

Предпочтительной является [http://www.opensource.org/licenses/mit-license.php лицензия MIT], но Вы можете взять другую свободную лицензию или даже написать свою. Однако имейте ввиду: мы ответственно подходим к лицензированию кода, поэтому без внимания мы это не оставим.

Со своей стороны обещаем соблюдать условия лицензии, либо не принимать Ваш код, если нас она не устроит.

=== Графические обозначения ===

Для облегчения навигации по заданиям применено цветовое кодирование сложности поставленной задачи и ее востребованности:

Категории сложности:
: · раз плюнуть ·
: · низкая ·
: · средняя ·
: · выше среднего ·
: · высокая ·

Категории востребованности (приоритет):
: · может подождать ·
: · низкий ·
: · средний ·
: · выше среднего ·
: · высокий ·

== Операторы DSH ==

По сути это команды, но играют роль структурных элементов шеллового языка программирования. Необходимо реализовать команды: true, false, test, if, switch, for, foreach.

* '''Сложность''': · низкая · '''Приоритет''': · высокий ·

* '''Технологии''':
* '''Автор''': --[[Участник:Korvin|Korvin]] 07:38, 18 июня 2008 (EDT)
* '''Примечания''':
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

== Базовые команды оболочки DSH ==

Ниже приведены команды, которые требуется реализовать для нормального функционирования командной оболочки Диптауна (DSH). Дабы не изобретать велосипед, было решено делать команды максимально похожими на их UNIX аналоги. Однако, следует помнить, что при реализации команд, надо учитывать специфику диптауна и ориентироваться на максимальное юзабилити а не стопроцентное соответствие UNIX. Короче говоря, не надо стараться реализовать полный клон команды, со всеми "наворотами" — достаточно только базовых возможностей, которые гарантированно понадобятся и будут полезны.

'''Примечание''': Все без исключения команды должны поддерживать следующие ключи:
;'''--version''': Вывод информации о версии программы и ее авторе.
;'''--help''': Вывод краткой справки по использованию команды. Может выводиться так же при отсутствии какого либо ввода со стороны пользователя (вызов команды без параметров), если это не противоречит логике работы команды.
;'''--''': Индикатор окончания списка параметров. Если в строке параметров встречается данный символ, это означает что дальнейшая информация уже не является параметрами. Например, команды
::<tt>deep$ ls -l</tt>
и
::<tt>deep$ ls -- -l</tt>
:имеют различный смысл. В первом случае вызывается расширенный список файлов текущей директории, тогда как во втором делается попытка отобразить содержимое директории с именем "-l".
;'''-''': Отдельный дефиз может использоваться всесто имени файла для указания того, что данные требуется получать из стандартного устройства ввода. А вывод — соответственно направлять в устройство вывода. Конкретное поведение зависит от используемой команды. Таким образом, следующие команды являются эквивалентами:
::<tt>deep$ cat </tt>
::<tt>deep$ cat - </tt>

=== ls ===

Команда ls (от англ. ''list'' — список) выводит в терминал содержимое некоторой директории. Формат списка, а так же исследуемая директория, задются с помощью соответствующих ключей.

* '''Сложность''': · низкая · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]], [[регулярные выражения]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 07:38, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=ls здесь].
* '''Исполнитель''': [http://ding.deeptown.org Deeptown DING project]
* '''Срок''': не установлен

=== <s>cp</s> ===

Команда cp (от англ. ''copy'' — копировать) производит копирование содержимого указанного каталога в новый каталог.

* '''Сложность''': · низкая · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=cp здесь].
* '''Исполнитель''': [http://ding.deeptown.org Deeptown DING project]
* '''Срок''': реализовано

=== mv ===

Команда mv (от англ. ''move'' — переместить) производит перемещение содержимого указанного каталога в новый каталог, либо переименовывает файлы (каталоги).

* '''Сложность''': · низкая · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=mv здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== <s>rm</s> ===

Команда rm (от англ. ''remove'' — удалить) удаляет файл, либо каталог.

* '''Сложность''': · низкая · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=rm здесь].
* '''Исполнитель''': [http://ding.deeptown.org Deeptown DING project]
* '''Срок''': реализовано

=== <s>touch</s> ===

Команда touch (от англ. ''touch'' — потрогать) создает пустой файл с указанным именем, либо изменяет время доступа существующего файла.

* '''Сложность''': · раз плюнуть · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=touch здесь].
* '''Исполнитель''': [http://ding.deeptown.org Deeptown DING project]
* '''Срок''': реализовано

=== mkdir ===

Команда mkdir (от англ. ''make directory'') создает директорию с указанным именем.

* '''Сложность''': · раз плюнуть · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=mkdir здесь].
* '''Исполнитель''': Deeptown DING project
* '''Срок''': не установлен

=== grep ===

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

* '''Сложность''': · низкая · '''Приоритет''': · выше среднего ·

* '''Технологии''': [[DISS]], [[регулярные выражения]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=grep здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== sed ===

Команда sed (от англ. ''stream editor'' — редактор потоков) производит фильтрацию своего входного потока и выдает результат в выходной поток. Следует иметь в виду, что реализация PCRE (используемая в К++) синтаксически отличается от канонической UNIX. Основная задача — преобразование данных по шаблону.

* '''Сложность''': · низкая · '''Приоритет''': · низкий ·

* '''Технологии''': [[DISS]], [[регулярные выражения]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=sed здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== wc ===

Команда wc (от англ. ''word counter'' — счетчик слов) производит подсчет количества структурных элементов в своем входном потоке и выдает результат в выходной поток. В качестве таких элементов могут выступать символы (ключ <tt>-c</tt>), строки (ключ <tt>-l</tt>) и др. Таким образом, простейший способ подсчета количества строк в файле может выглядеть так:
:<tt>deep$ cat myfile | wc -l</tt>

* '''Сложность''': · низкая · '''Приоритет''': · низкий ·

* '''Технологии''': [[DISS]], [[регулярные выражения]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=wc здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== nl ===

Команда nl (от англ. ''numbered lines'' — пронумерованные строки) записывает в стандартный поток вывода данные из своего стандартного потока ввода, предворяя их номерами строк. Может использоваться для формирования листингов программ, составления отчетов и др.

* '''Сложность''': · раз плюнуть · '''Приоритет''': · низкий ·

* '''Технологии''':
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=nl здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== sort ===

Команда sort производит сортировку данных из своего входного потока и выдает результат в выходной поток.

* '''Сложность''': · низкая · '''Приоритет''': · низкий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=sort здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== head ===

Команда head возвращает первые N строк из своего входного потока.

* '''Сложность''': · раз плюнуть · '''Приоритет''': · низкий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=head здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== tail ===

Команда head возвращает последние N строк из своего входного потока.

* '''Сложность''': · раз плюнуть · '''Приоритет''': · низкий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=tail здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== more ===

Команда more выводит данные из своего входного потока порциями по N строк. Используется для постепенного отображения содержимого буфера в консоль (так, чтобы пользователь успел все прочитать).

* '''Сложность''': · раз плюнуть · '''Приоритет''': · высокий ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=more здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== mount ===

Команда mount используется для привязки носителей данных к файловой системе Диптауна. Принципы ее работы несколько отличаются от UNIX аналога, поэтому документация не дается. Для получения информации, необходимо [[Обратная связь|связаться с разработчиками]].

* '''Сложность''': · низкая · '''Приоритет''': · выше среднего ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''':
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== chmod ===

Команда chmod используется для изменения прав доступа к файлам в файловой системе Диптауна. Принципы ее работы несколько отличаются от UNIX аналога, поэтому документация не дается. Для получения информации, необходимо [[Обратная связь|связаться с разработчиками]].

* '''Сложность''': · низкая · '''Приоритет''': · выше среднего ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''':
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== chown ===

Команда chown используется для изменения владельца и группы файлов в файловой системе Диптауна.

* '''Сложность''': · низкая · '''Приоритет''': · средний ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=chown здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== chattr ===

Команда chattr используется для изменения атрибутов файлов (в основном метаинформации) в файловой системе Диптауна. Принципы ее работы несколько отличаются от UNIX аналога, поэтому документация не дается. Для получения информации, необходимо [[Обратная связь|связаться с разработчиками]].

* '''Сложность''': · низкая · '''Приоритет''': · средний ·

* '''Технологии''': [[DISS]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''':
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== su ===

Команда su (от англ. ''switch user'' — переключить пользователя) используется для запуска подоболочки от имени другого пользователя.

* '''Сложность''': · низкая · '''Приоритет''': · низкий ·

* '''Технологии''': [[UserDB]], [[DSH]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=su здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== sudo ===

Команда sudo позволяет выполнить команду от имени другого пользователя.

* '''Сложность''': · низкая · '''Приоритет''': · низкий ·

* '''Технологии''': [[UserDB]], [[DSH]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=sudo здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

=== passwd ===

Команда passwd позволяет сменить пароль пользователя.

* '''Сложность''': · низкая · '''Приоритет''': · средний ·

* '''Технологии''': [[UserDB]], [[DSH]]
* '''Автор''': --[[Участник:Korvin|Korvin]] 08:24, 18 июня 2008 (EDT)
* '''Примечания''': Описание UNIX аналога команды можно найти [http://www.opennet.ru/man.shtml?topic=passwd здесь].
* '''Исполнитель''': не назначен (вакансия)
* '''Срок''': не установлен

== Стандартный интерфейс SQL ==
== Универсальный HTTP клиент ==
== Универсальный HTTP сервер ==
== Репозиторий медиаданных ==

K++

2009-04-22T09:11:20Z

Korvin:

__NOTOC__
[[Изображение:head.png]]

По мере разработки платформы Диптаун, нами была осознана необходимость создания удобного и универсального средства для управления платформой. Изначально, мы хотели реализовать ее так, чтобы платформа была максимально гибкой и расширяемой; чтобы она позволяла вносить изменения практически в любую ее часть без необходимости пересмотра и переработки системы в целом. Неотъемлемой частью существующей реализации является [[виртуальная машина Gide]], которая берет на себя большую часть задач по управлению различными частями платформы и организации их взаимодействия. Gide применяется практически во всех задачах: начиная от генерации процедурных текстур и до пользовательского интерфейса; от управления аватарами и до программирования объектов виртуального пространства.

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

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

Исключительными правами на язык К++ и на документацию к нему обладают его авторы. Копирование, распространение, а так же использование в других целях программ, текстов документации или любых их частей возможно только по письменному разрешению авторов.
* © Дмитрий Кашицын, 2007-2009
* © Дмитрий Роот, 2007-2009

== Введение ==

# [[Предисловие]]
## [[Предисловие#Роль K++ в проекте Диптаун|Роль K++ в проекте Диптаун]]
## [[Предисловие#Почему именно K++?|Почему именно K++?]]
## [[Предисловие#Для кого эта книга|Для кого эта книга]]
## [[Предисловие#Стиль изложения материала|Стиль изложения материала]]
## [[Предисловие#Тесная взаимосвязь с gide|Тесная взаимосвязь с gide]]
## [[Предисловие#Принятые обозначения|Принятые обозначения]]
# [[История создания языка]]
# [[Идеология языка]]
## [[Идеология языка#Немного теории о языках программирования|Немного теории о языках программирования]]
## [[Идеология языка#Компиляторы и интерпретаторы|Компиляторы и интерпретаторы]]
## [[Идеология языка#Парадигменность|Парадигменность]]
## [[Идеология языка#Понятие о типизации|Понятие о типизации]]
## [[Идеология языка#Управление памятью|Управление памятью]]
## [[Идеология языка#Понятие исключения|Понятие исключения]]

== Основы языка ==

# [[Введение, или краткий обзор]]
## [[Введение, или краткий обзор#Здравствуй, мир!|Здравствуй, мир!]]
## [[Введение, или краткий обзор#Более сложный пример|Более сложный пример]]
## [[Введение, или краткий обзор#Использование блоков|Использование блоков]]
## [[Введение, или краткий обзор#Расширение классов|Расширение классов]]
# [[Переменные]]
## [[Переменные#Понятие переменной, тип переменной|Понятие переменной, тип переменной]]
## [[Переменные#Статическая типизация на примере C++|Статическая типизация на примере C++]]
## [[Переменные#Динамическая типизация на примере Ruby|Динамическая типизация на примере Ruby]]
## [[Переменные#Полудинамическая типизация|Полудинамическая типизация]]
## [[Переменные#Типизация при объявлении|Типизация при объявлении]]
## [[Переменные#Типизация при инициализации|Типизация при инициализации]]
## [[Переменные#Нетипированные (динамические) переменные|Нетипированные (динамические) переменные]]
## [[Переменные#О важности инициализации переменных|О важности инициализации переменных]]
# [[Константы]]
## [[Константы#Понятие константы|Понятие константы]]
## [[Константы#Константные объекты|Константные объекты]]
## [[Константы#Константные функции|Константные функции]]
# [[Замечания об эффективности кода]]
## [[Замечания об эффективности кода#О пользе типов|О пользе типов]]
## [[Замечания об эффективности кода#О пользе спецификаторов доступа|О пользе спецификаторов доступа]]
# [[Приведение типов]]

== Синтаксис языка ==

# [[Классы и объекты]]
## [[Классы и объекты#История развития ООП|История развития ООП]]
### [[Классы и объекты#Возникновение языков программирования|Возникновение языков программирования]]
### [[Классы и объекты#Появление ассемблера|Появление ассемблера]]
### [[Классы и объекты#Концепция языка высокого уровня|Концепция языка высокого уровня]]
### [[Классы и объекты#Структурное программирование|Структурное программирование]]
### [[Классы и объекты#Объектно-ориентированное программирование|Объектно-ориентированное программирование]]
## [[Классы и объекты#Понятие класса|Понятие класса]]
## [[Классы и объекты#Понятие объекта|Понятие объекта]]
## [[Классы и объекты#Наследование|Наследование]]
## [[Классы и объекты#Методы|Методы]]
### [[Классы и объекты#Статические методы|Статические методы]]
### [[Классы и объекты#Конструкторы|Конструкторы]]
## [[Классы и объекты#Поля|Поля]]
## [[Классы и объекты#Свойства|Свойства]]
## [[Классы и объекты#Расширения|Расширения]]
# [[Объявление переменных и констант]]
# [[Выражения]]
## [[Выражения#Арифметические операции|Арифметические операции]]
## [[Выражения#Вызов функций|Вызов функций]]
## [[Выражения#Доступ к полям|Доступ к полям]]
## [[Выражения#Операторы|Операторы]]
# [[Стандартные типы данных]]
## [[Стандартные типы данных#Целые числа|Целые числа]]
## [[Стандартные типы данных#Числа с плавающей точкой|Числа с плавающей точкой]]
## [[Стандартные типы данных#Строки|Строки]]
## [[Стандартные типы данных#Интервалы|Интервалы]]
## [[Стандартные типы данных#Массивы и списки|Массивы и списки]]
## [[Стандартные типы данных#Хеши|Хеши]]
## [[Стандартные типы данных#Указатели|Указатели]]
# [[Функции]]
## [[Функции#Объявление|Объявление]]
## [[Функции#Аргументы|Аргументы]]
### [[Функции#Типизация аргументов|Типизация аргументов]]
### [[Функции#Инициализаторы аргументов (значения по умолчанию)|Инициализаторы аргументов (значения по умолчанию)]]
### [[Функции#Модификаторы и копирование|Модификаторы и копирование]]
### [[Функции#Функции с переменным списком аргументов|Функции с переменным списком аргументов]]
## [[Функции#Возврат значения|Возврат значения]]
## [[Функции#Локальные переменные|Локальные переменные]]
### [[Функции#Объявление|Объявление]]
### [[Функции#Область видимости|Область видимости]]
## [[Функции#Экспортирование функций|Экспортирование функций]]
## [[Функции#Перегрузка функций и операторов|Перегрузка функций и операторов]]
### [[Функции#Особенности применения|Особенности применения]]
### [[Функции#Применение перегрузки в расширениях|Применение перегрузки в расширениях]]
# [[Блоки]]
## [[Блоки#Применение блоков|Применение блоков]]
## [[Блоки#Отличие от функций|Отличие от функций]]
## [[Блоки#Типизация параметров|Типизация параметров]]
## [[Блоки#Встроенные блоки|Встроенные блоки]]
# [[Основные синтаксические конструкции]]
## [[Основные синтаксические конструкции#Условный оператор|Условный оператор]]
### [[Основные синтаксические конструкции#Оператор if|Оператор if]]
### [[Основные синтаксические конструкции#Оператор if-else|Оператор if-else]]
### [[Основные синтаксические конструкции#Оператор if-elsif-else|Оператор if-elsif-else]]
### [[Основные синтаксические конструкции#Постфиксные операторы|Постфиксные операторы]]
### [[Основные синтаксические конструкции#Тернарный условный оператор|Тернарный условный оператор]]
## [[Основные синтаксические конструкции#Оператор множественного выбора (switch)|Оператор множественного выбора (switch)]]
## [[Основные синтаксические конструкции#Циклы|Циклы]]
### [[Основные синтаксические конструкции#Цикл while|Цикл while]]
### [[Основные синтаксические конструкции#Цикл for|Цикл for]]
### [[Основные синтаксические конструкции#Цикл foreach|Цикл foreach]]
### [[Основные синтаксические конструкции#Управление циклами|Управление циклами]]
### [[Основные синтаксические конструкции#Понятие бесконечного цикла|Понятие бесконечного цикла]]
### [[Основные синтаксические конструкции#Взаимозаменяемость циклических структур|Взаимозаменяемость циклических структур]]
# [[Обработка исключений]]
## [[Обработка исключений#Идеология исключений|Идеология исключений]]
## [[Обработка исключений#Объект исключения|Объект исключения]]
## [[Обработка исключений#Генерация исключения|Генерация исключения]]
## [[Обработка исключений#Перехват исключений|Перехват исключений]]
# [[Управление пакетами]]
## [[Управление пакетами#Принципы организации кода|Принципы организации кода]]
## [[Управление пакетами#Импортирование библиотек, ключевое слово import|Импортирование библиотек, ключевое слово import]]
## [[Управление пакетами#Ключевое слово package|Ключевое слово package]]
## [[Управление пакетами#Спецификаторы доступа|Спецификаторы доступа]]
# [[Пространства имен]]

== Регулярные выражения ==
# [[История создания регулярных выражений]]
# [[Применение регулярных выражений]]
## [[Применение регулярных выражений#Зачем нужны регулярные выражения|Зачем нужны регулярные выражения]]
## [[Применение регулярных выражений#Преимущества регулярных выражений|Преимущества регулярных выражений]]
## [[Применение регулярных выражений#Применение регулярных выражений на примере разбора лог файла|Применение регулярных выражений на примере разбора лог файла]]
# [[Синтаксис регулярных выражений]]
## [[Синтаксис регулярных выражений#Классы символов|Классы символов]]
## [[Синтаксис регулярных выражений#Заполнители|Заполнители]]
## [[Синтаксис регулярных выражений#Квантификаторы|Квантификаторы]]

== Операторы ==

# [[Обзор операторов]]
# [[Типы операторов]]
## [[Типы операторов#Арифметические|Арифметические]]
## [[Типы операторов#Операторы сравнения|Операторы сравнения]]
## [[Типы операторов#Операторы присваивания|Операторы присваивания]]
## [[Типы операторов#Операторы приведения типов|Операторы приведения типов]]
## [[Типы операторов#Оператор индексного доступа|Оператор индексного доступа]]
## [[Типы операторов#Оператор вызова функции|Оператор вызова функции]]
## [[Типы операторов#Аксессоры и мутаторы|Аксессоры и мутаторы]]
# [[Использование операторов]]

== Системная библиотека ==

== GIDE ==

# [[Идеология gide]]
# [[Виртуальная машина gide]]
# [[Стандартная библиотека gide]]

[[Рабочие заметки]]

Release Notes

2008-11-26T10:11:50Z

Korvin:

<H2>''' Старьё! ''' </H2>

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

Прежде чем написать [[Bugzilla|отчет об ошибке]], проверьте - нет ли этой ошибки в данном списке.

== Ядро ==

* остается неисправленной ошибка с корректным завершением работы. Проблема кроется в сетевом движке.

== Компилятор [[K++]] ==

* исходный код стандартной библиотеки K++: [http://dao.deeptown.org/misc/kpp.kpp kpp.kpp]
* не обрабатываются спецификаторы доступа. Т.е. все, что может быть экспортировано из класса или из модуля - экспортируется из него, а ключевые слова private, protected и public игнорируются.
* для объектов, работающих с консолью (STDIN, STDOUT, STDERR) в стандартной библиотеке не реализованы оберточные более удобные классы. Это связано с тем, что эти переменные устанавливаются только для текущего модуля, и из стандартной библиотеки недоступны. Ошибка будет исправлена путем изменения механизма передачи этих объектов пользовательскому коду.
* не доработан интерфейс класса string в плане удобства его использования.

== Подсветка синтаксиса ==

Пользователи KDE, для удобства работы с исходными текстами программ, могут установить написанные нами схемы подсветки синтаксиса для Katepart. После установки схем подсветки, все редакторы, которые используют этот виджет (Kate, KWrite, KDevelop, Krusader и др.), автоматически смогут правильно подсвечивать синтаксис исходных текстов, написанных на K++ и на Gide, а так же расставлять маркеры для свертки кода (code folding).

Чтобы установить схемы подсветки, необходимо скачать их XML описания:
* [http://dao.deeptown.org/misc/kpp.xml Для K++]
* [http://dao.deeptown.org/misc/gide.xml Для Gide]

А затем скопировать их в одну из нижеприведенных директорий:
~/.kde/share/apps/katepart/syntax/
<путь к системным файлам kde>/<версия>/share/apps/katepart/syntax/

Узнать место установки kde в вашей системе, как правило можно с помощью переменной среды KDEDIRS. Если схема будет установлена в системную директорию, то она будет доступна всем пользователям, а не только текущему.

О проекте

2008-11-25T22:37:34Z

Korvin: /* Участие */

== Для кого эта wiki ==

Наконец-то, после долгих лет разработки, проект [http://www.deeptown.org/ Deeptown] вплотную подобрался к этапу открытого тестирования. До этого момента разработка проекта велась в основном "вглубь" — мы проектировали основные технологии и писали реализацию их основ — т.е. скелет проекта. Теперь же, когда ядро платформы почти готово и, хоть и со скрипом, но работает, можно приступать к разработке приложений на его основе.

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

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

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

Остальные сервисы включают в себя:
* [[Deeptown SDK|Deeptown Software Development Kit]] — набор программ и утилит для разработки системных и пользовательских приложений;
* [[Багтрекер]] — для отчетов об ошибках;
* [[Рассылка|Почтовая рассылка]] — включает в себя два списка рассылки: рассылку новостей и рассылку для обратной связи с разработчиками.

== Участие ==

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

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

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

== Некоторые понятия ==
Наше название: '''Проект «Диптаун»''' 
По-английски: '''«Deeptown project»''' 
Слово «Deeptown» принято переводить как '''«Город-в-Глубине»''' 
 
Наш официальный сайт: [http://www.deeptown.org www.deeptown.org] 
Наш официальный баннер: [[Изображение:Deep_1_88x31.gif|Официальный баннер для сайта 'deeptown.org']]

Class

2008-11-25T22:31:45Z

Korvin: /* getStaticMethod */

Основной задачей класса <tt>Class</tt> является предоставление механизма рефлексии. Сущность его заключается в том, что программист может получить инетресующую его информацию о классах и объектах прямо по ходу выполнения программы. В то время как класс <tt>[[Object]]</tt> ставит своей задачей управление собственно объектами, то есть инстанциями классов, класс <tt>Class</tt> используется для управления самими классами от которых были порождены соответствующие объекты. Ирония заключается в том что инстанции класса <tt>Class</tt>, будучи потомками класса <tt>[[Object]]</tt>, сами представляют классы.

'''Родители''': <tt>[[Object]]</tt> 
'''Методы''': <tt>[[#name|name]] [[#parents|parents]] [[#childOf|childOf]] [[#managed|managed]] [[#inspect|inspect]] [[#hasStaticMethod|hasStaticMethod]] [[#getStaticMethod|getStaticMethod]]</tt> 
'''Реализует операторы''':
<tt>[[#оператор ==|==]]</tt>,
<tt>[[#оператор <>|<>]]</tt>

__NOTOC__

== оператор == ==

operator == (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

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

<source lang="kpp">
var x = (5.class == 6.class); //значение: истина
var x = ('5'.class == 6.class); //значение: ложь
</source>

== оператор <> ==

operator <> (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

Инверсия оператора "<tt>[[#оператор ==|==]]</tt>".

'''Примечание:''' В языке К++ используется форма "<tt>!=</tt>".

== name ==

'''Возвращает''': <tt>[[string]]</tt> 

Метод возвращает имя класса. Эквивалент <tt>[[Object#className|Object:className]]</tt>.

== parents ==

'''Возвращает''': <tt>[[array]]<[[string]]></tt> 

Метод возвращает массив имен классов-родителей.

'''Примечание:''' Результирующий массив создается по требованию при каждом вызове метода. Поэтому, при необходимости итерирования следует сначала сохранить полученный массив в переменную, а затем работать уже с ней:
<source lang="kpp">
var my = new MyClass;
const parents = my.class.parents;
for (var i = 0 ; i < parents.size; i++)
//обработка полученных данных
</source>
либо
<source lang="kpp">
var my = new MyClass;
my.class.parents.each() { |parent| /* обработка полученных данных */; };
</source>

== childOf ==

childOf(''имя класса:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, унаследован ли текущий класс от указанного класса.

== managed ==

'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий класс [[управляемые и неуправляемые классы|управляемым]] или нет.

== inspect ==

'''Возвращает''': <tt>[[string]]</tt> 

Возвращает информацию о классе. См. также <tt>[[Object#inspect|Object:inspect]]</tt>.

== hasStaticMethod ==

hasStaticMethod(''имя статического метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

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

== getStaticMethod ==

getStaticMethod(''имя статического метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': <tt>[[Method]]</tt> 

Данный метод возвращает статический метод класса в виде объекта. Впоследствии, этот объект может использоваться для удаленного вызова метода, либо для получения дополнительной информации. При попытке получения несуществующего метода будет возбуждено исключение <tt>[[Классы исключений#ENotFound|ENotFound]]</tt>.

Пример использования:
<source lang="kpp">
var rnd = System.getClass('std/int').getStaticMethod('random');
var x = rnd();
</source>

В вышеприведенном примере, с помощью класса <tt>[[System]]</tt>, мы получаем класс <tt>[[int]]</tt> и создаем объект, соответствующий статическому методу <tt>random</tt>. Объект метода сохраняется в переменной ''rnd''. Обращаясь к этой переменной как к функции, мы неявным образом вызываем сам метод.

Class

2008-11-25T22:30:51Z

Korvin: /* getStaticMethod */

Основной задачей класса <tt>Class</tt> является предоставление механизма рефлексии. Сущность его заключается в том, что программист может получить инетресующую его информацию о классах и объектах прямо по ходу выполнения программы. В то время как класс <tt>[[Object]]</tt> ставит своей задачей управление собственно объектами, то есть инстанциями классов, класс <tt>Class</tt> используется для управления самими классами от которых были порождены соответствующие объекты. Ирония заключается в том что инстанции класса <tt>Class</tt>, будучи потомками класса <tt>[[Object]]</tt>, сами представляют классы.

'''Родители''': <tt>[[Object]]</tt> 
'''Методы''': <tt>[[#name|name]] [[#parents|parents]] [[#childOf|childOf]] [[#managed|managed]] [[#inspect|inspect]] [[#hasStaticMethod|hasStaticMethod]] [[#getStaticMethod|getStaticMethod]]</tt> 
'''Реализует операторы''':
<tt>[[#оператор ==|==]]</tt>,
<tt>[[#оператор <>|<>]]</tt>

__NOTOC__

== оператор == ==

operator == (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

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

<source lang="kpp">
var x = (5.class == 6.class); //значение: истина
var x = ('5'.class == 6.class); //значение: ложь
</source>

== оператор <> ==

operator <> (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

Инверсия оператора "<tt>[[#оператор ==|==]]</tt>".

'''Примечание:''' В языке К++ используется форма "<tt>!=</tt>".

== name ==

'''Возвращает''': <tt>[[string]]</tt> 

Метод возвращает имя класса. Эквивалент <tt>[[Object#className|Object:className]]</tt>.

== parents ==

'''Возвращает''': <tt>[[array]]<[[string]]></tt> 

Метод возвращает массив имен классов-родителей.

'''Примечание:''' Результирующий массив создается по требованию при каждом вызове метода. Поэтому, при необходимости итерирования следует сначала сохранить полученный массив в переменную, а затем работать уже с ней:
<source lang="kpp">
var my = new MyClass;
const parents = my.class.parents;
for (var i = 0 ; i < parents.size; i++)
//обработка полученных данных
</source>
либо
<source lang="kpp">
var my = new MyClass;
my.class.parents.each() { |parent| /* обработка полученных данных */; };
</source>

== childOf ==

childOf(''имя класса:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, унаследован ли текущий класс от указанного класса.

== managed ==

'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий класс [[управляемые и неуправляемые классы|управляемым]] или нет.

== inspect ==

'''Возвращает''': <tt>[[string]]</tt> 

Возвращает информацию о классе. См. также <tt>[[Object#inspect|Object:inspect]]</tt>.

== hasStaticMethod ==

hasStaticMethod(''имя статического метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

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

== getStaticMethod ==

getStaticMethod(''имя статического метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': <tt>[[Method]]</tt> 

Данный метод возвращает статический метод класса в виде объекта. Впоследствии, этот объект может использоваться для удаленного вызова метода, либо для получения дополнительной информации. При попытке получения несуществующего метода будет возбуждено исключение <tt>[[Классы исключений#ENotFound|ENotFound]]</tt>.

Пример использования:
<source lang="kpp">
var rnd = System.getClass('std/int').getStaticMethod('random');
var x = rnd();
</source>

В вышеприведенном примере, с помощью класса <tt>[[System]]</tt>, мы получаем класс <tt>[[int]]</tt> и создаем объект, соответствующий статическому методу <tt>random</tt>. Объект метода сохраняется в переменной ''c''. Обращаясь к этой переменной как к функции, мы неявным образом вызываем сам метод.

Class

2008-11-25T22:29:08Z

Korvin: /* parents */

Основной задачей класса <tt>Class</tt> является предоставление механизма рефлексии. Сущность его заключается в том, что программист может получить инетресующую его информацию о классах и объектах прямо по ходу выполнения программы. В то время как класс <tt>[[Object]]</tt> ставит своей задачей управление собственно объектами, то есть инстанциями классов, класс <tt>Class</tt> используется для управления самими классами от которых были порождены соответствующие объекты. Ирония заключается в том что инстанции класса <tt>Class</tt>, будучи потомками класса <tt>[[Object]]</tt>, сами представляют классы.

'''Родители''': <tt>[[Object]]</tt> 
'''Методы''': <tt>[[#name|name]] [[#parents|parents]] [[#childOf|childOf]] [[#managed|managed]] [[#inspect|inspect]] [[#hasStaticMethod|hasStaticMethod]] [[#getStaticMethod|getStaticMethod]]</tt> 
'''Реализует операторы''':
<tt>[[#оператор ==|==]]</tt>,
<tt>[[#оператор <>|<>]]</tt>

__NOTOC__

== оператор == ==

operator == (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

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

<source lang="kpp">
var x = (5.class == 6.class); //значение: истина
var x = ('5'.class == 6.class); //значение: ложь
</source>

== оператор <> ==

operator <> (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

Инверсия оператора "<tt>[[#оператор ==|==]]</tt>".

'''Примечание:''' В языке К++ используется форма "<tt>!=</tt>".

== name ==

'''Возвращает''': <tt>[[string]]</tt> 

Метод возвращает имя класса. Эквивалент <tt>[[Object#className|Object:className]]</tt>.

== parents ==

'''Возвращает''': <tt>[[array]]<[[string]]></tt> 

Метод возвращает массив имен классов-родителей.

'''Примечание:''' Результирующий массив создается по требованию при каждом вызове метода. Поэтому, при необходимости итерирования следует сначала сохранить полученный массив в переменную, а затем работать уже с ней:
<source lang="kpp">
var my = new MyClass;
const parents = my.class.parents;
for (var i = 0 ; i < parents.size; i++)
//обработка полученных данных
</source>
либо
<source lang="kpp">
var my = new MyClass;
my.class.parents.each() { |parent| /* обработка полученных данных */; };
</source>

== childOf ==

childOf(''имя класса:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, унаследован ли текущий класс от указанного класса.

== managed ==

'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий класс [[управляемые и неуправляемые классы|управляемым]] или нет.

== inspect ==

'''Возвращает''': <tt>[[string]]</tt> 

Возвращает информацию о классе. См. также <tt>[[Object#inspect|Object:inspect]]</tt>.

== hasStaticMethod ==

hasStaticMethod(''имя статического метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

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

== getStaticMethod ==

getStaticMethod(''имя статического метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': <tt>[[Method]]</tt> 

Данный метод возвращает статический метод класса в виде объекта. Впоследствии, этот объект может использоваться для удаленного вызова метода, либо для получения дополнительной информации. При попытке получения несуществующего метода будет возбуждено исключение <tt>[[Классы исключений#ENotFound|ENotFound]]</tt>.

Пример использования:
<source lang="kpp">
var c = System.getClass('std/int').getStaticMethod('random');
var rnd = c();
</source>

В вышеприведенном примере, с помощью класса <tt>[[System]]</tt>, мы получаем класс <tt>[[int]]</tt> и создаем объект, соответствующий статическому методу <tt>random</tt>. Объект метода сохраняется в переменной ''c''. Обращаясь к этой переменной как к функции, мы неявным образом вызываем сам метод.

Object

2008-11-25T22:20:41Z

Korvin: /* inspect */

Класс <tt>Object</tt> является сердцем всей стандартной библиотеки и ее центральным классом. Все остальные классы, прямо или косвенно наследуются от <tt>Object</tt>, что позволяет реализовывать централизованное управление и сбор информации об объектах. Данный класс имеет набор методов которые реализуют механизм рефлексии, который заключается в том, что объекты могут динамически получать информацию о других объектах (включая самих себя). Например, объект A может узнать, какие методы имеет объект B, и на основании этой информации выполнять те или иные действия.

Класс <tt>Object</tt> вводит понятие инспектирования объектов, которое позволяет получать сведения о содержимом объектов в удобной для восприятия форме (это может быть особенно полезно при отладке и трассировке программ).

'''Родители''': <tt>Object</tt> 
'''Методы''': <tt>[[#class|class]] [[#className|className]] [[#instanceOf|instanceOf]] [[#call|call]] [[#invoke|invoke]] [[#freeze|freeze]] [[#frozen|frozen]] [[#clone|clone]] [[#dup|dup]] [[#inspect|inspect]] [[#equals|equals]] [[#hasMethod|hasMethod]] [[#getMethod|getMethod]] [[#methods|methods]]</tt> 
'''Реализует операторы''': <tt>[[#equals|==]]</tt>

__NOTOC__

== class ==

'''Возвращает''': <tt>[[Class]]</tt> 

Метод возвращает инстанцию класса <tt>[[Class]]</tt>, соответствующую классу данного объекта. Например:
<source lang="kpp">
var x = 1; //переменная типа int
var c = x.class; //переменная типа Class
puts(c.name); //выведет на экран строку "int"
</source>

== className ==

'''Возвращает''': <tt>[[string]]</tt> 

Эквивалент операции <tt>x.class.name</tt>, только работает быстрее (без создания промежуточного объекта)

== instanceOf ==

instanceOf(''имя класса:'' <tt>[[string]]</tt>) 
instanceOf(''класс:'' <tt>[[Class]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий объект инстанцией указанного класса.

== call ==

call(''имя метода:'' <tt>[[string]]</tt>, <tt>'''...'''</tt>) 
'''Возвращает''': динамическую переменную 

Метод позволяет вызывать методы объектов динамически, по их имени. При этом, вызываемому методу передаются все последующие параметры (если таковые имеются). Естественно, никакой проверки типов фактических параметров не производится. Всю работу по приведению типов программист должен осуществлять сам. Пример:
<source lang="kpp">
var ary = new array;
ary.call(:push, 1, 2, 3);
puts(ary.inspect); // [1, 2, 3]
</source>

== invoke ==

invoke(''имя метода:'' <tt>[[string]]</tt>, ''параметры:'' <tt>[[array]]</tt>) 
'''Возвращает''': динамическую переменную 

Метод аналогичен по смыслу методу <tt>[[#call|call]]</tt>, за исключением того, что последующие параметры передаются в массиве. При вызове этот массив будет "развернут", как если бы все параметры были записаны через запятую:
<source lang="kpp">
var ary = new array;
ary.invoke(:push, [1, 2, 3]);
puts(ary.inspect); // [1, 2, 3]
</source>

== freeze ==

'''Возвращает''': текущий объект 

Метод "замораживает" текущий объект, после чего он становится доступным только для чтения. Обратной операции не существует, так что разморозить однажды замороженный объект нельзя.

== frozen ==

'''Возвращает''': [[логическое значение]] 

Проверяет, является ли текущий объект замороженным.

== clone ==

'''Возвращает''': копию текущего объекта 

Метод служит для создания копии текущего объекта, используя оператор "<tt>=</tt>". Если объект (или его класс) располагает таким методом, будет создана пустая инстанция класса, которой будет присвоено значение текущего объекта.

'''Примечание:''' В случае с контейнерами копирование происходит только в том случае, если данный элемент обладает оператором "<tt>=</tt>"; в противном случае, в копии контейнера будет лежать тот же объект:
<source lang="kpp">
var ary = new array;
ary.push(5);
ary.push(Stream.open(...));
var copy = ary.clone;
</source>

В этом примере, переменная ''copy'' будет содержать копию оригинального массива ''ary''. Однако скопирован будет только нулевой элемент массива, то есть объект соответствующий константе 5. Инстанция потока будет передана "как есть".

== dup ==

== inspect ==

'''Возвращает''': <tt>[[string]]</tt> 

Метод преобразует и возвращает информацию об объекте в удобном для восприятия виде. Переопределяется в классах-потомках для отображения более детальной информации. Во многих случаях является аналогом оператора приведения к строке, однако не всегда. Например, в случае K++, для класса строки оператор приведения к типу <tt>[[string]]</tt> возвращает саму строку, тогда как метод <tt>inspect</tt> возвращает строку с восстановленными спецсимволами и заключенную в кавычки:
<source lang="kpp">
var hello = "hello\tworld\n";
puts(hello); //вывод: hello world
puts(hello as string); //вывод: hello world
puts(hello.inspect); //вывод: "hello\tworld\n"
</source>

Другие классы, такие как контейнеры переопределяют метод для отображения своего содержимого. При этом, в коде метода рекурсивно вызывается метод <tt>inspect</tt> самих элементов для отображения их значения:
<source lang="kpp">
var ary = [1, [2,'3'], :x, { :a => 1 }];
puts(ary.inspect); //вывод: [1, [2, "3"], "x", { "a" => 1 }]
</source>

== equals ==

equals(''объект сравнения'') 
operator == (''объект сравнения'') 
'''Возвращает''': [[логическое значение]] 

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

<source lang="kpp">
var x = 5;
var b1 = x.equals(x);
var y = 4 + 1;
var b2 = x.equals(y);
</source>

В этом примере переменная ''b1'' будет истинной, в то время как переменная ''b2'' ложной. Несмотря на то, что переменные ''x'' и ''y'' равны численно — они представлены разными объектами.

'''Примечание:''' В случае с классом <tt>Object</tt> для тех же целей может применяться и оператор <tt>==</tt>, однако предполагается что он должен переопределяться дочерними классами для достижения собственных целей. Сам же метод <tt>equals</tt> переопределяться не должен никогда (для обеспечения оригинального функционала).

== hasMethod ==

hasMethod(''имя метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': [[логическое значение]] 

Проверяет, имеет ли объект указанный метод.

== getMethod ==

getMethod(''имя метода:'' <tt>[[string]]</tt>) 
'''Возвращает''': <tt>[[Method]]</tt> 

Данный метод возвращает метод объекта в виде объекта метода =) Впоследствии, этот объект может использоваться для удаленного вызова метода, либо для получения дополнительной информации. При попытке получения несуществующего метода будет возбуждено исключение <tt>[[Классы исключений#ENotFound|ENotFound]]</tt>.

Пример использования:
<source lang="kpp">
var ary = new array;
var p = ary.getMethod(:push);
p(1, 2, 3);
ary.inspect; //значение: [1, 2, 3]
</source>

== methods ==

'''Возвращает''': <tt>[[array]]<[[string]]></tt> 

Метод возвращает массив имен методов.

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

Array

2008-11-25T22:16:56Z

Korvin: /* индексные операторы */

Класс <tt>array</tt> предназначен для хранения данных в виде цельного блока, что позволяет производить быстрый поиск требуемого элемента на основании его индекса (смещения относительно начала блока). Данный контейнер предполагается использовать в тех случаях, когда требуется высокая скорость доступа к элементам, но операции добавления/удаления элементов просиходят сравнительно редко.

'''Родители''': <tt>[[Object]]</tt> 
'''Методы''': <tt>
[[#индексные операторы|at]]
[[#индексные операторы|set]]
[[#empty|empty]]
[[#size|size]]
[[#size=|size=]]
[[#size=|resize]]
[[#clear|clear]]
[[#push|push]]
[[#pop|pop]]
[[#top|top]]</tt> 
'''Реализует операторы''':
[[#индексные операторы|индексного доступа]],
[[оператор присваивания|присваивания]] 

__NOTOC__

== индексные операторы ==

operator <nowiki>[]</nowiki> (''индекс'': <tt>int</tt>) 
at(''индекс'': <tt>int</tt>) 
'''Возвращает''': <tt>[[Object]]</tt> 

Оператор индексного чтения служит для получения объекта расположенного по указанному индексу. Если указан индекс, выходящий за текущие границы массива, будет сгенерировано исключение <tt>[[Классы исключений#ERangeError|ERangeError]]</tt>.

operator <nowiki>[]=</nowiki> (''индекс'': <tt>int</tt>, ''значение'') 
set(''индекс'': <tt>int</tt>, ''значение'') 
'''Возвращает''': текущий объект 

Оператор индексной записи, напротив, служит для записи объекта по соответствующему индексу. Если указан индекс, выходящий за текущие границы массива, будет сгенерировано исключение <tt>[[Классы исключений#ERangeError|ERangeError]]</tt>.

'''Примечание''': см. [[копирование в контейнерах]].

== empty ==

'''Возвращает''': [[логическое значение]] 

Метод возвращает истину, если массив непуст.

== size ==

'''Возвращает''': <tt>[[int]]</tt> 

Метод возвращает текущее количество элементов массива.

== size= ==

size= (''новый размер'': <tt>[[int]]</tt>) 
resize(''новый размер'': <tt>[[int]]</tt>) 
'''Возвращает''': текущий объект 

Метод устанавливает новый размер массива, сохраняя существующие данные на своих местах. При этом, новые ячейки будут содержать значение <tt>'''null'''</tt>.

== clear ==

'''Возвращает''': текущий объект 

Очищает массив содержимого и сбрасывает внутренний буфер. После этого размер массива считается нулевым.

== push ==

push(''объект'') 
'''Возвращает''': текущий объект 

Метод добавляет переданный объект в конец массива, расширяя массив при необходимости.

'''Примечание''': см. [[копирование в контейнерах]].

== pop ==

'''Возвращает''': <tt>[[Object]]</tt> 

Метод возвращает объект с максимальным индексом и извлекает его из массива. Если сделана попытка извлечь объект из пустого массива, то будет сгенерировано исключение <tt>[[Классы исключений#ERangeError|ERangeError]]</tt>.

== top ==

'''Возвращает''': <tt>[[Object]]</tt> 

Метод возвращает объект с максимальным индексом, оставляя его в массиве. Если сделана попытка извлечь объект из пустого массива, то будет сгенерировано исключение <tt>[[Классы исключений#ERangeError|ERangeError]]</tt>.

Механизмы взаимодействия объектов с окружающей средой

2008-11-02T05:31:19Z

Korvin: /* Взаимодействие объекта с окружающей средой */

Объекты виртуального пространства могут взаимодействовать следующим образом:
* друг с другом
** передавая и получая события;
* с физическим движком
** получая от него уведомления о статусе;
* с пользовательским представлением объекта
** изменяя динамические свойства;
* с пользователем
** получая от него команды ввода;
** высылая ему уведомления;
* с окружающей средой
** управляя моторами;
** получая уведомления от сенсоров.

Рассмотрим эти взаимодействия подробнее.

== Взаимодействие объектов друг с другом. События ==

Между собой объекты "общаются" посредством событий.

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

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

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

== Взаимодействие объекта и физического движка ==

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

На данный момент реализовано лишь одно такое действие — init, уведомляющее объект о том, что он только что был создан.

== Взаимодействие объекта с его пользовательским представлением ==

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

Для передачи такой информации служат свойства объектов. ''Свойства'' — это массив произвольных данных, к которому возможен доступ по имени некоторого конкретного свойства. Описание свойств объекта находится в его файле данных.

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

== Взаимодействие объекта с пользователем ==

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

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

== Взаимодействие объекта с окружающей средой ==

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

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

Мотор задается в файле описания объекта тегом <motor> в корневой секции, например:
<source lang="xml">
<model bxd="http://dao.deeptown.org/bxd/model.bxd">

<motor name="engine" url="linear_speed:cube:(0,1,0)" />
</model>
</source>

Как мы видим, мотор задается именем, по которому к нему потом можно будет обращаться, и URL адресом, в котором указывается тип мотора и его параметры. В приведенном выше примере, тип мотора — <tt>linear_speed</tt> — позволяет объекту управлять силой по какой-либо оси для достижения определенной скорости в абсолютных координатах. Для него в качестве параметра передается имя твердого тела, к которому будет приложена сила, и вектор направления (в локальных координатах объекта) этой силы.

На данный момент это единственный реализованный мотор. В недалеком будущем их будет больше.

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

Механизмы взаимодействия объектов с окружающей средой

2008-11-02T05:25:38Z

Korvin: /* Взаимодействие объектов друг с другом. События */

Объекты виртуального пространства могут взаимодействовать следующим образом:
* друг с другом
** передавая и получая события;
* с физическим движком
** получая от него уведомления о статусе;
* с пользовательским представлением объекта
** изменяя динамические свойства;
* с пользователем
** получая от него команды ввода;
** высылая ему уведомления;
* с окружающей средой
** управляя моторами;
** получая уведомления от сенсоров.

Рассмотрим эти взаимодействия подробнее.

== Взаимодействие объектов друг с другом. События ==

Между собой объекты "общаются" посредством событий.

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

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

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

== Взаимодействие объекта и физического движка ==

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

На данный момент реализовано лишь одно такое действие — init, уведомляющее объект о том, что он только что был создан.

== Взаимодействие объекта с его пользовательским представлением ==

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

Для передачи такой информации служат свойства объектов. ''Свойства'' — это массив произвольных данных, к которому возможен доступ по имени некоторого конкретного свойства. Описание свойств объекта находится в его файле данных.

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

== Взаимодействие объекта с пользователем ==

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

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

== Взаимодействие объекта с окружающей средой ==

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

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

Мотор задается в файле описания объекта тегом <motor> в корневой секции, например:
<source lang="xml">
<model bxd="http://dao.deeptown.org/bxd/model.bxd">

<motor name="engine" url="linear_speed:cube:(0,1,0)" />
</model>
</source>

Как мы видим, мотор задается именем, по которому к нему потом можно будет обращаться, и URL адресом, в котором указывается тип мотора и его параметры. В приведенном выше примере, тип мотора — <tt>linear_speed</tt> — позволяет объекту управлять силой по какой-либо оси для достижения определенной скорости в абсолютных координатах. Для него в качестве параметра передается имя твердого тела, к которому будет приложена сила, и вектор направления (в локальных координатах объекта) этой силы.

На данный момент это единственный реализованный мотор. В недалеком будущем их будет больше.

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

Программирование поведения объекта

2008-11-01T15:49:46Z

Korvin: /* Создание простого объекта */

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

== Где хранить файлы? ==

Ядро Диптауна использует DISS для хранения файлов. По-умолчанию, в корень DISS монтируется директория, которая находится в подкаталоге storage архива media. Таким образом,
* в linux это директория, которая расположена в $DEEPTOWN_MEDIA/storage
* в windows - INSTALL_DIR/Media/storage

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

Далее в документе, везде, где указан путь к файлу, имеется ввиду DISS-путь.

Для хранения объектов, в корне DISS есть подкаталог media, в котором есть следующие подкаталоги:
* materials - для хранения файлов материалов;
* meshes - для графических 3d моделей;
* models - для файлов объектов;
* scenes - для файлов сцен;
* scripts - для файлов скриптов;
* textures - для текстур.

Отметим, что это лишь рекомендованные пути; Вы можете использовать любые другие в пределах DISS.

== Создание простого объекта ==

Для того, чтобы создать объект, нужны
* файл материала;
* файл 3d модели в формате OGRE mesh;
* необходимые материалу текстуры.

Все это можно получить, воспользовавшись одним из конверторов, доступных на [http://www.ogre3d.org/index.php?option=com_content&task=view&id=413&Itemid=133 официальном сайте OGRE].

Пожалуйста, обратите внимание, что все размеры в файле 3d модели должны указываться '''в метрах'''.

Если конвертер создает несколько файлов материалов, нужно объединить их в один (в произвольном порядке). Кроме того, нужно '''переправить пути к текстурам''' в файлах материалов на абсолютные DISS-пути (т.е. '''/media/textures/...''').

Когда все это сделано, остается последний шаг - создать файл модели. Для этого нужно создать XML-файл объекта, который, в простейшем случае, выглядит следующим образом:

<source lang="xml">
<model bxd="http://dao.deeptown.org/bxd/model.bxd">
<material_script node="путь к файлу материала" />
<body name="main_body">
<geometry>

</geometry>
<surfaces>
<mesh name="cube" node="путь к файлу 3d модели" />
</surfaces>
</body>
</model>
</source>

Чтобы теперь сконвертировать этот файл в bxl, воспользуйтесь командой
bxd filename.model.xml -f filename.model

где filename.model.xml - имя исходного файла, filename.model - имя получаемого файла модели.

Для того, чтобы использовать объект локально, необходимо задать его UID, записав его в метаинформацию DISS. В той же директории, где находится этот файл, создайте файл '''.meta''' и напишите туда следующее:
[filename.model]
version = 0.1
wso_node = 1
wso_uid = 0101-0001-00000001-0000000000000001

UID (последняя строчка) должен различаться для каждой копии объекта в пространстве. Если один и тот же объект нужно использовать в сцене несколько раз, можно задать ему несколько UID-ов в метаинформации - задав несколько записей wso_uid.

В самом UID-е можно менять только последний (самый длинный) блок цифр (это шестнадцатиричные цифры, т.е. от 0 до F).

Если в директории находится несколько объектов, дописывайте в .meta секции одну за другой. Файл .meta сканируется при создании индекса DISS, так что при внесении изменений нужно удалять '''.index'''.

=== Создание динамического объекта ===

Объект, приведенный в примере выше, будет статичным, т.е. все время находиться в одном и том же месте пространства (обладать бесконечной массой). Если нужен динамический объект, следует добавить в описание модели информацию о массе и моменте инерции объекта:

<source lang="xml">
<body name="main_body">
<mass_data>
<mass value="1" />
<inertia i11="1" i22="1" i33="1" i12="0" i13="0" i23="0" />
</mass_data>

</body>
</source>

Масса указывается в килограммах.

Момент инерции - в единицах СИ. Параметры - элементы симметричной матрицы инерции:
| i11 i12 i13 |
| i12 i22 i23 |
| i13 i23 i33 |

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

== Связывание объекта со скриптом ==

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

<source lang="xml">
<externals>
<event_receiver url="gide:/media/scripts/my_object.gbc!MyObject" />
</externals>
</source>

В этом случае объект будет передавать все свои события объекту гайд-класса MyObject, объявленного в файле /media/scripts/my_object.gbc.

В этом файле должен находиться '''скомпилированный''' код класса. Простейший, ничего не делающий код такого класса на [[K++]] выглядит следующим образом:

<source lang="kpp">
package my_object;

import world;

class MyObject extends WorldObject
{
export function State_init()
{
}
}
</source>

Напишите этот код в файл my_object.kpp в той же директории. Компилируется он командой
kpp my_object.kpp

== Добавление мотора ==

Мотор - это интерфейс объекта, позволяющий контролировать его поведение.

Все моторы объекта должны быть описаны в его файле модели. Делается это добавлением тега '''motor''' в корневую секцию:
<source lang="xml">
<motor name="engine" url="linear_speed:main_body:(0,1,0)" />
</source>

Такой тег создаст мотор '''engine''' с типом '''linear_speed''', прикладывающий силу к телу '''main_body''' (параметр '''name''' в теге '''body''') по вектору направления (0,1,0) - т.е. вверх.

Всевозможные типы моторов описаны (''еще нигде не описаны, дать ссылку'').

По-умолчанию, мотор будет выключен. Для того, чтобы его включить, добавим в наш код следующее:

<source lang="kpp">
export function State_init()
{
var engine = this.getMotor('engine'); // получили интерфейс мотора
// первый параметр - имя, указанное при создании мотора (см. выше)
engine.setParam('speed', 100); // максимальная скорость, сообщаемая объекту
engine.setParam('force', 100); // максимальная сила, которая будет приложена для разгона
engine.enable(); // включаем мотор
}
</source>

== Обработка пользовательского ввода ==

Теперь научим наш объект реагировать на команду пользователя.

Например, нам нужно, чтобы мотор был включен только пока нажата клавиша A на клавиатуре.

Для этого нужно научить наш объект понимать две команды - "включить" и "выключить", а в конфигурации движка ввода написать отправку команды "включить" на нажатие клавиши, а "выключить" - на ее отпускание.

В файл '''/etc/world/input.conf''' в контекст '''local_control''' нужно добавить следующие строки:
on key_press check(key=A) do send_event:start_engine
on key_release check(key=A) do send_event:stop_engine

Таким образом, когда пользователь нажимает клавишу A, нашему объекту будет отправлено уведомление '''start_engine''', а когда отпускает - '''stop_engine'''.

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

<source lang="kpp">
export function Control_start_engine(const bytea args)
{
this.getMotor('engine').enable();
}

export function Control_stop_engine(const bytea args)
{
this.getMotor('engine').disable();
}
</source>

(предполагается, что параметры мотора были установлены при инициализации, т.е. в State_init).

== Создание сенсора ==

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

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

<source lang="kpp">
export function State_init()
{
// создаем сенсор высоты
this.createSensor('height:>100', 'too_high');
}

export function Signal_too_high(const bytea args)
{
// метод будет вызван при срабатывании сенсора, т.е. когда абсолютная
// высота объекта превысит 100 метров.
this.getMotor('engine').disable();
}
</source>

Имя функции-обработчика формируется из префикса '''Signal_''' и второго параметра функции '''createSensor'''.

== Создание сцены ==

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

Сцена также описывается в формате BXL. XML-файл сцены выглядит довольно просто:

<source lang="xml">
<scene bxd="http://dao.deeptown.org/bxd/scene.bxd">
<model uid="0101-0001-00000001-0000000000000002"
x="0.2" y="0" z="-5"
qw="1" qx="0" qy="0" qz="0" />
</scene>
</source>

Тегов '''model''' может быть сколь угодно много. В параметрах этого тега указываются координаты объекта на сцене и кватернион его поворота.

== Пуск! ==

И теперь остался последний момент - загрузить все это в движок.

Для этого нужно набрать консольную команду
world.local_start /media/scenes/filename.scene UID

Первый параметр - имя файла сцены, второй - UID объекта, которому будет передаваться ввод пользователя.

Понятие объекта в пространстве

2008-11-01T15:30:36Z

Korvin: /* Представления объекта */

== Введение ==

Ключевым понятием в World Engine является Объект. Под этим понятием подразумевается некоторая атомарная сущность, которая может взаимодействовать с:
* пространством
* пользователем
* другими объектами.

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

== Представления объекта ==

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

В '''механическом''' пространстве, объект представляет собой одно или несколько твердых тел, каждое из которых характеризуется:
* массой,
* матрицей момента инерции,
* координатами,
* [http://www.gamedev.ru/users/wat/articles/quaternions кватернионом] вращения.

Обратите внимание, что в механическом пространстве '''отсутствует''' какая-либо информация о '''форме''' объекта.

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

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

Под примитивом здесь понимается один из нескольких геометрических примитивов: паралеллепипед, сфера, цилиндр и несколько других.

В '''графическом''' пространстве, объект представляет собой набор графических примитивов, таких как:
* полигональные поверхностей с различными графическими свойствами (начиная от текстурирования и заканчивая шейдерами),
* источники освещения,
* камеры.
Графическая модель также связана с механическим или физическим представлением — т.е. движок автоматически изменяет положение графических примитивов в соответствии с перемещениями физических.

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

# ''Аватар''. Имеет представления во всех трех пространствах. Является полноценным "физическим" объектом.
# ''Фаербол'', эмиттеры частиц (дым, огонь и т. д) либо другие графические фокусы. Представляются в графическом пространстве.
# ''Поля сил'' как проявления заклинаний или обычного ветра. Представляются в физическом пространстве.

== Данные объекта ==

Данные объекта хранятся в [[DISS]] файле в формате [[BXL]]. Объект также может зависеть от других файлов (скрипты, текстуры и др.), ссылки на которые приводятся в основном файле.

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

Все примеры приведены в формате XML; для конвертирования из XML в BXL существует утилита bxd — на данный момент она реализована на Perl. Для конвертирования объекта, наберите команду
bxd filename.model.xml -f filename.model
где filename.model.xml — имя файла с XML описанием.

=== Простейший физический объект ===

Рассмотрим пример файла, описывающего куб размером 1x1x1:

<source lang="xml" line="1">
<model bxd="http://dao.deeptown.org/bxd/model.bxd">
<material_script node="/media/materials/cube.material" />
<body name="cube">
<geometry>
<geom type="box" width="1" height="1" depth="1" />
</geometry>
<surfaces>
<mesh name="cube" node="/media/meshes/cube_small.mesh" />
</surfaces>
</body>
</model>
</source>

;1-11:Все описание объекта заключено в тег '''model''', у которого нет параметров (кроме стандартной ссылки на BXD-описание для корректного конвертирования в BXL);
;2:Тег '''material_script''' указывает на путь к файлу описания материалов. Формат этого файла описан в [http://www.ogre3d.org/docs/manual/manual_14.html документации OGRE]. Важно отметить, что внутри этого файла, все ссылки на текстуры, шейдеры и пр. делаются также указанием DISS-пути к соответствующему файлу;
;3:Тег '''body''' описывает '''твердое тело''', которое становится частью нашего объекта. В рамках одного объекта таких тел может быть несколько — каждое из них будет описываться отдельным тегом body;
;4:В рамках тега '''geometry''' содержится информация о геометрических примитивах, связанных с данным твердым телом, т.е. о его физическом представлении;
;5:Куб в пространстве легко описывается примитивом '''box''' — паралеллепипедом с указанными шириной, высотой и глубиной (оси x, y и z соответственно). Обратите внимание, что по-умолчанию примитив находится в центре локальных координат данного твердого тела. Сместить его можно тегом '''position''', следующим образом:
<source lang="xml">
<geom type="box" width="1" height="1" depth="1">
<position x="1" y="0" z="0" />
</geom>
</source>
:Такая конструкция сместила бы примитив на 1 (метр) по оси X относительно локальных координат твердого тела. Аналогично, тегом '''rotation''' с параметрами qw, qx, qy и qz можно задать кватернион вращения данного примитива относительно локальной системы координат.
;7-9:В рамках тега '''surfaces''' задаются графические примитивы, связанные с объектом. В нашем случае такой примитив только один: тег '''node''' указывает имя файла с графическим описанием куба в формате OGRE Mesh (конвертеры в этот формат можно скачать с [http://www.ogre3d.org официального сайта OGRE], там также имеется [http://www.ogre3d.org/wiki/index.php/OGRE_DCC_Tools набор инструментов] для создания графического контента).

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

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

=== Более сложный пример ===

Вот пример более сложной модели куба:

<source lang="xml" line="1">
<model bxd="http://dao.deeptown.org/bxd/model.bxd">
<material_script node="/media/materials/cube.material" />
<body name="cube">
<mass_data>
<mass value="1" />
</mass_data>
<geometry>
<geom type="box" width="1" height="1" depth="1" />
</geometry>
<surfaces>
<mesh name="cube" node="/media/meshes/cube_small.mesh" />
</surfaces>
</body>
<externals>
<event_receiver url="gide:/media/scripts/cube_small_dynamic.gbc!CubeSmallDynamic" />
</externals>
</model>
</source>

Рассмотрим теги, которые были добавлены в этот файл:
;4-6:Тег '''mass_data''' определяет механическое представление тела. В нем можно задать массу (тег '''mass''') и матрицу инерции (не указанный здесь тег '''inertia'''), которая по-умолчанию является единичной матрицой.
;14-16:В теге '''externals''' приводятся дополнительные данные объекта. В данном случае, это тег '''event_receiver''', который определяет обработчик события.

Обработчик события, как и многое другое, задается при помощи URL. Под URL всегда понимается некоторая строка, включающая в себя тип сущности (в данном случае — обработчика) и адрес этой сущности, который зависит от ее типа. Тип и адрес разделены двоеточием.

Единственный на данный момент реализованный обработчик событий имеет тип gide. Этот обработчик передает все события некоторому объекту Gide-класса. В адресе указано имя файла скрипта (в DISS) и имя класса, разделенные символом "!".

Алгоритм синхронизации

2008-10-31T09:29:41Z

Korvin: /* Поиск уравнения коррекции */

Здесь будет рассмотрена математическая составляющая алгоритмов синхронизации физики. Понимающих в этом деле, просьба прокомментировать.

== Построение сплайна ==

Для синхронизации была выбрана форма кубических сплайнов, при которой за основу берутся значения функции и ее производной в двух точках.

Свойства сплайна:
:<math>s(t_i) = f(t_i), \quad s'(t_i) = f'(t_i)\!</math>

Уравнения сплайна:
:<math>s(t) = a + bt + ct^2 + dt^3\!</math>
:<math>s'(t) = b + 2ct + 3dt^2\!</math>

Для нахождения коэффициентов <math>a, b, c, d</math> записываем систему уравнений:
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = f(t_0) \\
a + bt_1 + ct_1^2 + dt_1^3 = f(t_1) \\
b + 2ct_0 + 3dt_0^2 = f'(t_0) \\
b + 2ct_1 + 3dt_1^2 = f'(t_1)
\end{cases}
</math>

Подставляем известные значения в правой части системы (даны по условию):
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b + 2ct_0 + 3dt_0^2 = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Поскольку сплайн не зависит от конкретных значений <math>t_0</math> и <math>t_1</math>, положим <math>t_0 = 0</math>, а <math>t_1 = t</math>. В результате, пара уравнений становится тривиальной:
:<math>\begin{cases}
a = x_0 \\
a + bt + ct^2 + dt^3 = x_1 \\
b = v_0 \\
b + 2ct + 3dt^2 = v_1
\end{cases}
</math>

Заменяем в оставшихся уравнениях известные теперь коэффициенты и получаем конечную систему:
:<math>\begin{cases}
x_0 + v_0t + ct^2 + dt^3 = x_1 \\
v_0 + 2ct + 3dt^2 = v_1
\end{cases}
</math>

После нехитрых манипуляций, получаем выражения для оставшихся коэффициентов:
:<math>\begin{cases}
c = \frac{3x_1 - 3x_0 - 2v_0t - v_1t}{t^2} \\
d = \frac{2x_0 - 2x_1 + v_0t + v_1t}{t^3}
\end{cases}
</math>

Ниже представлены графики оригинальной функции с наложенным на них графиком сплайна, построенного по точкам. Парабола и экспонента построены по фиксированному набору точек (-2.5, -2, -0.5, 0.5, 2, 2.5). Синусоида построена по точкам с интервалом 0.05.
<gallery>
Изображение:Exp.gif|Экспонента
Изображение:Parabola2.gif|Парабола
Изображение:Sin.gif|Синус
</gallery>

== Механизм коррекции ошибки ==

На клиенте Диптауна работает физический движок — точно такой же, как и на сервере. Он хранит в памяти собственную копию мира (в пределах некотрого радиуса видимости), и, по приходящим от сервера данным, старается делать его наиболее похожим на мир, который находится на сервере.

В идеальном случае, при нулевой задержке времени между клиентом и сервером, а также при достаточно большой частоте обновлений, рассинхронизация между миром клиента и миром сервера была бы пренебрежимо мала. Однако, суровая реальность говорит обратное. В результате, клиентская часть, по сути, находится в прошлом от серверной (на время половины пинга). Поэтому, возникает необходимость подгонять траекторию движения клиентских тел так, чтобы она коррелировала с эталонной, серверной траекторией, опорные точки которой клиент получает по сети.

Коррекция осуществляется путем приложения сторонней силы к движущемуся телу так, чтобы "подтолкнуть" его в сторону желаемой траектории. Это делается в отношении координаты тела и в отношении вектора его скорости. Опять же, в идеальном случае, скорректированная траектория полностью накладывается на серверную, вплоть до равенства параметров в соответствующих точках. Необходимо найти такую корректирующую силу, которая бы наиболее быстро и незаметно сблизила реальную траекторию движения с идеальной. Задача сводится к нахождению уравнения движения, а также определению граничных параметров, которые позволят выполнить коррекцию гладко, без перерегулирования.

=== Поиск уравнения коррекции ===

Рассмотрим некоторый объект. В клиентской копии мира, он находится в некоторой точке и движется по некоторой траектории. Одновременно с этим, с сервера поступают данные о том, по какой траектории он движется на сервере. По этим данным клиент строит сплайн, описанный в предыдущем разделе, и получает траекторию, по которой данный объект должен двигаться на самом деле. Таким образом, в каждый момент времени нам известны вектор положения и вектор скорости объекта, а также вектор положения и вектор скорости, с которыми он должен двигаться в этот момент по данным сервера.

Для того, чтобы стабилизировать траекторию объекта, мы должны приложить к нему две силы — для коррекции положения и для коррекции скорости. Сумма двух этих сил скорректирует траекторию объекта некоторым образом. Если она будет слишком маленькой — мы не добъемся необходимого эффекта; если слишком большой — объект "перелетит" нужную нам траекторию, и начнет колебаться вокруг нее под действием этой силы — такое поведение, конечно, недопустимо. Для того, чтобы подобрать оптимальную силу, мы запишем уравнение движения объекта под ее действием и, проанализировав параметры, подберем оптимальные значения для регулирующих коэффициентов.

Сила коррекции координаты должна быть направлена по разности векторов положений объектов, и пропорциональна этой разности. Также она должна быть пропорциональна массе объекта — чтобы и тяжелые, и легкие объекты вели себя одинаково. Кроме того, подумав, мы решили что эта сила должна быть пропорциональна модулю скорости объекта — для того, чтобы при малых скоростях ее действие не было бы слишком заметным для глаз пользователя (впрочем, с этим множителем не все так просто — см. ниже). Осталось домножить все это на некоторый коэффициент пропорциональности — именно его мы и будем анализировать.

Сила коррекции скорости, аналогично, направлена по разности векторов скорости, пропорциональна этой разности; пропорциональна массе тела и некоторому второму коэффициенту.

Осталось убедиться, что сумма этих сил действительно стабилизирует траекторию движения объекта, не приведет к колебаниям, и найти оптимальные значения для коэффициентов двух сил.

Чтобы упростить себе жизнь, рассмотрим двумерный случай. Пусть серверная траектория тела совпадает с осью X; клиентская траектория — параллельна этой оси и находится от нее на расстоянии, равном H. В нулевой момент времени тело находится в нуле по оси X как на клиентской, так и на серверной траекториях.

Пусть и серверная, и клиентская точки имеют горизонтальную скорость <math>V_x</math>, а по вертикальной оси они неподвижны. Никаких прочих сил на объект не действует. Поскольку никаких сил по горизонтали не действует, мы будем рассматривать только движение по оси y.

Сила коррекции высоты, по такой модели, будет направлена "вниз" на эту точку и будет равна:
:<math>F_p = - K_p \cdot y(t) \cdot V_x \cdot m</math>
где <math>y</math> — это высота точки и
:<math>y(0) = H\!</math>

Множитель <math>V_x</math> мы добавляем специально, чтобы уменьшить влияние силы коррекции на малых скоростях (иначе еле движущееся тело будет менять свое положение заметными глазу рывками).

Сила коррекции вертикальной скорости точки:
:<math>F_v = - K_v \cdot V_y(t) \cdot m</math>
и
:<math>V_y(0) = 0\!</math>

Известно, что скорость — это производная координаты по времени:
:<math>V_y(t) = \frac{\partial y(t)}{\partial t}</math>

Соответственно, сила, которая действует на объект:
:<math>F(t) = m \cdot y''(t) = F_p + F_v = - K_p \cdot y(t) \cdot V_x \cdot m - K_v \cdot V_y(t) \cdot m</math>

:<math>F - F_p - F_v = 0\!</math>

Разделив на массу, и записав уравнение в дифференциальной форме, получим:
:<math>y''(t) + K_v \cdot y'(t) + K_p \cdot y(t) \cdot Vx = 0</math>

Перепишем параметрически:
:<math>y''(t) + A \cdot y'(t) + B \cdot y(t) = 0\!</math>

Характеристическое уравнение:
:<math>\lambda^2 + A \cdot \lambda + B = 0</math>

Дискриминант характеристического уравнения:
:<math>D = A^2 - 4 \cdot B = K_v^2 - 4 \cdot K_p \cdot V_x</math>

Для исключения колебательного процесса, необходимо условие <math>D \geqslant 0</math>. Следовательно:
:<math>K_v^2 - 4 \cdot K_p \cdot V_x \geqslant 0</math>
:<math>K_v^2 \geqslant 4 \cdot K_p \cdot V_x, \quad V_x \leqslant \frac{K_v^2}{4 \cdot K_p}</math>

Видно, что если <math>V_x</math> будет больше чем эта дробь, то возникнут колебания (нарушается условие <math>D \geqslant 0</math>). Поэтому, при малых скоростях используется само значение <math>V_x</math>, а когда <math>V_x</math> численно становится больше этой дроби, следует заменять ее на эту дробь (ограничение сверху).

В конечном счете, коэффициенты <math>\alpha</math> выражаются как
:<math>\alpha_{1,2} = \frac{-K_v \pm \sqrt{D}}{2}</math>

Далее, найдем коэффициенты <math>C_1</math> и <math>C_2</math>:
:<math>y(t) = C_1 \cdot e^{\alpha_1 t} + C_2 \cdot e^{\alpha_2 t}</math>

Зная начальные условия <math>y(0) = H</math> (начальное расстояние между объектами) и <math>y'(t) = 0</math> получаем уравнение:

:<math>C_1 \cdot e^{\alpha_1 \cdot 0} + C_2 \cdot e^{\alpha_2 \cdot 0} = y(0) = H</math>
следовательно
:<math>C_1 + C_2 = H\!</math>.

Из второго условия:
:<math>\alpha_1 \cdot C_1 \cdot e^{\alpha_1 \cdot 0} + \alpha_2 \cdot C_2 \cdot e^{\alpha_2 \cdot 0} = 0</math>
:<math>\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0</math>

Получаем систему следующих уравнений:
:<math>\begin{cases}
C_1 + C_2 = H \\
\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0
\end{cases}
</math>

Решая систему относительно <math>C_1</math> и <math>C_2</math>, получаем
:<math>C_{1,2} = \left ( \frac{1}{2} \pm \frac{K_v}{\sqrt{D}} \right ) \cdot H</math>

Все коэффициенты найдены, задачу можно считать решенной. Однако, есть еще один немаловажный момент.

=== Оценка параметров ===

Выше уже было упомянуто, что колебательный процесс для нас недопустим. Скажем, в случае летящей стрелы, это могло выглядеть как ее периодические колебания вдоль траектории движения, что плохо скажется на реалистичности.

Математически, коэффициенты были рассчитаны так, чтобы этого избежать. Проблема заключается в том, что в случае клиента, мы имеем дело не с непрерывными математическими функциями, а с дискретной апроксимацией. Плюс к этому, изменение модуля прилагаемой силы осуществляется не непрерывно, а, естественно, тоже дискретно. Поскольку в моменты времени "между" коррекциями тело предоставлено само себе, оно и будет двигаться в указанную ему сторону. В худшем случае, при больших и плохо подобранных параметрах, уже после первого корректирующего воздействия, тело вылетит "за траекторию", соответственно возникнут колебания (возможно даже возрастающие).

Для избежания этого неприятного момента, попробуем оценить параметры и найти их "практический потолок", с тем, чтобы не позволять пользователю задавать значения выходящие за границы.

Итак, при моделировании, будем считать что в течение шага тело движется по прямой. Соответственно, сила, которая будет действовать на тело в течение первого шага, т.е. времени <math>T</math>, будет равна
:<math>F_p = - K_p \cdot V_x \cdot H \cdot m</math>

Соответственно, в течение первого шага тело будет двигаться с ускорением
:<math>a = - K_p \cdot Vx \cdot H</math>

Условие стабилизации — расстояние, которое преодолеет тело за первый шаг должно быть меньше <math>H</math>:
:<math>K_p \cdot V_x \cdot H \cdot \frac{T^2}{2} < H, \quad K_p \cdot V_x \cdot T^2 < 2, \quad K_p < \frac{2}{V_x \cdot {T^2}}</math>

Левая часть неравенства будет минимальной в случае, когда <math>V_x</math> максимальна, т.е. равна <math>\tfrac{K_v^2}{4 \cdot K_p}</math>.

Это означает, что в том случае когда модуль скорости тела меньше чем указанное значение, то коррекция будет происходить гладко; когда больше — в формуле для силы стабилизации положения <math>V_x</math> заменяется на <math>\tfrac{K_v^2}{4 \cdot K_p}</math>. Объяснение было дано выше, при оценке дискриминанта характеристического уравнения.

Из этого следует, что чтобы действительно сделать невидимым действие нашей силы на малых скоростях, необходимо, чтобы значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math> было бы достаточно большим. Мы взяли его по-умолчанию равным 10, но это значение можно бдет менять в свойствах каждого конкретного объекта.

Осталось только численно оценить коэффициенты <math>K_p</math> и <math>K_v</math>. Для <math>K_p</math> конкретное значение получается, если подставить в условие
:<math>K_p < \frac{2}{V_x \cdot T^2}</math>
значения <math>V_x = 10</math> и <math>T = 0.04</math>. Получается, что <math>K_p < 125</math>.

Для нахождения <math>K_v</math> вместо <math>V_x</math> необходимо подставить наибольшее возможное для нее значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math>:

:<math>K_p < \frac{2}{\frac{K_v^2}{4 \cdot K_p} \cdot T^2}, \quad K_p < \frac{2 \cdot 4 \cdot K_p}{K_v^2 \cdot T^2}, \quad 1 < \frac{8}{K_v^2 \cdot T^2}, \quad K_v^2 < \frac{8}{T^2}</math>

Окончательно,
:<math>K_v < \frac{2\sqrt{2}}{T}</math>

При подстановке значения <math>T = 0.04</math>, получается, что <math>K_v < 70</math>. В реальных условиях эти пределы взяты еще меньше, для защиты от граничных случаев. Конкретно, <math>K_p</math> по-умолчанию не может превышать 50, а <math>K_v</math> — 30

Алгоритм синхронизации

2008-10-24T22:36:24Z

Korvin: /* Построение сплайна */

Здесь будет рассмотрена математическая составляющая алгоритмов синхронизации физики. Понимающих в этом деле, просьба прокомментировать.

== Построение сплайна ==

Для синхронизации была выбрана форма кубических сплайнов, при которой за основу берутся значения функции и ее производной в двух точках.

Свойства сплайна:
:<math>s(t_i) = f(t_i), \quad s'(t_i) = f'(t_i)\!</math>

Уравнения сплайна:
:<math>s(t) = a + bt + ct^2 + dt^3\!</math>
:<math>s'(t) = b + 2ct + 3dt^2\!</math>

Для нахождения коэффициентов <math>a, b, c, d</math> записываем систему уравнений:
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = f(t_0) \\
a + bt_1 + ct_1^2 + dt_1^3 = f(t_1) \\
b + 2ct_0 + 3dt_0^2 = f'(t_0) \\
b + 2ct_1 + 3dt_1^2 = f'(t_1)
\end{cases}
</math>

Подставляем известные значения в правой части системы (даны по условию):
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b + 2ct_0 + 3dt_0^2 = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Поскольку сплайн не зависит от конкретных значений <math>t_0</math> и <math>t_1</math>, положим <math>t_0 = 0</math>, а <math>t_1 = t</math>. В результате, пара уравнений становится тривиальной:
:<math>\begin{cases}
a = x_0 \\
a + bt + ct^2 + dt^3 = x_1 \\
b = v_0 \\
b + 2ct + 3dt^2 = v_1
\end{cases}
</math>

Заменяем в оставшихся уравнениях известные теперь коэффициенты и получаем конечную систему:
:<math>\begin{cases}
x_0 + v_0t + ct^2 + dt^3 = x_1 \\
v_0 + 2ct + 3dt^2 = v_1
\end{cases}
</math>

После нехитрых манипуляций, получаем выражения для оставшихся коэффициентов:
:<math>\begin{cases}
c = \frac{3x_1 - 3x_0 - 2v_0t - v_1t}{t^2} \\
d = \frac{2x_0 - 2x_1 + v_0t + v_1t}{t^3}
\end{cases}
</math>

Ниже представлены графики оригинальной функции с наложенным на них графиком сплайна, построенного по точкам. Парабола и экспонента построены по фиксированному набору точек (-2.5, -2, -0.5, 0.5, 2, 2.5). Синусоида построена по точкам с интервалом 0.05.
<gallery>
Изображение:Exp.gif|Экспонента
Изображение:Parabola2.gif|Парабола
Изображение:Sin.gif|Синус
</gallery>

== Механизм коррекции ошибки ==

На клиенте Диптауна работает физический движок — точно такой же, как и на сервере. Он хранит в памяти собственную копию мира (в пределах некотрого радиуса видимости), и, по приходящим от сервера данным, старается делать его наиболее похожим на мир, который находится на сервере.

В идеальном случае, при нулевой задержке времени между клиентом и сервером, а также при достаточно большой частоте обновлений, рассинхронизация между миром клиента и миром сервера была бы пренебрежимо мала. Однако, суровая реальность говорит обратное. В результате, клиентская часть, по сути, находится в прошлом от серверной (на время половины пинга). Поэтому, возникает необходимость подгонять траекторию движения клиентских тел так, чтобы она коррелировала с эталонной, серверной траекторией, опорные точки которой клиент получает по сети.

Коррекция осуществляется путем приложения сторонней силы к движущемуся телу так, чтобы "подтолкнуть" его в сторону желаемой траектории. Это делается в отношении координаты тела и в отношении вектора его скорости. Опять же, в идеальном случае, скорректированная траектория полностью накладывается на серверную, вплоть до равенства параметров в соответствующих точках. Необходимо найти такую корректирующую силу, которая бы наиболее быстро и незаметно сблизила реальную траекторию движения с идеальной. Задача сводится к нахождению уравнения движения, а также определению граничных параметров, которые позволят выполнить коррекцию гладко, без перерегулирования.

=== Поиск уравнения коррекции ===

Рассмотрим некоторый объект. В клиентской копии мира, он находится в некоторой точке и движется по некоторой траектории. Одновременно с этим, с сервера поступают данные о том, по какой траектории он движется на сервере. По этим данным клиент строит сплайн, описанный в предыдущем разделе, и получает траекторию, по которой данный объект должен двигаться на самом деле. Таким образом, в каждый момент времени нам известны вектор положения и вектор скорости объекта, а также вектор положения и вектор скорости, с которыми он должен двигаться в этот момент по данным сервера.

Для того, чтобы стабилизировать траекторию объекта, мы должны приложить к нему две силы — для коррекции положения и для коррекции скорости. Сумма двух этих сил скорректирует траекторию объекта некоторым образом. Если она будет слишком маленькой — мы не добъемся необходимого эффекта; если слишком большой — объект "перелетит" нужную нам траекторию, и начнет колебаться вокруг нее под действием этой силы — такое поведение, конечно, недопустимо. Для того, чтобы подобрать оптимальную силу, мы запишем уравнение движения объекта под ее действием и, проанализировав параметры, подберем оптимальные значения для регулирующих коэффициентов.

Сила коррекции координаты должна быть направлена по разности векторов положений объектов, и пропорциональна этой разности. Также она должна быть пропорциональна массе объекта — чтобы и тяжелые, и легкие объекты вели себя одинаково. Кроме того, подумав, мы решили что эта сила должна быть пропорциональна модулю скорости объекта — для того, чтобы при малых скоростях ее действие не было бы слишком заметным для глаз пользователя (впрочем, с этим множителем не все так просто — см. ниже). Осталось домножить все это на некоторый коэффициент пропорциональности — именно его мы и будем анализировать.

Сила коррекции скорости, аналогично, направлена по разности векторов скорости, пропорциональна этой разности; пропорциональна массе тела и некоторому второму коэффициенту.

Осталось убедиться, что сумма этих сил действительно стабилизирует траекторию движения объекта, не приведет к колебаниям, и найти оптимальные значения для коэффициентов двух сил.

Чтобы упростить себе жизнь, рассмотрим двумерный случай. Пусть серверная траектория тела совпадает с осью X; клиентская траектория — параллельна этой оси и находится от нее на расстоянии, равном H. В нулевой момент времени тело находится в нуле по оси X как на клиентской, так и на серверной траекториях.

Пусть и серверная, и клиентская точки имеют горизонтальную скорость <math>V_x</math>, а по вертикальной оси они неподвижны. Никаких прочих сил на объект не действует. Поскольку никаких сил по горизонтали не действует, мы будем рассматривать только движение по оси y.

Сила коррекции высоты, по такой модели, будет направлена "вниз" на эту точку и будет равна:
:<math>F_p = - K_p \cdot y(t) \cdot V_x \cdot m</math>
где <math>y</math> — это высота точки и
:<math>y(0) = H\!</math>

Множитель <math>V_x</math> мы добавляем специально, чтобы уменьшить влияние силы коррекции на малых скоростях (иначе еле движущееся тело будет менять свое положение заметными глазу рывками).

Сила коррекции вертикальной скорости точки:
:<math>F_v = - K_v \cdot V_y(t) \cdot m</math>
и
:<math>V_y(0) = 0\!</math>

Известно, что скорость — это производная координаты по времени:
:<math>V_y(t) = \frac{\partial y(t)}{\partial t}</math>

Соответственно, сила, которая действует на объект:
:<math>F(t) = m \cdot y''(t) = F_p + F_v = - K_p \cdot y(t) \cdot V_x \cdot m - K_v \cdot V_y(t) \cdot m</math>

:<math>F - F_p - F_v = 0\!</math>

Разделив на массу, и записав уравнение в дифференциальной форме, получим:
:<math>y''(t) + K_v \cdot y'(t) + K_p \cdot y(t) \cdot Vx = 0</math>

Перепишем параметрически:
:<math>y''(t) + A \cdot y'(t) + B \cdot y(t) = 0\!</math>

Характеристическое уравнение:
:<math>\lambda^2 + A \cdot \lambda + B = 0</math>

Дискриминант характеристического уравнения:
:<math>D = A^2 - 4 \cdot B = K_v^2 - 4 \cdot K_p \cdot V_x</math>

Для исключения колебательного процесса, необходимо условие <math>D \geqslant 0</math>. Следовательно:
:<math>K_v^2 - 4 \cdot K_p \cdot V_x \geqslant 0</math>
:<math>K_v^2 \geqslant 4 \cdot K_p \cdot V_x, \quad V_x \leqslant \frac{K_v^2}{4 \cdot K_p}</math>

Видно, что если <math>V_x</math> будет больше чем эта дробь, то возникнут колебания (нарушается условие <math>D \geqslant 0</math>). Поэтому, при малых скоростях используется само значение <math>V_x</math>, а когда <math>V_x</math> численно становится больше этой дроби, следует заменять ее на эту дробь (ограничение сверху).

В конечном счете, коэффициенты <math>\alpha</math> выражаются как
:<math>\alpha_{1,2} = \frac{-K_v \pm \sqrt{D}}{2}</math>

Далее, найдем коэффициенты <math>C_1</math> и <math>C_2</math>:
:<math>y(t) = C_1 \cdot e^{\alpha_1 t} + C_2 \cdot e^{\alpha_2 t}</math>

Зная начальные условия <math>y(0) = H</math> (начальное расстояние между объектами) и <math>y'(t) = 0</math> получаем уравнение:

:<math>C_1 \cdot e^{\alpha_1 \cdot 0} + C_2 \cdot e^{\alpha_2 \cdot 0} = y(0) = H</math>
следовательно
:<math>C_1 + C_2 = H\!</math>.

Из второго условия:
:<math>\alpha_1 \cdot C_1 \cdot e^{\alpha_1 \cdot 0} + \alpha_2 \cdot C_2 \cdot e^{\alpha_2 \cdot 0} = 0</math>
:<math>\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0</math>

Получаем систему следующих уравнений:
:<math>\begin{cases}
C_1 + C_2 = H \\
\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0
\end{cases}
</math>

Решая систему относительно <math>C_1</math> и <math>C_2</math>, получаем
:<math>C_{1,2} = \left ( \frac{1}{2} \pm \frac{K_v}{\sqrt{D}} \right ) \cdot H</math>

Все коэффициенты найдены, задачу можно считать решенной. Однако, есть еще один немаловаждый момент.

=== Оценка параметров ===

Выше уже было упомянуто, что колебательный процесс для нас недопустим. Скажем, в случае летящей стрелы, это могло выглядеть как ее периодические колебания вдоль траектории движения, что плохо скажется на реалистичности.

Математически, коэффициенты были рассчитаны так, чтобы этого избежать. Проблема заключается в том, что в случае клиента, мы имеем дело не с непрерывными математическими функциями, а с дискретной апроксимацией. Плюс к этому, изменение модуля прилагаемой силы осуществляется не непрерывно, а, естественно, тоже дискретно. Поскольку в моменты времени "между" коррекциями тело предоставлено само себе, оно и будет двигаться в указанную ему сторону. В худшем случае, при больших и плохо подобранных параметрах, уже после первого корректирующего воздействия, тело вылетит "за траекторию", соответственно возникнут колебания (возможно даже возрастающие).

Для избежания этого неприятного момента, попробуем оценить параметры и найти их "практический потолок", с тем, чтобы не позволять пользователю задавать значения выходящие за границы.

Итак, при моделировании, будем считать что в течение шага тело движется по прямой. Соответственно, сила, которая будет действовать на тело в течение первого шага, т.е. времени <math>T</math>, будет равна
:<math>F_p = - K_p \cdot V_x \cdot H \cdot m</math>

Соответственно, в течение первого шага тело будет двигаться с ускорением
:<math>a = - K_p \cdot Vx \cdot H</math>

Условие стабилизации — расстояние, которое преодолеет тело за первый шаг должно быть меньше <math>H</math>:
:<math>K_p \cdot V_x \cdot H \cdot \frac{T^2}{2} < H, \quad K_p \cdot V_x \cdot T^2 < 2, \quad K_p < \frac{2}{V_x \cdot {T^2}}</math>

Левая часть неравенства будет минимальной в случае, когда <math>V_x</math> максимальна, т.е. равна <math>\tfrac{K_v^2}{4 \cdot K_p}</math>.

Это означает, что в том случае когда модуль скорости тела меньше чем указанное значение, то коррекция будет происходить гладко; когда больше — в формуле для силы стабилизации положения <math>V_x</math> заменяется на <math>\tfrac{K_v^2}{4 \cdot K_p}</math>. Объяснение было дано выше, при оценке дискриминанта характеристического уравнения.

Из этого следует, что чтобы действительно сделать невидимым действие нашей силы на малых скоростях, необходимо, чтобы значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math> было бы достаточно большим. Мы взяли его по-умолчанию равным 10, но это значение можно бдет менять в свойствах каждого конкретного объекта.

Осталось только численно оценить коэффициенты <math>K_p</math> и <math>K_v</math>. Для <math>K_p</math> конкретное значение получается, если подставить в условие
:<math>K_p < \frac{2}{V_x \cdot T^2}</math>
значения <math>V_x = 10</math> и <math>T = 0.04</math>. Получается, что <math>K_p < 125</math>.

Для нахождения <math>K_v</math> вместо <math>V_x</math> необходимо подставить наибольшее возможное для нее значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math>:

:<math>K_p < \frac{2}{\frac{K_v^2}{4 \cdot K_p} \cdot T^2}, \quad K_p < \frac{2 \cdot 4 \cdot K_p}{K_v^2 \cdot T^2}, \quad 1 < \frac{8}{K_v^2 \cdot T^2}, \quad K_v^2 < \frac{8}{T^2}</math>

Окончательно,
:<math>K_v < \frac{2\sqrt{2}}{T}</math>

При подстановке значения <math>T = 0.04</math>, получается, что <math>K_v < 70</math>. В реальных условиях эти пределы взяты еще меньше, для защиты от граничных случаев. Конкретно, <math>K_p</math> по-умолчанию не может превышать 50, а <math>K_v</math> — 30

Алгоритм синхронизации

2008-10-24T17:12:16Z

Korvin: /* Построение сплайна */

Здесь будет рассмотрена математическая составляющая алгоритмов синхронизации физики. Понимающих в этом деле, просьба прокомментировать.

== Построение сплайна ==

Для синхронизации была выбрана форма кубических сплайнов, при которой за основу берутся значения функции и ее производной в двух точках.

Свойства сплайна:
:<math>s(t_i) = f(t_i), \quad s'(t_i) = f'(t_i)\!</math>

Уравнения сплайна:
:<math>s(t) = a + bt + ct^2 + dt^3\!</math>
:<math>s'(t) = b + 2ct + 3dt^2\!</math>

Для нахождения коэффициентов <math>a, b, c, d</math> записываем систему уравнений:
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = f(t_0) \\
a + bt_1 + ct_1^2 + dt_1^3 = f(t_1) \\
b + 2ct_0 + 3dt_0^2 = f'(t_0) \\
b + 2ct_1 + 3dt_1^2 = f'(t_1)
\end{cases}
</math>

Подставляем известные значения в правой части системы (даны по условию):
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b + 2ct_0 + 3dt_0^2 = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Поскольку сплайн не зависит от конкретных значений <math>t_0</math> и <math>t_1</math>, положим <math>t_0 = 0</math>, а <math>t_1 = t</math>. В результате, пара уравнений становится тривиальной:
:<math>\begin{cases}
a = x_0 \\
a + bt + ct^2 + dt^3 = x_1 \\
b = v_0 \\
b + 2ct + 3dt^2 = v_1
\end{cases}
</math>

Заменяем в оставшихся уравнениях известные теперь коэффициенты и получаем конечную систему:
:<math>\begin{cases}
x_0 + v_0t + ct^2 + dt^3 = x_1 \\
v_0 + 2ct + 3dt^2 = v_1
\end{cases}
</math>

После нехитрых манипуляций, получаем выражения для оставшихся коэффициентов:
:<math>\begin{cases}
c = \frac{3x_1 - 3x_0 - 2v_0t - v_1t}{t^2} \\
d = \frac{v_1t - 2x_1 + 2x_0 + v_ot}{t^3}
\end{cases}
</math>

Ниже представлены графики оригинальной функции с наложенным на них графиком сплайна, построенного по точкам. Парабола и экспонента построены по фиксированному набору точек (-2.5, -2, -0.5, 0.5, 2, 2.5). Синусоида построена по точкам с интервалом 0.05.
<gallery>
Изображение:Exp.gif|Экспонента
Изображение:Parabola2.gif|Парабола
Изображение:Sin.gif|Синус
</gallery>

== Механизм коррекции ошибки ==

На клиенте Диптауна работает физический движок — точно такой же, как и на сервере. Он хранит в памяти собственную копию мира (в пределах некотрого радиуса видимости), и, по приходящим от сервера данным, старается делать его наиболее похожим на мир, который находится на сервере.

В идеальном случае, при нулевой задержке времени между клиентом и сервером, а также при достаточно большой частоте обновлений, рассинхронизация между миром клиента и миром сервера была бы пренебрежимо мала. Однако, суровая реальность говорит обратное. В результате, клиентская часть, по сути, находится в прошлом от серверной (на время половины пинга). Поэтому, возникает необходимость подгонять траекторию движения клиентских тел так, чтобы она коррелировала с эталонной, серверной траекторией, опорные точки которой клиент получает по сети.

Коррекция осуществляется путем приложения сторонней силы к движущемуся телу так, чтобы "подтолкнуть" его в сторону желаемой траектории. Это делается в отношении координаты тела и в отношении вектора его скорости. Опять же, в идеальном случае, скорректированная траектория полностью накладывается на серверную, вплоть до равенства параметров в соответствующих точках. Необходимо найти такую корректирующую силу, которая бы наиболее быстро и незаметно сблизила реальную траекторию движения с идеальной. Задача сводится к нахождению уравнения движения, а также определению граничных параметров, которые позволят выполнить коррекцию гладко, без перерегулирования.

=== Поиск уравнения коррекции ===

Рассмотрим некоторый объект. В клиентской копии мира, он находится в некоторой точке и движется по некоторой траектории. Одновременно с этим, с сервера поступают данные о том, по какой траектории он движется на сервере. По этим данным клиент строит сплайн, описанный в предыдущем разделе, и получает траекторию, по которой данный объект должен двигаться на самом деле. Таким образом, в каждый момент времени нам известны вектор положения и вектор скорости объекта, а также вектор положения и вектор скорости, с которыми он должен двигаться в этот момент по данным сервера.

Для того, чтобы стабилизировать траекторию объекта, мы должны приложить к нему две силы — для коррекции положения и для коррекции скорости. Сумма двух этих сил скорректирует траекторию объекта некоторым образом. Если она будет слишком маленькой — мы не добъемся необходимого эффекта; если слишком большой — объект "перелетит" нужную нам траекторию, и начнет колебаться вокруг нее под действием этой силы — такое поведение, конечно, недопустимо. Для того, чтобы подобрать оптимальную силу, мы запишем уравнение движения объекта под ее действием и, проанализировав параметры, подберем оптимальные значения для регулирующих коэффициентов.

Сила коррекции координаты должна быть направлена по разности векторов положений объектов, и пропорциональна этой разности. Также она должна быть пропорциональна массе объекта — чтобы и тяжелые, и легкие объекты вели себя одинаково. Кроме того, подумав, мы решили что эта сила должна быть пропорциональна модулю скорости объекта — для того, чтобы при малых скоростях ее действие не было бы слишком заметным для глаз пользователя (впрочем, с этим множителем не все так просто — см. ниже). Осталось домножить все это на некоторый коэффициент пропорциональности — именно его мы и будем анализировать.

Сила коррекции скорости, аналогично, направлена по разности векторов скорости, пропорциональна этой разности; пропорциональна массе тела и некоторому второму коэффициенту.

Осталось убедиться, что сумма этих сил действительно стабилизирует траекторию движения объекта, не приведет к колебаниям, и найти оптимальные значения для коэффициентов двух сил.

Чтобы упростить себе жизнь, рассмотрим двумерный случай. Пусть серверная траектория тела совпадает с осью X; клиентская траектория — параллельна этой оси и находится от нее на расстоянии, равном H. В нулевой момент времени тело находится в нуле по оси X как на клиентской, так и на серверной траекториях.

Пусть и серверная, и клиентская точки имеют горизонтальную скорость <math>V_x</math>, а по вертикальной оси они неподвижны. Никаких прочих сил на объект не действует. Поскольку никаких сил по горизонтали не действует, мы будем рассматривать только движение по оси y.

Сила коррекции высоты, по такой модели, будет направлена "вниз" на эту точку и будет равна:
:<math>F_p = - K_p \cdot y(t) \cdot V_x \cdot m</math>
где <math>y</math> — это высота точки и
:<math>y(0) = H\!</math>

Множитель <math>V_x</math> мы добавляем специально, чтобы уменьшить влияние силы коррекции на малых скоростях (иначе еле движущееся тело будет менять свое положение заметными глазу рывками).

Сила коррекции вертикальной скорости точки:
:<math>F_v = - K_v \cdot V_y(t) \cdot m</math>
и
:<math>V_y(0) = 0\!</math>

Известно, что скорость — это производная координаты по времени:
:<math>V_y(t) = \frac{\partial y(t)}{\partial t}</math>

Соответственно, сила, которая действует на объект:
:<math>F(t) = m \cdot y''(t) = F_p + F_v = - K_p \cdot y(t) \cdot V_x \cdot m - K_v \cdot V_y(t) \cdot m</math>

:<math>F - F_p - F_v = 0\!</math>

Разделив на массу, и записав уравнение в дифференциальной форме, получим:
:<math>y''(t) + K_v \cdot y'(t) + K_p \cdot y(t) \cdot Vx = 0</math>

Перепишем параметрически:
:<math>y''(t) + A \cdot y'(t) + B \cdot y(t) = 0\!</math>

Характеристическое уравнение:
:<math>\lambda^2 + A \cdot \lambda + B = 0</math>

Дискриминант характеристического уравнения:
:<math>D = A^2 - 4 \cdot B = K_v^2 - 4 \cdot K_p \cdot V_x</math>

Для исключения колебательного процесса, необходимо условие <math>D \geqslant 0</math>. Следовательно:
:<math>K_v^2 - 4 \cdot K_p \cdot V_x \geqslant 0</math>
:<math>K_v^2 \geqslant 4 \cdot K_p \cdot V_x, \quad V_x \leqslant \frac{K_v^2}{4 \cdot K_p}</math>

Видно, что если <math>V_x</math> будет больше чем эта дробь, то возникнут колебания (нарушается условие <math>D \geqslant 0</math>). Поэтому, при малых скоростях используется само значение <math>V_x</math>, а когда <math>V_x</math> численно становится больше этой дроби, следует заменять ее на эту дробь (ограничение сверху).

В конечном счете, коэффициенты <math>\alpha</math> выражаются как
:<math>\alpha_{1,2} = \frac{-K_v \pm \sqrt{D}}{2}</math>

Далее, найдем коэффициенты <math>C_1</math> и <math>C_2</math>:
:<math>y(t) = C_1 \cdot e^{\alpha_1 t} + C_2 \cdot e^{\alpha_2 t}</math>

Зная начальные условия <math>y(0) = H</math> (начальное расстояние между объектами) и <math>y'(t) = 0</math> получаем уравнение:

:<math>C_1 \cdot e^{\alpha_1 \cdot 0} + C_2 \cdot e^{\alpha_2 \cdot 0} = y(0) = H</math>
следовательно
:<math>C_1 + C_2 = H\!</math>.

Из второго условия:
:<math>\alpha_1 \cdot C_1 \cdot e^{\alpha_1 \cdot 0} + \alpha_2 \cdot C_2 \cdot e^{\alpha_2 \cdot 0} = 0</math>
:<math>\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0</math>

Получаем систему следующих уравнений:
:<math>\begin{cases}
C_1 + C_2 = H \\
\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0
\end{cases}
</math>

Решая систему относительно <math>C_1</math> и <math>C_2</math>, получаем
:<math>C_{1,2} = \left ( \frac{1}{2} \pm \frac{K_v}{\sqrt{D}} \right ) \cdot H</math>

Все коэффициенты найдены, задачу можно считать решенной. Однако, есть еще один немаловаждый момент.

=== Оценка параметров ===

Выше уже было упомянуто, что колебательный процесс для нас недопустим. Скажем, в случае летящей стрелы, это могло выглядеть как ее периодические колебания вдоль траектории движения, что плохо скажется на реалистичности.

Математически, коэффициенты были рассчитаны так, чтобы этого избежать. Проблема заключается в том, что в случае клиента, мы имеем дело не с непрерывными математическими функциями, а с дискретной апроксимацией. Плюс к этому, изменение модуля прилагаемой силы осуществляется не непрерывно, а, естественно, тоже дискретно. Поскольку в моменты времени "между" коррекциями тело предоставлено само себе, оно и будет двигаться в указанную ему сторону. В худшем случае, при больших и плохо подобранных параметрах, уже после первого корректирующего воздействия, тело вылетит "за траекторию", соответственно возникнут колебания (возможно даже возрастающие).

Для избежания этого неприятного момента, попробуем оценить параметры и найти их "практический потолок", с тем, чтобы не позволять пользователю задавать значения выходящие за границы.

Итак, при моделировании, будем считать что в течение шага тело движется по прямой. Соответственно, сила, которая будет действовать на тело в течение первого шага, т.е. времени <math>T</math>, будет равна
:<math>F_p = - K_p \cdot V_x \cdot H \cdot m</math>

Соответственно, в течение первого шага тело будет двигаться с ускорением
:<math>a = - K_p \cdot Vx \cdot H</math>

Условие стабилизации — расстояние, которое преодолеет тело за первый шаг должно быть меньше <math>H</math>:
:<math>K_p \cdot V_x \cdot H \cdot \frac{T^2}{2} < H, \quad K_p \cdot V_x \cdot T^2 < 2, \quad K_p < \frac{2}{V_x \cdot {T^2}}</math>

Левая часть неравенства будет минимальной в случае, когда <math>V_x</math> максимальна, т.е. равна <math>\tfrac{K_v^2}{4 \cdot K_p}</math>.

Это означает, что в том случае когда модуль скорости тела меньше чем указанное значение, то коррекция происходить гладко; когда больше — в формуле для силы стабилизации положения <math>V_x</math> заменяется на <math>\tfrac{K_v^2}{4 \cdot K_p}</math>. Объяснение было дано выше, при оценке дискриминанта характеристического уравнения.

Из этого следует, что чтобы действительно сделать невидимым действие нашей силы на малых скоростях, необходимо, чтобы значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math> было бы достаточно большим. Мы взяли его по-умолчанию равным 10, но это значение можно бдет менять в свойствах каждого конкретного объекта.

Осталось только численно оценить коэффициенты <math>K_p</math> и <math>K_v</math>. Для <math>K_p</math> конкретное значение получается, если подставить в условие
:<math>K_p < \frac{2}{V_x \cdot T^2}</math>
значения <math>V_x = 10</math> и <math>T = 0.04</math>. Получается, что <math>K_p < 125</math>.

Для нахождения <math>K_v</math> вместо <math>V_x</math> необходимо подставить наибольшее возможное для нее значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math>:

:<math>K_p < \frac{2}{\frac{K_v^2}{4 \cdot K_p} \cdot T^2}, \quad K_p < \frac{2 \cdot 4 \cdot K_p}{K_v^2 \cdot T^2}, \quad 1 < \frac{8}{K_v^2 \cdot T^2}, \quad K_v^2 < \frac{8}{T^2}</math>

Окончательно,
:<math>K_v < \frac{2\sqrt{2}}{T}</math>

При подстановке значения <math>T = 0.04</math>, получается, что <math>K_v < 70</math>. В реальных условиях эти пределы взяты еще меньше, для защиты от граничных случаев. Конкретно, <math>K_p</math> по-умолчанию не может превышать 50, а <math>K_v</math> — 30

Алгоритм синхронизации

2008-10-24T17:07:42Z

Korvin: /* Механизм коррекции ошибки */

Здесь будет рассмотрена математическая составляющая алгоритмов синхронизации физики. Понимающих в этом деле, просьба прокомментировать.

== Построение сплайна ==

Для синхронизации была выбрана форма кубических сплайнов, при которой за основу берутся значения функции и ее производной в двух точках.

Свойства сплайна:
:<math>s(t_i) = f(t_i), \quad s'(t_i) = f'(t_i)\!</math>

Уравнения сплайна:
:<math>s(t) = a + bt + ct^2 + dt^3\!</math>
:<math>s'(t) = b + 2ct + 3dt^2\!</math>

Для нахождения коэффициентов <math>a, b, c, d</math> записываем систему уравнений:
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = f(t_0) \\
a + bt_1 + ct_1^2 + dt_1^3 = f(t_1) \\
b + 2ct_0 + 3dt_0^2 = f'(t_0) \\
b + 2ct_1 + 3dt_1^2 = f'(t_1)
\end{cases}
</math>

Подставляем известные значения в правой части системы (даны по условию):
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b + 2ct_0 + 3dt_0^2 = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Поскольку сплайн не зависит от конкретных значений <math>t_0</math> и <math>t_1</math>, положим <math>t_0 = 0</math>, а <math>t_1 = t</math>. В результате, пара уравнений становится тривиальной:
:<math>\begin{cases}
a = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Заменяем в оставшихся уравнениях известные теперь коэффициенты и получаем конечную систему:
:<math>\begin{cases}
x_0 + v_0t_1 + ct_1^2 + dt_1^3 = x_1 \\
v_0 + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

После нехитрых манипуляций, получаем выражения для оставшихся коэффициентов:
:<math>\begin{cases}
c = \frac{3x_1 - 3x_0 - 2v_0t - v_1t}{t^2} \\
d = \frac{v_1t - 2x_1 + 2x_0 + v_ot}{t^3}
\end{cases}
</math>

Ниже представлены графики оригинальной функции с наложенным на них графиком сплайна, построенного по точкам. Парабола и экспонента построены по фиксированному набору точек (-2.5, -2, -0.5, 0.5, 2, 2.5). Синусоида построена по точкам с интервалом 0.05.
<gallery>
Изображение:Exp.gif|Экспонента
Изображение:Parabola2.gif|Парабола
Изображение:Sin.gif|Синус
</gallery>

== Механизм коррекции ошибки ==

На клиенте Диптауна работает физический движок — точно такой же, как и на сервере. Он хранит в памяти собственную копию мира (в пределах некотрого радиуса видимости), и, по приходящим от сервера данным, старается делать его наиболее похожим на мир, который находится на сервере.

В идеальном случае, при нулевой задержке времени между клиентом и сервером, а также при достаточно большой частоте обновлений, рассинхронизация между миром клиента и миром сервера была бы пренебрежимо мала. Однако, суровая реальность говорит обратное. В результате, клиентская часть, по сути, находится в прошлом от серверной (на время половины пинга). Поэтому, возникает необходимость подгонять траекторию движения клиентских тел так, чтобы она коррелировала с эталонной, серверной траекторией, опорные точки которой клиент получает по сети.

Коррекция осуществляется путем приложения сторонней силы к движущемуся телу так, чтобы "подтолкнуть" его в сторону желаемой траектории. Это делается в отношении координаты тела и в отношении вектора его скорости. Опять же, в идеальном случае, скорректированная траектория полностью накладывается на серверную, вплоть до равенства параметров в соответствующих точках. Необходимо найти такую корректирующую силу, которая бы наиболее быстро и незаметно сблизила реальную траекторию движения с идеальной. Задача сводится к нахождению уравнения движения, а также определению граничных параметров, которые позволят выполнить коррекцию гладко, без перерегулирования.

=== Поиск уравнения коррекции ===

Рассмотрим некоторый объект. В клиентской копии мира, он находится в некоторой точке и движется по некоторой траектории. Одновременно с этим, с сервера поступают данные о том, по какой траектории он движется на сервере. По этим данным клиент строит сплайн, описанный в предыдущем разделе, и получает траекторию, по которой данный объект должен двигаться на самом деле. Таким образом, в каждый момент времени нам известны вектор положения и вектор скорости объекта, а также вектор положения и вектор скорости, с которыми он должен двигаться в этот момент по данным сервера.

Для того, чтобы стабилизировать траекторию объекта, мы должны приложить к нему две силы — для коррекции положения и для коррекции скорости. Сумма двух этих сил скорректирует траекторию объекта некоторым образом. Если она будет слишком маленькой — мы не добъемся необходимого эффекта; если слишком большой — объект "перелетит" нужную нам траекторию, и начнет колебаться вокруг нее под действием этой силы — такое поведение, конечно, недопустимо. Для того, чтобы подобрать оптимальную силу, мы запишем уравнение движения объекта под ее действием и, проанализировав параметры, подберем оптимальные значения для регулирующих коэффициентов.

Сила коррекции координаты должна быть направлена по разности векторов положений объектов, и пропорциональна этой разности. Также она должна быть пропорциональна массе объекта — чтобы и тяжелые, и легкие объекты вели себя одинаково. Кроме того, подумав, мы решили что эта сила должна быть пропорциональна модулю скорости объекта — для того, чтобы при малых скоростях ее действие не было бы слишком заметным для глаз пользователя (впрочем, с этим множителем не все так просто — см. ниже). Осталось домножить все это на некоторый коэффициент пропорциональности — именно его мы и будем анализировать.

Сила коррекции скорости, аналогично, направлена по разности векторов скорости, пропорциональна этой разности; пропорциональна массе тела и некоторому второму коэффициенту.

Осталось убедиться, что сумма этих сил действительно стабилизирует траекторию движения объекта, не приведет к колебаниям, и найти оптимальные значения для коэффициентов двух сил.

Чтобы упростить себе жизнь, рассмотрим двумерный случай. Пусть серверная траектория тела совпадает с осью X; клиентская траектория — параллельна этой оси и находится от нее на расстоянии, равном H. В нулевой момент времени тело находится в нуле по оси X как на клиентской, так и на серверной траекториях.

Пусть и серверная, и клиентская точки имеют горизонтальную скорость <math>V_x</math>, а по вертикальной оси они неподвижны. Никаких прочих сил на объект не действует. Поскольку никаких сил по горизонтали не действует, мы будем рассматривать только движение по оси y.

Сила коррекции высоты, по такой модели, будет направлена "вниз" на эту точку и будет равна:
:<math>F_p = - K_p \cdot y(t) \cdot V_x \cdot m</math>
где <math>y</math> — это высота точки и
:<math>y(0) = H\!</math>

Множитель <math>V_x</math> мы добавляем специально, чтобы уменьшить влияние силы коррекции на малых скоростях (иначе еле движущееся тело будет менять свое положение заметными глазу рывками).

Сила коррекции вертикальной скорости точки:
:<math>F_v = - K_v \cdot V_y(t) \cdot m</math>
и
:<math>V_y(0) = 0\!</math>

Известно, что скорость — это производная координаты по времени:
:<math>V_y(t) = \frac{\partial y(t)}{\partial t}</math>

Соответственно, сила, которая действует на объект:
:<math>F(t) = m \cdot y''(t) = F_p + F_v = - K_p \cdot y(t) \cdot V_x \cdot m - K_v \cdot V_y(t) \cdot m</math>

:<math>F - F_p - F_v = 0\!</math>

Разделив на массу, и записав уравнение в дифференциальной форме, получим:
:<math>y''(t) + K_v \cdot y'(t) + K_p \cdot y(t) \cdot Vx = 0</math>

Перепишем параметрически:
:<math>y''(t) + A \cdot y'(t) + B \cdot y(t) = 0\!</math>

Характеристическое уравнение:
:<math>\lambda^2 + A \cdot \lambda + B = 0</math>

Дискриминант характеристического уравнения:
:<math>D = A^2 - 4 \cdot B = K_v^2 - 4 \cdot K_p \cdot V_x</math>

Для исключения колебательного процесса, необходимо условие <math>D \geqslant 0</math>. Следовательно:
:<math>K_v^2 - 4 \cdot K_p \cdot V_x \geqslant 0</math>
:<math>K_v^2 \geqslant 4 \cdot K_p \cdot V_x, \quad V_x \leqslant \frac{K_v^2}{4 \cdot K_p}</math>

Видно, что если <math>V_x</math> будет больше чем эта дробь, то возникнут колебания (нарушается условие <math>D \geqslant 0</math>). Поэтому, при малых скоростях используется само значение <math>V_x</math>, а когда <math>V_x</math> численно становится больше этой дроби, следует заменять ее на эту дробь (ограничение сверху).

В конечном счете, коэффициенты <math>\alpha</math> выражаются как
:<math>\alpha_{1,2} = \frac{-K_v \pm \sqrt{D}}{2}</math>

Далее, найдем коэффициенты <math>C_1</math> и <math>C_2</math>:
:<math>y(t) = C_1 \cdot e^{\alpha_1 t} + C_2 \cdot e^{\alpha_2 t}</math>

Зная начальные условия <math>y(0) = H</math> (начальное расстояние между объектами) и <math>y'(t) = 0</math> получаем уравнение:

:<math>C_1 \cdot e^{\alpha_1 \cdot 0} + C_2 \cdot e^{\alpha_2 \cdot 0} = y(0) = H</math>
следовательно
:<math>C_1 + C_2 = H\!</math>.

Из второго условия:
:<math>\alpha_1 \cdot C_1 \cdot e^{\alpha_1 \cdot 0} + \alpha_2 \cdot C_2 \cdot e^{\alpha_2 \cdot 0} = 0</math>
:<math>\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0</math>

Получаем систему следующих уравнений:
:<math>\begin{cases}
C_1 + C_2 = H \\
\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0
\end{cases}
</math>

Решая систему относительно <math>C_1</math> и <math>C_2</math>, получаем
:<math>C_{1,2} = \left ( \frac{1}{2} \pm \frac{K_v}{\sqrt{D}} \right ) \cdot H</math>

Все коэффициенты найдены, задачу можно считать решенной. Однако, есть еще один немаловаждый момент.

=== Оценка параметров ===

Выше уже было упомянуто, что колебательный процесс для нас недопустим. Скажем, в случае летящей стрелы, это могло выглядеть как ее периодические колебания вдоль траектории движения, что плохо скажется на реалистичности.

Математически, коэффициенты были рассчитаны так, чтобы этого избежать. Проблема заключается в том, что в случае клиента, мы имеем дело не с непрерывными математическими функциями, а с дискретной апроксимацией. Плюс к этому, изменение модуля прилагаемой силы осуществляется не непрерывно, а, естественно, тоже дискретно. Поскольку в моменты времени "между" коррекциями тело предоставлено само себе, оно и будет двигаться в указанную ему сторону. В худшем случае, при больших и плохо подобранных параметрах, уже после первого корректирующего воздействия, тело вылетит "за траекторию", соответственно возникнут колебания (возможно даже возрастающие).

Для избежания этого неприятного момента, попробуем оценить параметры и найти их "практический потолок", с тем, чтобы не позволять пользователю задавать значения выходящие за границы.

Итак, при моделировании, будем считать что в течение шага тело движется по прямой. Соответственно, сила, которая будет действовать на тело в течение первого шага, т.е. времени <math>T</math>, будет равна
:<math>F_p = - K_p \cdot V_x \cdot H \cdot m</math>

Соответственно, в течение первого шага тело будет двигаться с ускорением
:<math>a = - K_p \cdot Vx \cdot H</math>

Условие стабилизации — расстояние, которое преодолеет тело за первый шаг должно быть меньше <math>H</math>:
:<math>K_p \cdot V_x \cdot H \cdot \frac{T^2}{2} < H, \quad K_p \cdot V_x \cdot T^2 < 2, \quad K_p < \frac{2}{V_x \cdot {T^2}}</math>

Левая часть неравенства будет минимальной в случае, когда <math>V_x</math> максимальна, т.е. равна <math>\tfrac{K_v^2}{4 \cdot K_p}</math>.

Это означает, что в том случае когда модуль скорости тела меньше чем указанное значение, то коррекция происходить гладко; когда больше — в формуле для силы стабилизации положения <math>V_x</math> заменяется на <math>\tfrac{K_v^2}{4 \cdot K_p}</math>. Объяснение было дано выше, при оценке дискриминанта характеристического уравнения.

Из этого следует, что чтобы действительно сделать невидимым действие нашей силы на малых скоростях, необходимо, чтобы значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math> было бы достаточно большим. Мы взяли его по-умолчанию равным 10, но это значение можно бдет менять в свойствах каждого конкретного объекта.

Осталось только численно оценить коэффициенты <math>K_p</math> и <math>K_v</math>. Для <math>K_p</math> конкретное значение получается, если подставить в условие
:<math>K_p < \frac{2}{V_x \cdot T^2}</math>
значения <math>V_x = 10</math> и <math>T = 0.04</math>. Получается, что <math>K_p < 125</math>.

Для нахождения <math>K_v</math> вместо <math>V_x</math> необходимо подставить наибольшее возможное для нее значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math>:

:<math>K_p < \frac{2}{\frac{K_v^2}{4 \cdot K_p} \cdot T^2}, \quad K_p < \frac{2 \cdot 4 \cdot K_p}{K_v^2 \cdot T^2}, \quad 1 < \frac{8}{K_v^2 \cdot T^2}, \quad K_v^2 < \frac{8}{T^2}</math>

Окончательно,
:<math>K_v < \frac{2\sqrt{2}}{T}</math>

При подстановке значения <math>T = 0.04</math>, получается, что <math>K_v < 70</math>. В реальных условиях эти пределы взяты еще меньше, для защиты от граничных случаев. Конкретно, <math>K_p</math> по-умолчанию не может превышать 50, а <math>K_v</math> — 30

Алгоритм синхронизации

2008-10-24T13:43:36Z

Korvin: /* Оценка параметров */

Здесь будет рассмотрена математическая составляющая алгоритмов синхронизации физики. Понимающих в этом деле, просьба прокомментировать.

== Построение сплайна ==

Для синхронизации была выбрана форма кубических сплайнов, при которой за основу берутся значения функции и ее производной в двух точках.

Свойства сплайна:
:<math>s(t_i) = f(t_i), \quad s'(t_i) = f'(t_i)\!</math>

Уравнения сплайна:
:<math>s(t) = a + bt + ct^2 + dt^3\!</math>
:<math>s'(t) = b + 2ct + 3dt^2\!</math>

Для нахождения коэффициентов <math>a, b, c, d</math> записываем систему уравнений:
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = f(t_0) \\
a + bt_1 + ct_1^2 + dt_1^3 = f(t_1) \\
b + 2ct_0 + 3dt_0^2 = f'(t_0) \\
b + 2ct_1 + 3dt_1^2 = f'(t_1)
\end{cases}
</math>

Подставляем известные значения в правой части системы (даны по условию):
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b + 2ct_0 + 3dt_0^2 = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Поскольку сплайн не зависит от конкретных значений <math>t_0</math> и <math>t_1</math>, положим <math>t_0 = 0</math>, а <math>t_1 = t</math>. В результате, пара уравнений становится тривиальной:
:<math>\begin{cases}
a = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Заменяем в оставшихся уравнениях известные теперь коэффициенты и получаем конечную систему:
:<math>\begin{cases}
x_0 + v_0t_1 + ct_1^2 + dt_1^3 = x_1 \\
v_0 + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

После нехитрых манипуляций, получаем выражения для оставшихся коэффициентов:
:<math>\begin{cases}
c = \frac{3x_1 - 3x_0 - 2v_0t - v_1t}{t^2} \\
d = \frac{v_1t - 2x_1 + 2x_0 + v_ot}{t^3}
\end{cases}
</math>

Ниже представлены графики оригинальной функции с наложенным на них графиком сплайна, построенного по точкам. Парабола и экспонента построены по фиксированному набору точек (-2.5, -2, -0.5, 0.5, 2, 2.5). Синусоида построена по точкам с интервалом 0.05.
<gallery>
Изображение:Exp.gif|Экспонента
Изображение:Parabola2.gif|Парабола
Изображение:Sin.gif|Синус
</gallery>

== Механизм коррекции ошибки ==

На клиенте Диптауна работает физический движок - точно такой же, как и на сервере. Он хранит в памяти собственную копию мира (в пределах некотрого радиуса видимости), и, по приходящим от сервера данным, старается делать его наиболее похожим на мир, который находится на сервере.

В идеальном случае, при нулевой задержке времени между клиентом и сервером, а также при достаточно большой частоте обновлений, рассинхронизация между миром клиента и миром сервера была бы пренебрежимо мала. Однако, суровая реальность говорит обратное. В результате, клиентская часть, по сути, находится в прошлом от серверной (на время половины пинга). Поэтому, возникает необходимость подгонять траекторию движения клиентских тел так, чтобы она коррелировала с эталонной, серверной траекторией, опорные точки которой мы получаем.

Коррекция осуществляется путем приложения сторонней силы к движущемуся телу так, чтобы "подтолкнуть" его в сторону желаемой траектории. Коррекция осуществляется в отношении собственно координаты тела и в отношении вектора его скорости. Опять же, в идеальном случае, скорректированная траектория полностью накладывается на серверную, вплоть до равенства параметров в соответствующих точках. Необходимо найти такую корректирующую силу, которая бы наиболее быстро и незаметно сблизила бы реальную траекторию движения с идеальной. Задача сводится к нахождению уравнения движения, а также определению граничных параметров, которые позволят выполнить коррекцию гладко, без перерегулирования.

=== Поиск уравнения коррекции ===

Рассмотрим некоторый объект. В клиентской копии мира, он находится в некоторой точке и движется по некоторой траектории. Одновременно с этим, с сервера поступают данные о том, по какой траектории он движется на сервере. По этим данным клиент строит сплайн, описанный в предыдущем разделе, и получает траекторию, по которой данный объект должен двигаться на самом деле. Таким образом, в каждый момент времени нам известны вектор положения и вектор скорости объекта, а также вектор положения и вектор скорости, с которыми он должен двигаться в этот момент по данным сервера.

Для того, чтобы стабилизировать траекторию объекта, мы должны приложить к нему две силы - для коррекции положения и для коррекции скорости. Сумма двух этих сил скорректирует траекторию объекта некоторым образом. Если она будет слишком маленькой - мы не добъемся необходимого эффекта; если слишком большой - объект "перелетит" нужную нам траекторию, и начнет колебаться вокруг нее под действием этой силы - такое поведение, конечно, недопустимо. Для того, чтобы подобрать оптимальную силу, мы запишем уравнение движения объекта под ее действием и, проанализировав параметры, подберем оптимальные значения для регулирующих коэффициентов.

Сила коррекции координаты должна быть направлена по разности векторов положений объектов, и пропорциональна этой разности. Также она должна быть пропорциональна массе объекта - чтобы и тяжелые, и легкие объекты вели себя одинаково. Кроме того, подумав, мы решили что эта сила должна быть пропорциональна модулю скорости объекта - для того, чтобы при малых скоростях ее действие не было бы слишком заметным для глаз пользователя (впрочем, с этим множителем не все так просто - см. ниже). Осталось домножить все это на некоторый коэффициент пропорциональности - именно его мы и будем анализировать.

Сила коррекции скорости, аналогично: направлена по разности векторов скорости, пропорциональна этой разности; пропорциональна массе тела и некоторому второму коэффициенту.

Осталось убедиться, что сумма этих сил действительно стабилизирует траекторию движения объекта, не приведет к колебаниям, и найти оптимальные значения для коэффициентов двух сил.

Чтобы упростить себе жизнь, рассмотрим двумерный случай. Пусть серверная траектория тела совпадает с осью X; клиентская траектория — параллельна этой оси и находится от нее на расстоянии, равном H. В нулевой момент времени тело находится в нуле по оси X как на клиентской, так и на серверной траекториях.

Пусть и серверная, и клиентская точки имеют горизонтальную скорость <math>V_x</math>, а по вертикальной оси они неподвижны. Никаких прочих сил на объект не действует. Поскольку никаких сил по горизонтали не действует, мы будем рассматривать только движение по оси y.

Сила коррекции высоты, по такой модели, будет направлена "вниз" на эту точку, и будет равна:
:<math>F_p = - K_p \cdot y(t) \cdot V_x \cdot m</math>
где <math>y</math> — это высота точки и
:<math>y(0) = H\!</math>

Множитель <math>V_x</math> мы добавляем специально, чтобы уменьшить влияние силы коррекции на малых скоростях (иначе еле движущееся тело будет менять свое положение заметными глазу рывками).

Сила коррекции вертикальной скорости точки:
:<math>F_v = - K_v \cdot V_y(t) \cdot m</math>
и
:<math>V_y(0) = 0\!</math>

Известно, что скорость — это производная координаты по времени:
:<math>V_y(t) = \frac{\partial y(t)}{\partial t}</math>

Соответственно, сила, которая действует на объект:
:<math>F(t) = m \cdot y''(t) = F_p + F_v = - K_p \cdot y(t) \cdot V_x \cdot m - K_v \cdot V_y(t) \cdot m</math>

:<math>F - F_p - F_v = 0\!</math>

Разделив на массу, и записав уравнение в дифференциальной форме, получим:
:<math>y''(t) + K_v \cdot y'(t) + K_p \cdot y(t) \cdot Vx = 0</math>

Перепишем параметрически:
:<math>y''(t) + A \cdot y'(t) + B \cdot y(t) = 0\!</math>

Характеристическое уравнение:
:<math>\lambda^2 + A \cdot \lambda + B = 0</math>

Дискриминант характеристического уравнения:
:<math>D = A^2 - 4 \cdot B = K_v^2 - 4 \cdot K_p \cdot V_x</math>

Для исключения колебательного процесса, необходимо условие <math>D \geqslant 0</math>. Следовательно:
:<math>K_v^2 - 4 \cdot K_p \cdot V_x \geqslant 0</math>
:<math>K_v^2 \geqslant 4 \cdot K_p \cdot V_x, \quad V_x \leqslant \frac{K_v^2}{4 \cdot K_p}</math>

Видно, что если <math>V_x</math> будет больше чем эта дробь, то возникнут колебания (нарушается условие <math>D \geqslant 0</math>). Поэтому, при малых скоростях используется само значение <math>V_x</math>, а когда <math>V_x</math> численно становится больше этой дроби, следует заменять ее на эту дробь (ограничение сверху).

В конечном счете, коэффициенты <math>\alpha</math> выражаются как
:<math>\alpha_{1,2} = \frac{-K_v \pm \sqrt{D}}{2}</math>

Далее, найдем <math>C_1</math> и <math>C_2</math>:
:<math>y(t) = C_1 \cdot e^{\alpha_1 t} + C_2 \cdot e^{\alpha_2 t}</math>
Зная начальные условия <math>y(0) = H</math> (начальное расстояние между объектами) и <math>y'(t) = 0</math> получаем уравнение:

:<math>C_1 \cdot e^{\alpha_1 \cdot 0} + C_2 \cdot e^{\alpha_2 \cdot 0} = y(0) = H</math>
следовательно
:<math>C_1 + C_2 = H\!</math>.

Из второго условия:
:<math>\alpha_1 \cdot C_1 \cdot e^{\alpha_1 \cdot 0} + \alpha_2 \cdot C_2 \cdot e^{\alpha_2 \cdot 0} = 0</math>
:<math>\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0</math>

Получаем систему следующих уравнений:
:<math>\begin{cases}
C_1 + C_2 = H \\
\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0
\end{cases}
</math>

Решая систему относительно <math>C_1</math> и <math>C_2</math>, получаем
:<math>C_{1,2} = \left ( \frac{1}{2} \pm \frac{K_v}{\sqrt{D}} \right ) \cdot H</math>

Все коэффициенты найдены, задачу можно считать решенной. Однако, есть еще один немаловаждый момент.

=== Оценка параметров ===

Выше уже было упомянуто, что колебательный процесс для нас недопустим. Скажем, в случае летящей стрелы, это могло выглядеть как ее периодические колебания вдоль траектории движения, что плохо скажется на реалистичности.

Математически, коэффициенты были рассчитаны так, чтобы этого избежать. Проблема заключается в том, что в случае клиента, мы имеем дело не с непрерывными математическими функциями, а с дискретной апроксимацией. Плюс к этому, изменение модуля прилагаемой силы осуществляется не непрерывно, а, естественно, тоже дискретно. Поскольку в моменты времени "между" коррекциями тело предоставлено само себе, оно и будет двигаться в указанную ему сторону. В худшем случае, при больших и плохо подобранных параметрах, уже после первого корректирующего воздействия, тело вылетит "за траекторию", соответственно возникнут колебания (возможно даже возрастающие).

Для избежания этого неприятного момента, попробуем оценить параметры и найти их "практический потолок", с тем, чтобы не позволять пользователю задавать значения выходящие за границы.

Итак, при моделировании, будем считать что в течение шага тело движется по прямой. Соответственно, сила, которая будет действовать на тело в течение первого шага, т.е. времени <math>T</math>, будет равна
:<math>F_p = - K_p \cdot V_x \cdot H \cdot m</math>

Соответственно, в течение первого шага тело будет двигаться с ускорением
:<math>a = - K_p \cdot Vx \cdot H</math>

Условие стабилизации — расстояние, которое преодолеет тело за первый шаг должно быть меньше <math>H</math>:
:<math>K_p \cdot V_x \cdot H \cdot \frac{T^2}{2} < H, \quad K_p \cdot V_x \cdot T^2 < 2, \quad K_p < \frac{2}{V_x \cdot {T^2}}</math>

Левая часть будет минимальной в случае, когда <math>V_x</math> максимальна, т.е. равна <math>\tfrac{K_v^2}{4 \cdot K_p}</math>.

Это означает, что в том случае когда модуль скорости тела меньше чем указанное значение, то коррекция происходить гладко; когда больше — в формуле для силы стабилизации положения <math>V_x</math> заменяется на <math>\tfrac{K_v^2}{4 \cdot K_p}</math>. Объяснение было дано выше, при оценке дискриминанта характеристического уравнения.

Из этого следует, что чтобы действительно сделать невидимым действие нашей силы на малых скоростях, необходимо, чтобы значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math> было бы достаточно большим. Мы взяли его по-умолчанию равным 10, но это значение можно бдет менять в свойствах каждого конкретного объекта.

Осталось только численно оценить коэффициенты <math>K_p</math> и <math>K_v</math>. Для <math>K_p</math> конкретное значение получается, если подставить в условие
:<math>K_p < \frac{2}{V_x \cdot T^2}</math>
значения <math>V_x = 10</math> и <math>T = 0.04</math>. Получается, что <math>K_p < 125</math>.

Для нахождения <math>K_v</math> вместо <math>V_x</math> необходимо подставить наибольшее возможное для нее значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math>:

:<math>K_p < \frac{2}{\frac{K_v^2}{4 \cdot K_p} \cdot T^2}, \quad K_p < \frac{2 \cdot 4 \cdot K_p}{K_v^2 \cdot T^2}, \quad 1 < \frac{8}{K_v^2 \cdot T^2}, \quad K_v^2 < \frac{8}{T^2}</math>

Окончательно,
:<math>K_v < \frac{2\sqrt{2}}{T}</math>

При подстановке значения <math>T = 0.04</math>, получается, что <math>K_v < 70</math>. В реальных условиях эти пределы взяты еще меньше, для защиты от граничных случаев. Конкретно, <math>K_p</math> по-умолчанию не может превышать 50, а <math>K_v</math> — 30

Алгоритм синхронизации

2008-10-23T12:23:03Z

Korvin: /* Поиск уравнения коррекции */

Здесь будет рассмотрена математическая составляющая алгоритмов синхронизации физики. Понимающих в этом деле, просьба прокомментировать.

== Построение сплайна ==

Для синхронизации была выбрана форма кубических сплайнов, при которой за основу берутся значения функции и ее производной в двух точках.

Свойства сплайна:
:<math>s(t_i) = f(t_i), \quad s'(t_i) = f'(t_i)\!</math>

Уравнения сплайна:
:<math>s(t) = a + bt + ct^2 + dt^3\!</math>
:<math>s'(t) = b + 2ct + 3dt^2\!</math>

Для нахождения коэффициентов <math>a, b, c, d</math> записываем систему уравнений:
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = f(t_0) \\
a + bt_1 + ct_1^2 + dt_1^3 = f(t_1) \\
b + 2ct_0 + 3dt_0^2 = f'(t_0) \\
b + 2ct_1 + 3dt_1^2 = f'(t_1)
\end{cases}
</math>

Подставляем известные значения в правой части системы (даны по условию):
:<math>\begin{cases}
a + bt_0 + ct_0^2 + dt_0^3 = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b + 2ct_0 + 3dt_0^2 = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Поскольку сплайн не зависит от конкретных значений <math>t_0</math> и <math>t_1</math>, положим <math>t_0 = 0</math>, а <math>t_1 = t</math>. В результате, пара уравнений становится тривиальной:
:<math>\begin{cases}
a = x_0 \\
a + bt_1 + ct_1^2 + dt_1^3 = x_1 \\
b = v_0 \\
b + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

Заменяем в оставшихся уравнениях известные теперь коэффициенты и получаем конечную систему:
:<math>\begin{cases}
x_0 + v_0t_1 + ct_1^2 + dt_1^3 = x_1 \\
v_0 + 2ct_1 + 3dt_1^2 = v_1
\end{cases}
</math>

После нехитрых манипуляций, получаем выражения для оставшихся коэффициентов:
:<math>\begin{cases}
c = \frac{3x_1 - 3x_0 - 2v_0t - v_1t}{t^2} \\
d = \frac{v_1t - 2x_1 + 2x_0 + v_ot}{t^3}
\end{cases}
</math>

Ниже представлены графики оригинальной функции с наложенным на них графиком сплайна, построенного по точкам. Парабола и экспонента построены по фиксированному набору точек (-2.5, -2, -0.5, 0.5, 2, 2.5). Синусоида построена по точкам с интервалом 0.05.
<gallery>
Изображение:Exp.gif|Экспонента
Изображение:Parabola2.gif|Парабола
Изображение:Sin.gif|Синус
</gallery>

== Механизм коррекции ошибки ==

В идеальном случае, при нулевой задержке времени между клиентом и сервером, а также при достаточно большой частоте обновлений, рассинхронизация между миром клиента и миром сервера была бы пренебрежимо мала. Однако, суровая реальность говорит обратное. В результате, клиентская часть, по сути, находится в прошлом от серверной (на время половины пинга). Поэтому, возникает необходимость подгонять траекторию движения клиентских тел так, чтобы она коррелировала с эталонной, серверной траекторией, опорные точки которой мы получаем.

Коррекция осуществляется путем приложения сторонней силы к движущемуся телу так, чтобы "подтолкнуть" его в сторону желаемой траектории. Коррекция осуществляется в отношении собственно координаты тела и в отношении вектора его скорости. Опять же, в идеальном случае, скорректированная траектория полностью накладывается на серверную, вплоть до равенства параметров в соответствующих точках. Задача сводится к нахождению дифференциального уравнения соответствующей силы, а также определению граничных параметров, которые позволят выполнить коррекцию гладко, без перерегулирования.

=== Поиск уравнения коррекции ===

Чтобы упростить себе жизнь, рассмотрим одномерный случай. Пусть серверная "траектория" тела находится в точке 0; клиентская "траектория" — в точке с координатой H. Графически, это выглядит как вертикальная линия, в нуле — серверная траектория, в точке на высоте H — клиентская. Горизонтальную и вертикальную компоненты скорости будем рассматривать отдельно.

Пусть серверная точка имеет горизонтальную скорость <math>V_x</math>. Клиентская, в самом начале — горизонтальную скорость <math>V_x</math> и вертикальную, равную нулю.

Сила коррекции высоты, по такой модели, будет направлена "вниз" на эту точку, и будет равна:
:<math>F_p = - K_p \cdot y(t) \cdot V_x \cdot m</math>
где <math>y</math> — это высота точки и
:<math>y(0) = H\!</math>

Множитель <math>V_x</math> мы добавляем специально, чтобы уменьшить влияние силы коррекции на малых скоростях (иначе еле движущееся тело будет менять свое положение заметными глазу рывками).

Сила коррекции вертикальной скорости точки:
:<math>F_v = - K_v \cdot V_y(t) \cdot m</math>
и
:<math>V_y(0) = 0\!</math>

Известно, что скорость — это производная координаты по времени:
:<math>V_y(t) = \frac{\partial y(t)}{\partial t}</math>

Соответственно, сила, которая действует на объект:
:<math>F(t) = m \cdot y''(t) = F_p + F_v = - K_p \cdot y(t) \cdot V_x \cdot m - K_v \cdot V_y(t) \cdot m</math>

:<math>F - F_p - F_v = 0\!</math>

Разделив на массу, и записав уравнение в дифференциальной форме, получим:
:<math>y''(t) + K_v \cdot y'(t) + K_p \cdot y(t) \cdot Vx = 0</math>

Перепишем параметрически:
:<math>y''(t) + A \cdot y'(t) + B \cdot y(t) = 0\!</math>

Характеристическое уравнение:
:<math>\lambda^2 + A \cdot \lambda + B = 0</math>

Дискриминант характеристического уравнения:
:<math>D = A^2 - 4 \cdot B = K_v^2 - 4 \cdot K_p \cdot V_x</math>

Для исключения колебательного процесса, необходимо условие <math>D \geqslant 0</math>. Следовательно:
:<math>K_v^2 - 4 \cdot K_p \cdot V_x \geqslant 0</math>
:<math>K_v^2 \geqslant 4 \cdot K_p \cdot V_x, \quad V_x \leqslant \frac{K_v^2}{4 \cdot K_p}</math>

Видно, что если <math>V_x</math> будет больше чем эта дробь, то возникнут колебания (нарушается условие <math>D \geqslant 0</math>). Поэтому, при малых скоростях используется само значение <math>V_x</math>, а когда <math>V_x</math> численно становится больше этой дроби, следует заменять ее на эту дробь (ограничение сверху).

В конечном счете, коэффициенты <math>\alpha</math> выражаются как
:<math>\alpha_{1,2} = \frac{-K_v \pm \sqrt{D}}{2}</math>

Далее, найдем <math>C_1</math> и <math>C_2</math>:
:<math>y(t) = C_1 \cdot e^{\alpha_1 t} + C_2 \cdot e^{\alpha_2 t}</math>
Зная начальные условия <math>y(0) = H</math> (начальное расстояние между объектами) и <math>y'(t) = 0</math> получаем уравнение:

:<math>C_1 \cdot e^{\alpha_1 \cdot 0} + C_2 \cdot e^{\alpha_2 \cdot 0} = y(0) = H</math>
следовательно
:<math>C_1 + C_2 = H\!</math>.

Из второго условия:
:<math>\alpha_1 \cdot C_1 \cdot e^{\alpha_1 \cdot 0} + \alpha_2 \cdot C_2 \cdot e^{\alpha_2 \cdot 0} = 0</math>
:<math>\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0</math>

Получаем систему следующих уравнений:
:<math>\begin{cases}
C_1 + C_2 = H \\
\alpha_1 \cdot C_1 + \alpha_2 \cdot C_2 = 0
\end{cases}
</math>

Решая систему относительно <math>C_1</math> и <math>C_2</math>, получаем
:<math>C_{1,2} = \left ( \frac{1}{2} \pm \frac{K_v}{\sqrt{D}} \right ) \cdot H</math>

Все коэффициенты найдены, задачу можно считать решенной. Однако, есть еще один немаловаждый момент.

=== Оценка параметров ===

Выше уже было упомянуто, что колебательный процесс для нас недопустим. Скажем, в случае летящей стрелы, это могло выглядеть как ее периодические колебания вдоль траектории движения, что плохо скажется на реалистичности.

Математически, коэффициенты были рассчитаны так, чтобы этого избежать. Проблема заключается в том, что в случае клиента, мы имеем дело не с непрерывными математическими функциями, а с дискретной апроксимацией. Плюс к этому, изменение модуля прилагаемой силы осуществляется не непрерывно, а, естественно, тоже дискретно. Поскольку в моменты времени "между" коррекциями тело предоставлено само себе, оно и будет двигаться в указанную ему сторону. В худшем случае, при больших и плохо подобранных параметрах, уже после первого корректирующего воздействия, тело вылетит "за траекторию", соответственно возникнут колебания (возможно даже возрастающие).

Для избежания этого неприятного момента, попробуем оценить параметры и найти их "практический потолок", с тем, чтобы не позволять пользователю задавать значения выходящие за границы.

Итак, при моделировании, будем считать что в течение шага тело движется по прямой. Соответственно, сила, которая будет действовать на тело в течение первого шага, т.е. времени <math>T</math>, будет равна
:<math>F_p = - K_p \cdot V_x \cdot H \cdot m</math>

Соответственно, в течение первого шага тело будет двигаться с ускорением
:<math>a = - K_p \cdot Vx \cdot H</math>

Условие стабилизации — расстояние, которое преодолеет тело за первый шаг должно быть меньше <math>H</math>:
:<math>K_p \cdot V_x \cdot H \cdot \frac{T^2}{2} < H, \quad K_p \cdot V_x \cdot \frac{T^2}{2} < 2, \quad K_p < \frac{2}{V_x \cdot {T^2}}</math>

Левая часть будет минимальной в случае, когда <math>V_x</math> максимальна, т.е. равна <math>\tfrac{K_v^2}{4 \cdot K_p}</math>.

Это означает, что в том случае когда модуль скорости тела меньше чем указанное значение, то коррекция происходить гладко; когда больше — в формуле для силы стабилизации положения <math>V_x</math> заменяется на <math>\tfrac{K_v^2}{4 \cdot K_p}</math>. Объяснение было дано выше, при оценке дискриминанта характеристического уравнения.

Из этого следует, что чтобы действительно сделать невидимым действие нашей силы на малых скоростях, необходимо, чтобы значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math> было бы достаточно большим. Мы взяли его по-умолчанию равным 10, но это значение можно бдет менять в свойствах каждого конкретного объекта.

Осталось только численно оценить коэффициенты <math>K_p</math> и <math>K_v</math>. Для <math>K_p</math> конкретное значение получается, если подставить в условие
:<math>K_p < \frac{2}{V_x \cdot T^2}</math>
значения <math>V_x = 10</math> и <math>T = 0.04</math>. Получается, что <math>K_p < 125</math>.

Для нахождения <math>K_v</math> вместо <math>V_x</math> необходимо подставить наибольшее возможное для нее значение <math>\tfrac{K_v^2}{4 \cdot K_p}</math>:

:<math>K_p < \frac{2}{\frac{K_v^2}{4 \cdot K_p} \cdot T^2}, \quad K_p < \frac{2 \cdot 4 \cdot K_p}{K_v^2 \cdot T^2}, \quad 1 < \frac{8}{K_v^2 \cdot T^2}, \quad K_v^2 < \frac{8}{T^2}</math>

Окончательно,
:<math>K_v < \frac{2\sqrt{2}}{T}</math>

При подстановке значения <math>T = 0.04</math>, получается, что <math>K_v < 70</math>. В реальных условиях эти пределы взяты еще меньше, для защиты от граничных случаев. Конкретно, <math>K_p</math> по-умолчанию не может превышать 50, а <math>K_v</math> — 30