Просмотр исходного текста страницы Введение, или краткий обзор

__TOC__

(Введение...)

== Здравствуй, мир! ==

Классический пример программы, выводящей строку "Hello, world!" на экран, на языке K++ выглядит следующим образом:

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

external console_stream STDOUT;

export function void main()
{
    STDOUT.print("Hello, world!\n");
}
</source>


;1: Как уже [[Модули|отмечалось ранее]], в K++ любая программа или библиотека является модулем. Ключевое слово <tt>'''package'''</tt> используется для объявления имени модуля, в который должна быть скомпилирована программа.

;3: Здесь мы объявляем глобальную переменную ''STDOUT'', имеющую тип <tt>console_stream</tt>. Ключевое слово <tt>'''external'''</tt> помечает переменную как ''внешнюю'' — т.е. создаваемую пользователем. 

;5-8: Наконец, объявляется функция <tt>main()</tt>, которая вызывает метод <tt>print()</tt> объекта ''STDOUT'', передав ему строку "Hello, world!\n" в качестве параметра.

: Ключевое слово <tt>'''export'''</tt> говорит о том, что имя функции не следует декорировать. Декорирование имен применяется для того, чтобы дать возможность [[Функции#Перегрузка функций и операторов|перегружать функции]] с одинаковыми именами, но разными списками параметров (или параметрами разных типов).


Теперь несколько слов о том, как такая программа будет запущена. В первую очередь стоит отметить, что нет никаких стандартов на имя функции <tt>main()</tt> или объекта ''STDOUT''. На платформе Gide каждая программа является библиотекой, и порядок ее использования полностью определяется пользователем. В данном случае предполагается, что программа будет запускаться при помощи консольной команды '''gide.run''', реализованной в модуле стандартной библиотеки. Эта команда определяет три глобальные переменные ''STDIN'', ''STDOUT'' и ''STDERR'', имеющие тип <tt>console_stream</tt> и запускает функцию <tt>main()</tt>, экспортируемую программой.

Если бы мы, скажем, писали программу, генерирующую текстуру — никакой функции <tt>main()</tt> в ней не было бы. Набор экспортируемых ей функций полностью определялся бы требованиями генератора текстур, которые описаны в соответствующей документации.

== Более сложный пример ==

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

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

export function void main()
{
    var ary = [ 1, 2, 3, 4 ];
    var sums = new array;
    var int i;
    sums.push(ary[0]);
    for(i = 1; i < ary.size(); ++i)
        sums.push(sums[i-1] + ary[i]);
}
</source>

Смысл этой программы понятен интуитивно: создается два массива — исходный (''ary'') и результирующий (''sums''), и затем массив ''sums'' заполняется суммами чисел из массива ''ary'' от 0 до текущего индекса i.

;5-6: Особое внимание в этом примере следует уделить объявлениям переменных. Мы видим, что объявляются два [[Стандартные типы данных#Массивы|массива]] — ''ary'' и ''sums'',  причем в инструкции <tt>'''var'''</tt> их тип никак не указывается. В этом случае работает следующее правило: если при объявлении переменной ее тип не указан, то типом переменной становится тип результата инициализатора переменной, т.е. выражения, стоящего справа от оператора '='.

:Выражения, записанные в квадратных скобках через запятую — это встроенная в K++ конструкция, создающая объект, имеющий тип <tt>[[Стандартные типы данных#Массивы|array]]</tt> (объявленный в [[Стандартная библиотека gide|стандартной библиотеке]]) и заполненный соответствующими значениями.

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

;7: Здесь мы создаем переменную типа <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. Когда тип указан в самой конструкции <tt>'''var'''</tt> — объект соответствующего класса создается автоматически. Таким образом, например, следующие объявления эквивалентны:

<source lang="kpp">
var sums = new array;
var sums = [ ];
var array sums;
</source>

или

<source lang="kpp">
var i = 0;
var i = new int;
var int i;
</source>

Метод <tt>push()</tt> класса <tt>array</tt> добавляет элемент в конец массива; <tt>size()</tt> — возвращает количество элементов массива. Дальнейший код, думаю, объяснять не стоит.

== Использование блоков ==

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

Выглядит это следующим образом:

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

external console_stream STDOUT;

function void times(int i, block b)
{
    var int n;
    for(n = 0; n < i; ++n)
        b(n);
}

export function void main()
{
    times(3) { |i| STDOUT.print((i as string) + " "); };
    STDOUT.print("\n");
}
</source>

Результат выполнения программы:

 0 1 2

Данный пример также демонстрирует объявление параметров функции: это делается в стиле языка C. Впрочем, тип параметра функции можно опустить — в этом случае будет сгенерирован [[Переменные#Динамическая типизация на примере Ruby|динамический код]].

;14:В функции <tt>main()</tt> используется специальный синтаксис для вызова функции <tt>times()</tt>: тело блока идет сразу после оператора вызова функции. Такой синтаксис работает только в том случае, если параметр—блок объявлен последним.

Можно было бы переписать эту конструкцию так:

<source lang="kpp">
var b = { |i| STDOUT.print((i as string) + " "); };
times(3,b);
</source>

Параметры блока могут быть перечислены между символами "|" через запятую. В данном случае блок принимает один параметр — номер итерации.

== Расширение классов ==

Приведенный выше пример можно переписать следующим образом:

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

external console_stream STDOUT;

extend int {
    public const function void times(block b)
    {
        var int n;
        for (n = 0; n < this; ++n)
            b(n);
    }
}

export function void main()
{
    3.times() { |i| STDOUT.print((i as string) + " "); };
    STDOUT.print("\n");
}
</source>


;5-12: Оператор <tt>'''extend'''</tt> расширяет функционал класса — в данном случае класса <tt>[[Стандартные типы данных#Целые числа|int]]</tt>. Его использование аналогично объявлению класса, но объявленные внутри поля, методы и операторы будут добавлены к уже существующему классу.

: Таким образом, к классу <tt>int</tt>, объявленному в стандартной библиотеке, добавляется метод <tt>times()</tt>, вызывающий связанный блок количество раз, равное текущему числу (не забываем: мы добавляем метод в класс <tt>int</tt>, который отвечает за хранение числа).

;16: После такого объявления, в функции <tt>main()</tt> мы используем уже метод <tt>times()</tt> класса <tt>int</tt>: конструкция <tt>3.times()</tt> означает создание объекта 3 класса <tt>int</tt> и вызов у этого объекта метода <tt>times()</tt>.


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