Print($'{Arr(1,2,3)}')
теперь печатает содержимое массива
This commit is contained in:
Mikhalkovich Stanislav
parent
deef6b40d5
commit
7aed6ed062
|
|
@ -15,7 +15,7 @@ internal static class RevisionClass
|
|||
public const string Major = "3";
|
||||
public const string Minor = "11";
|
||||
public const string Build = "0";
|
||||
public const string Revision = "3693";
|
||||
public const string Revision = "3699";
|
||||
|
||||
public const string MainVersion = Major + "." + Minor;
|
||||
public const string FullVersion = Major + "." + Minor + "." + Build + "." + Revision;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
%MINOR%=11
|
||||
%REVISION%=3693
|
||||
%REVISION%=3699
|
||||
%COREVERSION%=0
|
||||
%MAJOR%=3
|
||||
|
|
|
|||
|
|
@ -112,9 +112,9 @@ Microsoft.NET - </span><a href="http://www.mono-project.com/">среда
|
|||
<li>Сборщик мусора начинает работу в момент
|
||||
исчерпания динамической памяти, его работа занимает несколько миллисекунд. Для
|
||||
приложений реального времени это непозволительно.</li>
|
||||
<li>Запуск .NET-приложения обязательно требует
|
||||
установки на компьютере платформы .NET. Без нее
|
||||
приложение работать не будет (Отметим, что в Windows Vista и в
|
||||
<li>Запуск .NET-приложения обязательно требует установки на компьютере
|
||||
платформы .NET. Без нее приложение работать не будет (Отметим, что в Windows
|
||||
начиная с
|
||||
<span lang="en-us">Windows 7 </span>платформа .NET встроена).</li>
|
||||
</ol>
|
||||
<p>Отметим, что достоинства платформы .NET
|
||||
|
|
|
|||
|
|
@ -58,13 +58,13 @@
|
|||
<hr>
|
||||
<p><b><font color="#0000FF"><i>Шаг 2.</i> </font></b>Переменные
|
||||
<code>a</code> и <code>b</code>
|
||||
считываются из полей ввода, выделенных желтым цветом, с помощью обычной процедуры <code>read</code>. Закроем окно задачника
|
||||
считываются из полей ввода, выделенных желтым цветом, с помощью обычной функции <code>
|
||||
ReadInteger</code>, <code>ReadReal</code> ... Закроем окно задачника
|
||||
и изменим программу следующим образом:
|
||||
</p>
|
||||
<blockquote>
|
||||
<code><b>uses</b> PT4;<br><b>var </b>a, b: integer;<b><br>
|
||||
begin</b><br> Task('Begin3');<br>
|
||||
read(a, b);<br>
|
||||
<code><b>uses</b> PT4;<br><b><br>begin</b><br> Task('Begin3');<br>
|
||||
<b>var (</b>a,b) := ReadInteger2;<br>
|
||||
<b>end</b>.</code>
|
||||
</blockquote>
|
||||
<p>После запуска этого вариант программы окно задачник примет вид:</p>
|
||||
|
|
@ -86,9 +86,8 @@
|
|||
<hr>
|
||||
<p><font color="#0000FF"><b><i>Шаг 3.</i> </b></font>Исправим тип исходных данных:</p>
|
||||
<blockquote>
|
||||
<code><b>uses</b> PT4;<br><b>var </b>a, b: real;<b><br>
|
||||
begin</b><br> Task('Begin3');<br>
|
||||
read(a, b);<br>
|
||||
<code><b>uses</b> PT4;<br><b><br>begin</b><br> Task('Begin3');<br>
|
||||
<b>var (</b>a,b) := ReadReal2;<br>
|
||||
<b>end</b>.</code>
|
||||
</blockquote>
|
||||
<p>Вновь запустим программу:</p>
|
||||
|
|
@ -106,12 +105,11 @@
|
|||
<p><font color="#0000FF"><b><i>Шаг 4.</i> </b></font>Проведем
|
||||
вычисления и выведем результирующие данные, но в неверном порядке:</p>
|
||||
<blockquote>
|
||||
<code><b>uses</b> PT4;<br><b>var </b>a, b, S, P: real;<b><br>
|
||||
begin</b><br> Task('Begin3');<br>
|
||||
read(a, b);<br>
|
||||
S := a * b;<br>
|
||||
P := 2 * (a + b);<br>
|
||||
write(P, S)<br>
|
||||
<code><b>uses</b> PT4;<br><b><br>begin</b><br> Task('Begin3');<br>
|
||||
<b>var (</b>a,b) := ReadReal2;<br>
|
||||
<b>var </b>S := a * b;<br>
|
||||
<b>var </b>P := 2 * (a + b);<br>
|
||||
Print(P, S)<br>
|
||||
<b>end</b>.</code>
|
||||
</blockquote>
|
||||
<p>Вновь запустим программу:</p>
|
||||
|
|
@ -129,10 +127,12 @@
|
|||
<p><font color="#0000FF"><b><i>Шаг 5.</i> </b></font>Исправим
|
||||
ошибку:</p>
|
||||
<blockquote>
|
||||
<code><b>uses</b> PT4;<br><b>var </b>a, b, S, P: real;<b><br>begin</b><br> Task('Begin3');<br> read(a, b);<br>
|
||||
S := a * b;<br>
|
||||
P := 2 * (a + b);<br>
|
||||
write(S, P)<br><b>end</b>.</code>
|
||||
<code><b>uses</b> PT4;<br><b><br>begin</b><br> Task('Begin3');<br>
|
||||
<b>var (</b>a,b) := ReadReal2;<br>
|
||||
<b>var </b>S := a * b;<br>
|
||||
<b>var </b>P := 2 * (a + b);<br>
|
||||
Print(S, P)<br>
|
||||
<b>end</b>.</code>
|
||||
</blockquote>
|
||||
<p>После запуска программы увидим следующее окно:</p>
|
||||
<blockquote>
|
||||
|
|
|
|||
|
|
@ -37,13 +37,14 @@
|
|||
<img border="0" src="gif/Load.gif" width="16" height="17"> или клавиатурной
|
||||
комбинации <b>Shift+Ctrl+L</b>. Приведем текст созданной заготовки:
|
||||
</p>
|
||||
<blockquote><code><pre><b>uses</b> PT4Exam;
|
||||
<blockquote><code><b>uses</b> PT4Exam;
|
||||
|
||||
<b>begin</b>
|
||||
<b><br><br>begin</b>
|
||||
<br>
|
||||
Task('ExamBegin2');
|
||||
|
||||
<b>end</b>.
|
||||
</pre></code></blockquote>
|
||||
<b><br>end</b>.
|
||||
</code></blockquote>
|
||||
<p>После запуска программы на экране появится <a href="../PT4/window.html">окно задачника</a>:
|
||||
</p>
|
||||
<blockquote>
|
||||
|
|
@ -93,33 +94,15 @@
|
|||
<p>Приступим к выполнению задания. В данном случае следует использовать алгоритм, не требующий
|
||||
применения массивов, поэтому опишем три простые переменные вещественного типа и введем в них исходные данные:
|
||||
</p>
|
||||
<blockquote><code><pre><b>uses</b> PT4Exam;
|
||||
<b>var</b>
|
||||
a, b, c: real;
|
||||
<b>begin</b>
|
||||
<blockquote><code><b>uses</b> PT4Exam;
|
||||
<b><br><br>begin</b> <br>
|
||||
Task('ExamBegin2');
|
||||
read(a, b, c);
|
||||
<b>end</b>.
|
||||
</pre></code></blockquote>
|
||||
<p>Мы воспользовались стандартной процедурой ввода <code>read</code>, введя все три исходных числа за один ее вызов.
|
||||
Этого же результата мы могли бы добиться и с помощью процедуры <code>readln</code>:
|
||||
</p>
|
||||
<blockquote><code><pre>readln(a, b, c);
|
||||
</pre></code></blockquote>
|
||||
<p>Заметим, что использование <i>отдельных</i> процедур <code>readln</code> для ввода каждого числа приведет к ошибочному результату:
|
||||
</p>
|
||||
<blockquote><code><pre>readln(a);
|
||||
readln(b);
|
||||
readln(c);
|
||||
</pre></code></blockquote>
|
||||
<p>В этом случае уже после ввода первого числа произойдет автоматический переход на следующую строку
|
||||
с исходными данными. Поэтому оставшиеся в первой строке числа будут пропущены, а поскольку
|
||||
во второй строке «ничего нет» (входной поток состоит из единственной строки),
|
||||
будет выведено сообщение об ошибке «<i>Input string was not in a correct format</i>»
|
||||
(«<i>Входная строка имела неверный формат</i>»).
|
||||
</p>
|
||||
<p>Приведенный пример показывает, что при организации ввода данных в заданиях групп Exam необходимо учитывать особенности
|
||||
стандартных процедур <code>read</code> и <code>readln</code>.
|
||||
<br>
|
||||
<b>var</b>
|
||||
(a,b,c) := ReadReal3;
|
||||
<b><br>end</b>.
|
||||
</code></blockquote>
|
||||
<p>Мы воспользовались стандартной функцией ввода <code>ReadReal3</code>, введя все три исходных числа за один ее вызов.
|
||||
</p>
|
||||
<p>При запуске приведенного выше варианта программы вид окна не изменится, поскольку мы не вывели никаких данных.
|
||||
В заданиях групп Exam запуск программы считается ознакомительным до тех пор, пока программа не выведет
|
||||
|
|
@ -132,22 +115,24 @@ readln(c);
|
|||
<p>Реализуем алгоритм нахождения минимального и максимального элемента. Для этого опишем еще две
|
||||
переменные <code>min</code> и <code>max</code> типа <code>real</code> и добавим в конец программы следующие операторы:
|
||||
</p>
|
||||
<blockquote><code><pre><b>if</b> a < b <b>then</b>
|
||||
<b>begin</b>
|
||||
<blockquote><code><b>if</b> a < b <b>then</b>
|
||||
<b><br>begin</b>
|
||||
<br>
|
||||
min := a;
|
||||
max := b;
|
||||
<b>end</b>
|
||||
<b>else</b>
|
||||
<b>begin</b>
|
||||
<br> max := b;
|
||||
<b><br>end</b>
|
||||
<b><br>else</b>
|
||||
<b><br>begin</b> <br>
|
||||
min := b;
|
||||
max := a;
|
||||
<b>end</b>;
|
||||
<b>if</b> c < min <b>then</b>
|
||||
<br> max := a;
|
||||
<b><br>end</b>;
|
||||
<b><br>if</b> c < min <b>then</b> <br>
|
||||
min := c
|
||||
<b>else</b>
|
||||
<b>if</b> c > max <b>then</b>
|
||||
<b><br>else</b>
|
||||
<b>if</b> c > max <b>then</b> <br>
|
||||
max := c;
|
||||
</pre></code></blockquote>
|
||||
|
||||
</code></blockquote>
|
||||
<p>Таким образом, для одновременного нахождения минимального и максимального из трех чисел требуется
|
||||
не более трех операций сравнения и не более трех операций присваивания.
|
||||
</p>
|
||||
|
|
@ -161,8 +146,7 @@ readln(c);
|
|||
<p>Вначале, в качестве примера, организуем вывод, не соответствующий условиям задачи. Для этого добавим в конец программы
|
||||
следующий оператор:
|
||||
</p>
|
||||
<blockquote><code><pre>writeln(min, max);
|
||||
</pre></code></blockquote>
|
||||
<blockquote><code>Println(min, max); </code></blockquote>
|
||||
<p>Приведем вид окна задачника при запуске полученной программы:
|
||||
</p>
|
||||
|
||||
|
|
@ -189,16 +173,12 @@ readln(c);
|
|||
</p>
|
||||
<p>Для исправления первых двух ошибок достаточно изменить вывод следующим образом:
|
||||
</p>
|
||||
<blockquote><code><pre>writeln('MIN=', min);
|
||||
writeln('MAX=', max);
|
||||
</pre></code></blockquote>
|
||||
<blockquote><code>Println('MIN=', min); <br>Println('MAX=', max); </code></blockquote>
|
||||
<p>Однако в этом случае числа по-прежнему могут содержать неверное число дробных знаков.
|
||||
Для исправления этой последней ошибки проще всего использовать
|
||||
<i>атрибуты форматирования</i>, начинающиеся с символа «:» (двоеточие):
|
||||
</p>
|
||||
<blockquote><code><pre>writeln('MIN=', min:0:2);
|
||||
writeln('MAX=', max:0:2);
|
||||
</pre></code></blockquote>
|
||||
<blockquote><code>Println('MIN=', min:0:2); <br>Println('MAX=', max:0:2); </code></blockquote>
|
||||
<p>Первый атрибут определяет <i>ширину поля вывода</i> (если ширина равна 0, то используется минимально
|
||||
необходимое поле вывода). Наличие второго атрибута (допустимого только для вещественных чисел) означает,
|
||||
что число надо вывести в формате с фиксированной точкой, причем его значение равно количеству дробных знаков.
|
||||
|
|
|
|||
|
|
@ -49,47 +49,6 @@ Programming Taskbook</a> свидетельствует, что обучение
|
|||
Робот.</a></p>
|
||||
<p>Исполнитель Робот является бесценным источником заданий для быстрого обучения
|
||||
основным конструкциям программирования школьников средних классов. </p>
|
||||
<p><a href="ctstring.html">Пример 3. Задание String9
|
||||
из электронного задачника <b>Programming Taskbook</b>.</a></p>
|
||||
<p>Данное задание знакомит с особенностями выполнения заданий на обработку символов
|
||||
и строк. Следует обратить внимание на диагностику ошибки, связанной с выводом строки, длина которой превышает длину
|
||||
строки — правильного решения.</p>
|
||||
<p><a href="ctfile.html">Пример 4. Задание File48
|
||||
из электронного задачника <b>Programming Taskbook</b>.</a></p>
|
||||
<p>Это задание знакомит с особенностями выполнения заданий
|
||||
на обработку типизированных файлов. Исходные файлы при вызове
|
||||
задания создаются на диске, после чего могут обрабатываться по стандартным
|
||||
правилам. Содержимое файлов, созданных в процессе выполнения задания,
|
||||
проверяется электронным задачником; после проверки исходные и результирующие
|
||||
файлы автоматически удаляются. Следует обратить внимание на то, как содержимое
|
||||
файлов отображается в окне задачника, а также на обработку ошибок времени
|
||||
выполнения, возникающих при выполнении заданий. В примере описаны типичные ошибки при
|
||||
работе с файлами и способы их устранения. </p>
|
||||
<p><a href="ctpointer.html">Пример 5. Задания группы Dynamic
|
||||
из электронного задачника <b>Programming Taskbook</b>.</a></p>
|
||||
<p>В данном примере описываются задания из раздела, посвященного указателям и линейным динамическим
|
||||
структурам данных. При вызове задания в динамической памяти создаются все
|
||||
исходные структуры данных (в виде односвязных или двусвязных списков), а
|
||||
указатели на элементы этих структур выступают в качестве входных данных задания.
|
||||
Содержимое всех структур данных отображается в окне задачника в наглядном виде.
|
||||
Созданные программой ученика структуры данных анализируются задачником и после
|
||||
анализа все структуры данных удаляются из памяти. </p>
|
||||
<p><a href="cttree.html">Пример 6. Задания группы Tree
|
||||
из электронного задачника <b>Programming Taskbook</b>.</a></p>
|
||||
<p>В данном примере описываются задания на обработку иерархических структур данных —
|
||||
деревьев. Подобные структуры, как и линейные динамические структуры, рассмотренные
|
||||
в предыдущем примере, создаются задачником автоматически и в наглядном виде отображаются
|
||||
в его окне. Для доступа к ним также используются указатели.
|
||||
</p>
|
||||
<p><a href="ctexam.html">Пример 7. Задания групп ExamBegin и ExamTaskC
|
||||
из электронного задачника <b>Programming Taskbook</b>.</a></p>
|
||||
<p>Пример содержит описание процесса выполнения заданий, связанных с ЕГЭ
|
||||
по информатике. Основной особенностью этих заданий является то, что
|
||||
при их выполнении требуется использовать стандартные процедуры ввода-вывода языка
|
||||
Pascal (а не их специальные модификации, реализованные для задачника <b>Programming Taskbook</b>).
|
||||
Рассматриваются задания из группы ExamBegin, посвященные базовым алгоритмам,
|
||||
и задания из группы ExamTaskC, посвященные обработке сложных наборов данных.
|
||||
</p>
|
||||
<p>Все примеры, связанные с электронным задачником <b>Programming Taskbook</b>, иллюстрируются
|
||||
изображениями окна задачника
|
||||
в <a href="..\PT4\window.html#dynmode">режиме с динамической компоновкой</a>, появившемся в версии 4.11.
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ protected, атрибуты static, virtual и override для методов. <
|
|||
<blockquote>
|
||||
<p><code><b>type </b>AuthorAttribute = <strong>class</strong>(System.Attribute)<br>
|
||||
<strong>auto</strong> property Name: string;<br> <strong>constructor</strong> (n: string);<br>
|
||||
<strong>begin</strong><br> name := n;<br> <strong>end</strong>; <strong><br>end</strong>;</code></p>
|
||||
<strong>begin</strong><br> Name := n;<br> <strong>end</strong>; <strong><br>end</strong>;</code></p>
|
||||
</blockquote>
|
||||
<p>Следует обратить внимание, что класс атрибута принято оканчивать на <code>
|
||||
Attribute</code>.</p>
|
||||
|
|
@ -42,7 +42,7 @@ Attribute</code>.</p>
|
|||
<p>Следует обратить внимание, что окончание <code>Attribute</code> можно не
|
||||
указывать.</p>
|
||||
<p>Распознать, помечен ли данный класс атрибутом, можно, используя
|
||||
отражение: </p>
|
||||
анализ типа: </p>
|
||||
<blockquote>
|
||||
<p><code><strong>begin</strong> <br> <strong>var</strong> t := typeof(My);
|
||||
<br> <strong>var</strong> attrs := t.GetCustomAttributes(false); <br>
|
||||
|
|
@ -51,7 +51,7 @@ Attribute</code>.</p>
|
|||
<strong>then</strong> <br> Print(auth.Name);
|
||||
<br><strong>end</strong>.</code></p>
|
||||
</blockquote>
|
||||
<p>След</p>
|
||||
<p> </p>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
|
@ -27,9 +27,9 @@
|
|||
<blockquote><code><b>type</b> Person = <strong>auto class</strong><br>
|
||||
name: string;<br> age: integer;<br><strong>end</strong>;<br><strong>
|
||||
var</strong> p := new Person('Иванов',20); // конструктор автокласса
|
||||
генерируется автоматически<br>Writeln(p); // вызывается сгенерированный
|
||||
генерируется автоматически<br>Println(p); // вызывается сгенерированный
|
||||
автоматически метод ToString</code></blockquote>
|
||||
<p>Здесь в отличие от действия writeln по умолчанию выводятся значения не только
|
||||
<p>Здесь в отличие от действия Println по умолчанию выводятся значения не только
|
||||
публичных, а всех полей.</p>
|
||||
</body>
|
||||
|
||||
|
|
|
|||
|
|
@ -26,14 +26,10 @@
|
|||
<b> ...<br>
|
||||
</b> <b>procedure</b> IncCourse; <br>
|
||||
<b>end</b>;<br>
|
||||
...<br>
|
||||
<b>var <br>
|
||||
</b>p: Person;<br>
|
||||
s: Student;<br>
|
||||
<b>begin</b><br>
|
||||
p := new Student('Иванов',20,3,1); //
|
||||
<b><br>begin</b><br>
|
||||
<strong>var </strong>p: Person := new Student('Иванов',20,3,1); //
|
||||
неявное преобразование к типу базового класса<br>
|
||||
s := Student(p); // явное
|
||||
<strong>var</strong> s: Student := Student(p); // явное
|
||||
приведение к типу производного класса <br>
|
||||
<b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ property</span></b><span lang="en-us"> Coun: integer <b>read</b> cnt;</span><br>
|
|||
<p><code><span lang="en-us"><b>begin</b><br>
|
||||
<b>var</b> p: Person := new Person('</span>Иванов<span lang="en-us">',20);<br>
|
||||
<b>var</b> p1: Person := new Person('</span>Петров<span lang="en-us">',18);<br>
|
||||
Writeln(Person.Count); // </span>обращение к классовому методу
|
||||
Println(Person.Count); // </span>обращение к классовому методу
|
||||
<span lang="en-us">Count<br>
|
||||
<b>end</b>.</span></code></p>
|
||||
<p>В отличие от статических полей и методов, обычные поля и методы называются
|
||||
|
|
|
|||
|
|
@ -25,14 +25,14 @@
|
|||
<strong>end</strong>;<br>
|
||||
<br><strong>begin<br></strong> MyPrint(1);<br> 1.MyPrintEx;<br>
|
||||
<strong>end</strong>.</code></blockquote>
|
||||
<p>Здесь MyPrint - это обычная процедура с параметром типа integer, MyPrintEx -
|
||||
метод расширения типа integer. При этом при вызове первый параметр MyPrintEx
|
||||
становится объектом, вызывающим MyPrintEx как метод.</p>
|
||||
<p>Здесь <code>MyPrint</code> - это обычная процедура с параметром типа integer, MyPrintEx -
|
||||
метод расширения типа integer. При этом при вызове первый параметр <code>MyPrintEx</code> становится объектом, вызывающим
|
||||
<code>MyPrintEx</code> как метод.</p>
|
||||
<p>Можно расширить тип последовательности, тогда все классы, являющиеся
|
||||
последовательностями (динамические одномерные массивы, списки List<T>, множества
|
||||
HashSet<T> и SortedSet<T>),
|
||||
последовательностями (динамические одномерные массивы, списки <code>List<T></code>, множества
|
||||
<code>HashSet<T></code> и <code>SortedSet<T></code>),
|
||||
получат этот метод. Например, в системном модуле PABCSystem так введен метод
|
||||
расширения ForEach для последовательностей:</p>
|
||||
расширения <code>ForEach</code> для последовательностей:</p>
|
||||
<blockquote><code><strong>procedure</strong> &ForEach<T>(Self: <strong>sequence
|
||||
of</strong> T; action: T -> ()); <strong>extensionmethod</strong>;<br>
|
||||
<strong>begin</strong><br> <strong>foreach</strong> x: T <strong>in</strong>
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@
|
|||
Print;<br><b> property</b> Name: string read fName;<br><b>
|
||||
property</b> Age: integer read fAge;<b><br> end</b>;<br><strong><br>
|
||||
procedure</strong> Person.Print;<br><strong>begin</strong><br>
|
||||
Writeln($'Имя: {Name} Возраст: {Age}');<br><strong>end</strong>;</code></p>
|
||||
Println($'Имя: {Name} Возраст: {Age}');<br><strong>end</strong>;</code></p>
|
||||
</blockquote>
|
||||
<p>После слова <code><b>class</b></code>
|
||||
в скобках может быть указано имя класса-предка (см. <A href="inheritance.html">
|
||||
|
|
@ -115,7 +115,7 @@
|
|||
<b> end</b>;<br>
|
||||
...<br>
|
||||
<b>var</b> p: Person := new Person('Иванов',20);<br>
|
||||
Writeln(p); // Имя: Иванов Возраст: 20</code></p>
|
||||
Println(p); // Имя: Иванов Возраст: 20</code></p>
|
||||
</blockquote>
|
||||
<h2>Присваивание и передача в качестве параметров подпрограмм</h2>
|
||||
<p>Переменная типа класс является ссылкой и хранит ссылку на объект, создаваемый
|
||||
|
|
@ -144,9 +144,9 @@
|
|||
значения. </p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> p1 := new Person('Петров',20);<br><b>var</b> p2 := new
|
||||
Person('Петров',20);<br>writeln(p1=p2); // False<br>
|
||||
Person('Петров',20);<br>Println(p1 = p2); // False<br>
|
||||
p2 := p1; <br>
|
||||
writeln(p1=p2); // True</code></p>
|
||||
Println(p1 = p2); // True</code></p>
|
||||
</blockquote>
|
||||
<p>Это поведение можно изменить, <A href="operoverloading.html">перегрузив</A>
|
||||
операцию = для класса.</p>
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ integer);<br>
|
|||
<p><code> <b>procedure</b> Print;<br>
|
||||
<b>begin</b><br>
|
||||
<b>inherited</b>;<br>
|
||||
writeln('Курс: ',course,' Группа: ',group);<br>
|
||||
Writeln('Курс: ',course,' Группа: ',group);<br>
|
||||
<b>end</b>;<br>
|
||||
</code></p>
|
||||
</body>
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ B</code>
|
|||
var </b>a1: A;<br>
|
||||
...<br>
|
||||
a1 := B.Create;<br>
|
||||
writeln(a1 <b>is</b> B); // True</code></p>
|
||||
Println(a1 <b>is</b> B); // True</code></p>
|
||||
</blockquote>
|
||||
<p>Если <code>a1</code> - переменная
|
||||
классового типа, а <code>B</code> - тип класса, то выражение <code>a1 <b>as</b>
|
||||
|
|
|
|||
|
|
@ -91,11 +91,19 @@ value: Complex);<br> <b>begin</b><br> &
|
|||
<b>end</b>;<br> <b>end</b>;</code></p>
|
||||
</blockquote>
|
||||
<p>Можно перегружать операции с помощью <a href="extensionmethods.html">методов расширения</a> - в этом случае при
|
||||
описании подпрограммы не следует писать слово class. Например, так в системном модуле
|
||||
описании подпрограммы не следует писать слово static. Например, так в системном модуле
|
||||
реализовано добавление числа к строке:</p>
|
||||
<blockquote>
|
||||
<p><code><strong>function</strong> operator+(str: string; n:
|
||||
integer): string; <strong>extensionmethod</strong>;<br><strong>begin</strong><br> result := str +
|
||||
<p><code><strong>function</strong> <strong>operator</strong>+(str: string; n:
|
||||
integer): string; <strong>extensionmethod</strong>;<br><strong>begin</strong><br>
|
||||
Result := str +
|
||||
n.ToString;<br><strong>end</strong>;</code></p>
|
||||
</blockquote>
|
||||
<p>При перегрузке операций методами расширения ключевое слово <code> <strong>extensionmethod</strong></code> можно не писать:</p>
|
||||
<blockquote>
|
||||
<p><code><strong>function</strong> <strong>operator</strong>+(str: string; n:
|
||||
integer): string;<br><strong>begin</strong><br>
|
||||
Result := str +
|
||||
n.ToString;<br><strong>end</strong>;</code></p>
|
||||
</blockquote>
|
||||
<p>Можно перегружать расширенные операции присваивания +=, -= и т.д.: </p>
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ PropertyReader</code></code>, при доступе на запись - <code>
|
|||
p.Age := p.Age + 1; // компилятор заменяет этот код на p.setAge(p.getAge
|
||||
+ 1);<br>
|
||||
|
||||
writeln(p.Id); <br><strong>end</strong>.</code></p>
|
||||
Println(p.Id); <br><strong>end</strong>.</code></p>
|
||||
</blockquote>
|
||||
<p>Всякий раз, когда мы присваиваем свойству <code>Age</code>
|
||||
новое значение,
|
||||
|
|
|
|||
|
|
@ -36,14 +36,14 @@
|
|||
public </b><br>
|
||||
<b>procedure</b> Print;<br>
|
||||
<b>begin</b><br>
|
||||
writeln('Base');<br>
|
||||
Println('Base');<br>
|
||||
<b>end</b>;<br>
|
||||
<b>end</b>;<br>
|
||||
Derived =<b> class</b>(Base)<br>
|
||||
<b> public </b><br>
|
||||
<b>procedure</b> Print;<br>
|
||||
<b>begin</b><br>
|
||||
writeln('Derived');<br>
|
||||
Println('Derived');<br>
|
||||
<b>end</b>;<br>
|
||||
<b>end</b>;</code> </p>
|
||||
</blockquote>
|
||||
|
|
@ -79,14 +79,14 @@
|
|||
public </b><br>
|
||||
<b>procedure</b> Print; <b>virtual</b>;<br>
|
||||
<b>begin</b><br>
|
||||
writeln('Base');<br>
|
||||
Println('Base');<br>
|
||||
<b>end</b>;<br>
|
||||
<b>end</b>;<br>
|
||||
Derived =<b> class</b>(Base)<br>
|
||||
<b> public </b><br>
|
||||
<b>procedure</b> Print; <b>override</b>;<br>
|
||||
<b>begin</b><br>
|
||||
writeln('Derived');<br>
|
||||
Println('Derived');<br>
|
||||
<b>end</b>;<br>
|
||||
<b>end</b>;</code> </p>
|
||||
</blockquote>
|
||||
|
|
@ -105,7 +105,7 @@ Derived</code> за счет того что решение о вызове ме
|
|||
<blockquote>
|
||||
<p><code><b>type</b><br> DerivedTwice1 =<b> class</b>(Derived)<br>
|
||||
<b> public </b><br> <b>procedure</b> Print; </code><code><b>reintroduce</b></code><code>;<br>
|
||||
<b>begin</b><br> writeln('DerivedTwice1');<br>
|
||||
<b>begin</b><br> Println('DerivedTwice1');<br>
|
||||
<b>end</b>;<br> <b>end</b>;</code> </p>
|
||||
</blockquote>
|
||||
<p>Если мы хотим начать новую цепочку виртуальности, то следует использовать и
|
||||
|
|
@ -114,7 +114,7 @@ Derived</code> за счет того что решение о вызове ме
|
|||
<p><code><b>type</b><br> DerivedTwice2 =<b> class</b>(Derived)<br>
|
||||
<b> public </b><br> <b>procedure</b> Print; </code><code><b>virtual</b>; </code><code>
|
||||
<b>reintroduce</b>;<br>
|
||||
<b>begin</b><br> writeln('DerivedTwice2');<br>
|
||||
<b>begin</b><br> Println('DerivedTwice2');<br>
|
||||
<b>end</b>;<br> <b>end</b>;</code> </p>
|
||||
</blockquote>
|
||||
<p>Если переопределить виртуальную функцию невиртуальной без ключевого слова
|
||||
|
|
|
|||
|
|
@ -57,21 +57,21 @@
|
|||
B =<b> class</b>(A)<br>
|
||||
<b> public<br>
|
||||
</b>
|
||||
<b> procedure</b> print;<br>
|
||||
<b> procedure</b> Print;<br>
|
||||
<b>begin</b><br>
|
||||
writeln(a); // верно, т.к.
|
||||
Println(a); // верно, т.к.
|
||||
a - защищенное поле<b><br>
|
||||
</b> writeln(x); // неверно,
|
||||
</b> Println(x); // неверно,
|
||||
т.к. х - закрытое поле<br>
|
||||
<b>end</b>;<br>
|
||||
<b>end</b>;<br>
|
||||
...<br>
|
||||
<b>var</b> b1: B := new B(5); <br>
|
||||
...<br>
|
||||
writeln(b1.x); // неверно, т.к. х - закрытое
|
||||
поле<br>writeln(b1.a); // неверно, т.к. a -
|
||||
Println(b1.x); // неверно, т.к. х - закрытое
|
||||
поле<br>Println(b1.a); // неверно, т.к. a -
|
||||
защищенное поле<br>
|
||||
b1.print; // верно, т.к. print -
|
||||
b1.Print; // верно, т.к. Print -
|
||||
открытый метод</code></blockquote>
|
||||
<p>Комментарии по тексту программы описывают верное и неверное в смысле доступа
|
||||
обращение к полям и методам.</p>
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@
|
|||
<param name="Keyword" value="string_nullbased">
|
||||
<param name="Keyword" value="platformtarget">
|
||||
<param name="Keyword" value="targetframework">
|
||||
<param name="Keyword" value="zerobasedstrings">
|
||||
|
||||
</object>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1251">
|
||||
<title></title>
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@
|
|||
x[0] := 1;<br>
|
||||
x[1] := 2.71;<br>
|
||||
x[2] := 3.14;<br>
|
||||
writeln(FindFirstInArray(x,1));<br>
|
||||
Println(FindFirstInArray(x,1));<br>
|
||||
<b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
<p>произойдет ошибка. Причина состоит в том, что первый параметр имеет тип
|
||||
|
|
@ -95,10 +95,10 @@ integer</span>, что не соответствует ни одному тип
|
|||
x := <b>new</b> Pair<integer,real>;<br>
|
||||
x.first := 3;<br>
|
||||
y := x.ChangeSecond('abc');<br>
|
||||
writeln(y.first, y.second);<br>
|
||||
Println(y.first, y.second);<br>
|
||||
<b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
<p>По окончании работы данная программа выведет 3abc.</p>
|
||||
<p>По окончании работы данная программа выведет 3 abc.</p>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
</p>
|
||||
<p>Например, <span lang="ru">в классе </span><code>System.Array</code>
|
||||
<span lang="ru">имеется несколько статических обобщенных методов с обобщенными
|
||||
подпрограммами в качестве параметров. Так</span>, <code>System.Array.Find</code>
|
||||
подпрограммами в качестве параметров. Так</span>, <code>System.Array.FindAll</code>
|
||||
<span lang="ru">имеет следующий прототип:</span></p>
|
||||
<blockquote>
|
||||
<p><code>System.Array.FindAll<T>(a: <b>array</b> <b>of</b> T; pred:
|
||||
|
|
@ -27,11 +27,7 @@
|
|||
<code>pred</code><span lang="ru">.</span></p>
|
||||
<p><span lang="ru">Приведем пример вызова этой функции:</span></p>
|
||||
<blockquote>
|
||||
<p><code><b>function</b> f(x: integer): boolean;<br>
|
||||
<b>begin</b><br>
|
||||
Result := ;<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>var</b> a := Seq(1,3,6,5,8);<br>
|
||||
<p><code><b>var</b> a := [1,3,6,5,8];<br>
|
||||
<b>var</b> b := System.Array.FindAll(a,x -> x <b>mod</b> 2 = 0);</code></p>
|
||||
</blockquote>
|
||||
<p><span lang="ru">Здесь возвращается массив </span><code>b</code><span lang="ru">,
|
||||
|
|
|
|||
|
|
@ -59,22 +59,19 @@ Stack<integer></code> - класс списка с элементами т
|
|||
</blockquote>
|
||||
<p>Использование шаблона класса иллюстрируется ниже:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> <br>
|
||||
si: Stack<integer>;<br>
|
||||
sr: Stack<real>;<br>
|
||||
<b>begin</b><br>
|
||||
si := <b>new</b> Stack<integer>; <br>
|
||||
sr := <b>new</b> Stack<real>;<br>
|
||||
<p><code><b>begin</b><br>
|
||||
<strong> var </strong>si := <b>new</b> Stack<integer>; <br>
|
||||
<strong> var </strong>sr := <b>new</b> Stack<real>;<br>
|
||||
<b>for</b> <span lang="en-us"><b>var</b> </span>i := 1 <b>to</b> 10 <b>do</b><br>
|
||||
si.Push(Random(100));<br>
|
||||
<b>while</b> <b>not</b> si.IsEmpty <b>do</b><br>
|
||||
sr.Push(si.Pop);<br>
|
||||
<b>while</b> <b>not</b> sr.IsEmpty <b>do</b><br>
|
||||
write(sr.Pop,' ');<br>
|
||||
Print(sr.Pop);<br>
|
||||
<b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
<p>Подстановка конкретного типа-параметра в обобщенный тип называется
|
||||
инстанцированием.</p>
|
||||
<strong>инстанцированием</strong>.</p>
|
||||
<p> </p>
|
||||
</body>
|
||||
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ read и write. </p>
|
|||
<b>end</b>;<br>
|
||||
<b>procedure</b> Print;<br>
|
||||
<b>begin</b><br>
|
||||
write(xx,' ',yy);<br>
|
||||
Print(xx,yy);<br>
|
||||
<b>end</b>;<br> <b>end</b>;</code></p>
|
||||
</blockquote>
|
||||
<p>Интерфейсы можно наследовать друг от
|
||||
|
|
@ -108,7 +108,7 @@ read и write. </p>
|
|||
...<br>
|
||||
<b>var</b> p: Point := ip <b>as</b> Point;<br>
|
||||
<b>if</b> p<>nil <b>then</b> <br>
|
||||
writeln('Преобразование успешно');</code></p>
|
||||
Println('Преобразование успешно');</code></p>
|
||||
</blockquote>
|
||||
</body>
|
||||
|
||||
|
|
|
|||
|
|
@ -38,9 +38,9 @@
|
|||
t1: TTT;</code></p>
|
||||
</blockquote>
|
||||
<p>Документирующие комментарии могут занимать несколько строк, каждая из которых
|
||||
должна начинаться с<span class="auto-style1"> ///</span> . Для комментирования
|
||||
должна начинаться с<code> ///</code> . Для комментирования
|
||||
подпрограмм можно использовать в первой строке документирующий комментарий
|
||||
<span class="auto-style1">///-</span>, тогда его содержимое меняет заголовок
|
||||
<code>///-</code>, тогда его содержимое меняет заголовок
|
||||
подпрограммы в подсказке при наведении курсора мыши. Например:</p>
|
||||
<blockquote>
|
||||
<p><code>///- Exclude(var s : set of T; el : T)<br>///Удаляет элемент el из
|
||||
|
|
@ -48,7 +48,7 @@
|
|||
TypedSet; el: object);</code></p>
|
||||
</blockquote>
|
||||
<p>Если первая строка документирующего комментария имеет вид
|
||||
<span class="auto-style1">///--</span>, то подсказка не всплывает. Это делается
|
||||
<code>///--</code>, то подсказка не всплывает. Это делается
|
||||
для элементов, которые хочется скрыть от системы всплывающих подсказок.</p>
|
||||
</body>
|
||||
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@
|
|||
<p><b><code>interface</code></b></p>
|
||||
<p><code><b>uses</b> GraphABC;</code></p>
|
||||
<p><code><b>const</b> Dim = 5;<br>
|
||||
<b>var</b> Colors: <b>array</b> [1..Dim] <b>of</b> integer;</code></p>
|
||||
<b>var</b> Colors: <b>array</b> <b>of</b> integer := new integer[Dim];</code></p>
|
||||
<p><code><b>function</b> RandomColor: integer;<br>
|
||||
<b>procedure</b> FillByRandomColor;</code></p>
|
||||
<p><b><code>implementation</code></b></p>
|
||||
|
|
@ -91,7 +91,7 @@
|
|||
<b>end</b>;<br>
|
||||
<b>procedure</b> FillByRandomColor;<br>
|
||||
<b>begin</b><br>
|
||||
<b>for</b> i: integer := 1 <b>to</b> Dim <b>do</b><br>
|
||||
<b>for</b> <strong>var </strong>i := 0 <b>to</b> Dim-1 <b>do</b><br>
|
||||
Colors[i] := RandomColor; <br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>initialization</b><br>
|
||||
|
|
|
|||
|
|
@ -78,21 +78,17 @@
|
|||
<span class="auto-style2"><em>ИмяБиблиотеки</em></span><span class="auto-style1">}</span>.
|
||||
Например:</p>
|
||||
<blockquote>
|
||||
<p><span class="auto-style1">{$reference ABC.dll}<br>{$reference ABC1.dll}<br>
|
||||
<br><strong>begin</strong><br> writeln(a.GetType); <br><strong>end</strong>.</span> </p>
|
||||
<p><code>{$reference ABC.dll}<br>{$reference ABC1.dll}<br>
|
||||
<br><strong>begin</strong><br> writeln(a.GetType); <br><strong>end</strong>.</code> </p>
|
||||
</blockquote>
|
||||
<p>Подключение библиотеки может проводиться в любом месте исходного файла.</p>
|
||||
<p>Библиотеки ABC и ABC1 имеют соответственно вид:</p>
|
||||
<blockquote>
|
||||
<p class="auto-style1"><strong>library</strong> ABC;</p>
|
||||
<p class="auto-style1"><strong>var</strong> a: integer;</p>
|
||||
<p><span class="auto-style1"><strong>end</strong>.</span> </p>
|
||||
</blockquote>
|
||||
<p><code><strong>library</strong> ABC;<strong><br>var</strong> a: integer;<strong><br>end</strong>.</code>
|
||||
</blockquote>
|
||||
<p>и</p>
|
||||
<blockquote>
|
||||
<p class="auto-style1"><strong>library</strong> ABC1;</p>
|
||||
<p class="auto-style1"><strong>var</strong> a: real;</p>
|
||||
<p><span class="auto-style1"><strong>end</strong>.</span> </p>
|
||||
<p><code><strong>library</strong> ABC1;<strong><br>var</strong> a: real;<strong><br>end</strong>.</code> </p>
|
||||
</blockquote>
|
||||
<h2>Алгоритм поиска имен в библиотеках </h2>
|
||||
<p>В первую очередь имя ищется в исходном модуле, затем в модулях, подключенных
|
||||
|
|
@ -103,9 +99,9 @@
|
|||
<p>В случае коллизии имен используемое имя можно предварять именем библиотеки с
|
||||
последующей точкой:</p>
|
||||
<blockquote>
|
||||
<p><span class="auto-style1">{$reference ABC.dll}<br>{$reference ABC1.dll}<br>
|
||||
<br><strong>begin</strong><br> writeln(ABC1.a.GetType); <br><strong>
|
||||
end</strong>.</span> </p>
|
||||
<p><code>{$reference ABC.dll}<br>{$reference ABC1.dll}<br>
|
||||
<br><strong>begin</strong><br> Println(ABC1.a.GetType); <br><strong>
|
||||
end</strong>.</code> </p>
|
||||
</blockquote>
|
||||
<p> </p>
|
||||
</body>
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ span.a
|
|||
раньше второй – в первый элемент массива запишется значение из второго, а если
|
||||
позже – то из третьего элемента массива.</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> a:integer;<br>
|
||||
<p><code><b>var</b> a: integer;<br>
|
||||
<font color="#666666">{$omp parallel for}<br>
|
||||
</font>
|
||||
<b>for</b> <b>var</b> i:=1 <b>to</b> 10 <b>do</b><br>
|
||||
|
|
@ -93,9 +93,7 @@ span.a
|
|||
параллельности. Вычисление различных элементов матрицы происходит независимо,
|
||||
поэтому не надо предусматривать никаких средств синхронизации.</span></p>
|
||||
<blockquote>
|
||||
<p><code><b>uses</b> Arrays;<br>
|
||||
<br>
|
||||
<b>procedure</b> ParallelMult(a,b,c: <b>array</b> [,] <b>of</b> real; n:
|
||||
<p><code><b>procedure</b> ParallelMult(a,b,c: <b>array</b> [,] <b>of</b> real; n:
|
||||
integer);<br>
|
||||
<b>begin</b><br>
|
||||
<font color="#666666"><span lang="ru"> </span>{$omp parallel for }<br>
|
||||
|
|
@ -127,17 +125,15 @@ span.a
|
|||
<br>
|
||||
<b>begin</b><br>
|
||||
<b><span lang="ru"> </span>var</b> a :=
|
||||
Arrays.CreateRandomRealMatrix(n,n);<br>
|
||||
MatrRandomReal(n,n);<br>
|
||||
<b><span lang="ru"> </span>var</b> b :=
|
||||
Arrays.CreateRandomRealMatrix(n,n);<br>
|
||||
MatrRandomReal(n,n);<br>
|
||||
<b><span lang="ru"> </span>var</b> c := new real[n,n];<br>
|
||||
<span lang="ru"> </span>ParallelMult(a,b,c,n);<br>
|
||||
<span lang="ru"> </span>writeln('Параллельное перемножение матриц:
|
||||
',Milliseconds,' миллисекунд');<br>
|
||||
<span lang="ru"> </span>Println('Параллельное перемножение матриц:',Milliseconds,'миллисекунд');<br>
|
||||
<b><span lang="ru"> </span>var</b> d := Milliseconds;<br>
|
||||
<span lang="ru"> </span>Mult(a,b,c,n);<br>
|
||||
<span lang="ru"> </span>writeln('Непараллельное перемножение матриц:
|
||||
',Milliseconds-d,' миллисекунд');<br>
|
||||
<span lang="ru"> </span>Println('Непараллельное перемножение матриц:',Milliseconds-d,'миллисекунд');<br>
|
||||
<b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
</body>
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@
|
|||
<blockquote>
|
||||
<p><code><b>var</b> a: integer := 1;<br>
|
||||
<font color="#666666">{$omp parallel for reduction(+:a)}<br>
|
||||
</font><b>for</b> <b>var</b> i: integer:=1 <b>to</b> 2 <b>do</b><br>
|
||||
</font><b>for</b> <b>var</b> i:=1 <b>to</b> 2 <b>do</b><br>
|
||||
a := a+1;</code></p>
|
||||
</blockquote>
|
||||
<p>Здесь начальное значение переменной a – единица, для действия + локальные
|
||||
|
|
|
|||
|
|
@ -26,11 +26,11 @@
|
|||
<p>Критические секции можно использовать при обращении к общим переменным, чтобы
|
||||
избежать потерь данных.</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> a:integer:=0;<br>
|
||||
<p><code><b>var</b> a: integer := 0;<br>
|
||||
<font color="#666666">{$omp parallel for}<br>
|
||||
</font><b>for</b> <b>var</b> i:integer:=1 <b>to</b> 100 <b>do</b><br>
|
||||
{$omp critical}<br>
|
||||
a:=a+1;</code></p>
|
||||
</font><b>for</b> <b>var</b> i:=1 <b>to</b> 100 <b>do</b><br>
|
||||
<font color="#666666"> {$omp critical}<br>
|
||||
</font> a := a + 1;</code></p>
|
||||
</blockquote>
|
||||
<p>Здесь критическую секцию можно использовать вместо редукции. Весь оператор
|
||||
<code>a:=a+1</code> выполнится одним потоком и только потом – другим. Однако использование
|
||||
|
|
@ -40,13 +40,13 @@
|
|||
<p>Но не во всех случаях использование критических секций помогает обеспечить
|
||||
корректную работу параллельных конструкций.</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> a:integer := 0;<br>
|
||||
<p><code><b>var</b> a: integer := 0;<br>
|
||||
<font color="#666666">{$omp parallel sections}<br>
|
||||
</font><b>begin</b><br>
|
||||
<font color="#666666"> {$omp critical}<br>
|
||||
</font> a:=1;<br>
|
||||
</font> a := 1;<br>
|
||||
<font color="#666666"> {$omp critical}<br>
|
||||
</font> a:=a+1;<br>
|
||||
</font> a := a+1;<br>
|
||||
<b>end</b>;</code></p>
|
||||
</blockquote>
|
||||
<p>Значение переменной a зависит от того, в каком порядке выполнятся секции.
|
||||
|
|
|
|||
|
|
@ -39,12 +39,12 @@
|
|||
<p>Рекомендуется использовать вторую форму условной операции.</p>
|
||||
<p><strong>Ограничение</strong>. Вторую форму условной операции нельзя
|
||||
использовать в качестве выражения верхнего уровня в лямбдах. Следующий код
|
||||
ошибочен:</p>
|
||||
<strong><em>ошибочен</em></strong>:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> l: real -> real := x -> <strong>if</strong> x<0 <strong>
|
||||
then</strong> 0 <strong>else</strong> x;</code></p>
|
||||
</blockquote>
|
||||
<p>Для решения указанной проблемы можно взять условную операцию в скобки:</p>
|
||||
<p>Для решения указанной проблемы нужно <em><strong>взять условную операцию в скобки</strong></em>:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> l: real -> real := x -> (<strong>if</strong> x<0 <strong>
|
||||
then</strong> 0 <strong>else</strong> x);</code></p>
|
||||
|
|
|
|||
|
|
@ -6,13 +6,6 @@
|
|||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1251">
|
||||
<title></title>
|
||||
<link rel="StyleSheet" href="../../default.css">
|
||||
<style type="text/css">
|
||||
.auto-style1 {
|
||||
font-family: monospace;
|
||||
font-size: 10pt;
|
||||
color: #000080;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body><H1>Срезы</H1>
|
||||
<p>Срез - это набор элементов динамического массива, списка List<T> или строки,
|
||||
|
|
@ -34,28 +27,27 @@
|
|||
<code>a?[from:to:step]</code>
|
||||
</blockquote>
|
||||
<p>и содержит копию элементов исходного контейнера в диапазоне [<code>from</code>,
|
||||
<span class="auto-style1">to</span>) с
|
||||
шагом <span class="auto-style1">step</span>. Запись [<span class="auto-style1">from</span>,
|
||||
<span class="auto-style1">to</span>) означает, что элемент с индексом
|
||||
<span class="auto-style1">from</span> включается в
|
||||
диапазон, а элемент с индексом <span class="auto-style1">to</span> - не включается.
|
||||
<code>to</code>) с
|
||||
шагом <code>step</code>. Запись [<code>from</code>,
|
||||
<code>to</code>) означает, что элемент с индексом
|
||||
<code>from</code> включается в
|
||||
диапазон, а элемент с индексом <code>to</code> - не включается.
|
||||
Значения <code>from</code>,
|
||||
<span class="auto-style1">to</span>, <span class="auto-style1">step</span>
|
||||
<code>to</code>, <code>step</code>
|
||||
должны быть целыми.</p>
|
||||
<p>Если <span class="auto-style1">step</span> не указывается, то предполагается, что
|
||||
<span class="auto-style1">step</span>=1, т.е. элементы
|
||||
<p>Если <code>step</code> не указывается, то предполагается, что
|
||||
<code>step</code>=1, т.е. элементы
|
||||
расположены непрерывно.</p>
|
||||
<p>Тип среза совпадает с типом контейнера: срез элементов массива представляет
|
||||
собой массив, срез строки - строку и срез для List<T> также принадлежит к типу
|
||||
List<T>.</p>
|
||||
<p>Для обычных срезов исключение генерируется в следующих случаях. Если индекс <span class="auto-style1">from</span> выходит за границы, то во
|
||||
<p>Для обычных срезов исключение генерируется в следующих случаях. Если индекс <code>from</code> выходит за границы, то во
|
||||
время выполнения программы возникает исключение. Индекс
|
||||
<span class="auto-style1">to</span> может выходить за границы на 1, т.е.
|
||||
<code>to</code> может выходить за границы на 1, т.е.
|
||||
находиться в диапазоне [-1..a.Count] для динамических массивов и списков List<T>
|
||||
и в диапазоне [0..s.Length+1] для строк, в противном случае также возникает
|
||||
исключение. </p>
|
||||
<p>Если <span class="auto-style1">
|
||||
step</span>=0, то для всех видов срезов генерируется исключение.</p>
|
||||
<p>Если <code>step</code>=0, то для всех видов срезов генерируется исключение.</p>
|
||||
<p>Срезы вида
|
||||
<code>a?</code>
|
||||
называются <i>безопасными срезами</i> и во всех остальных случаях не генерируют
|
||||
|
|
@ -65,30 +57,29 @@ step</span>=0, то для всех видов срезов генерирует
|
|||
контейнеру.</p>
|
||||
<p>Приведём ряд примеров:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> a := Arr(0,1,2,3,4,5,6);<br>Println(a[2:5]); // [2,3,4]<br>
|
||||
<p><code><b>var</b> a array of integer := [0,1,2,3,4,5,6];<br>Println(a[2:5]); // [2,3,4]<br>
|
||||
Println(a[2:a.Length]); // [2,3,4,5,6]<br>Println(a[2:1000]); // Исключение!<br>Println(a?[2:1000]);
|
||||
// [2,3,4,5,6]<br>Println(a[2:7:2]); // [2,4,6]<br>
|
||||
Println(a[2:0]); // пустой массив<br><b>var</b> s := '0123456';<br>
|
||||
Println(s[2:5]); // 123<br>Println(s[0:2]); // Исключение!<br>Println(s?[0:2]);
|
||||
// 12<br>Println(s?[-2::2]); // 135<br>Println(s[2:s.Length]); // 12345</code></p>
|
||||
</blockquote>
|
||||
<p>Шаг <span class="auto-style1">step</span> может быть отрицательным. Например:</p>
|
||||
<p>Шаг <code>step</code> может быть отрицательным. Например:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> a := Arr(0,1,2,3,4,5,6);<br>Println(a[5:2:-1]); //
|
||||
[5,4,3]<br>Println(a[2:5:-1]); // пустой массив<br>
|
||||
Println(a[a.Length-1:-1:-2]); // [6,4,2,0]</code></p>
|
||||
</blockquote>
|
||||
<p>В записи среза выражение <span class="auto-style1">from</span> или выражение
|
||||
<span class="auto-style1">to</span> могут быть пропущены, в этом случае в срез
|
||||
попадают все элементы с соответствующей стороны. Если <span class="auto-style1">
|
||||
step</span>>0, то пропущенный <span class="auto-style1">from</span> полагается
|
||||
равным индексу первого элемента, пропущенный <span class="auto-style1">to</span>
|
||||
<p>В записи среза выражение <code>from</code> или выражение
|
||||
<code>to</code> могут быть пропущены, в этом случае в срез
|
||||
попадают все элементы с соответствующей стороны. Если <code>
|
||||
step</code>>0, то пропущенный <code>from</code> полагается
|
||||
равным индексу первого элемента, пропущенный <code>to</code>
|
||||
полагается равным индексу последнего элемента + 1. Если
|
||||
<span class="auto-style1">step</span><0, то пропущенный
|
||||
<span class="auto-style1">from</span> полагается равным индексу последнего
|
||||
элемента, а пропущенный <span class="auto-style1">to</span> - индексу первого
|
||||
элемента - 1. </p>
|
||||
<p>Например:</p>
|
||||
<code>step</code><0, то пропущенный
|
||||
<code>from</code> полагается равным индексу последнего
|
||||
элемента, а пропущенный <code>to</code> - индексу первого
|
||||
элемента - 1. </p><p>Например:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> s := '0123456';<br>Println(s[2:]); // 23456<br>
|
||||
Println(s[:4]); // 012<br>Println(s[::-1]); // 6543210</code></p>
|
||||
|
|
|
|||
|
|
@ -59,30 +59,25 @@ b=1</code>, то <code>b <b>shl</b> 10=1024</code>, а <code><b>not</b> b=254</c
|
|||
операции <code>+</code> (объединение), <code>-</code>
|
||||
(разность) и <code>*</code> (пересечение):</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> <br>
|
||||
s1,s2,s: <b>set</b> <b>of</b> byte;<br>
|
||||
<b>begin<br>
|
||||
</b> s1:=[1..4];<br>
|
||||
s2:=[2..5];<br>
|
||||
s:=s1+s2; // s=[1..5]<br>
|
||||
s:=s1-s2; // s=[1]<br>
|
||||
s:=s1*s2; // s=[2..4] </code></p>
|
||||
<p><code><b>var</b> s1,s2,s: <b>set</b> <b>of</b> byte;<br>
|
||||
s1 := [1..4];<br>
|
||||
s2 := [2..5];<br>
|
||||
s := s1 + s2; // s = [1..5]<br>
|
||||
s := s1 - s2; // s = [1]<br>
|
||||
s := s1 * s2; // s = [2..4] </code></p>
|
||||
</blockquote>
|
||||
<p>К множествам применимы также операции отношения = (равенство), <code><></code>
|
||||
(неравенство), <= (вложено) и
|
||||
>= (содержит):</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> <br>
|
||||
s1,s2,s: <b>set</b> <b>of</b> byte;<br>
|
||||
b: boolean;<br>
|
||||
<b>begin<br>
|
||||
</b> s1:=[1..4];<br>
|
||||
s2:=[2..5];<br>
|
||||
s:=[1,2]; <br>
|
||||
b:=s1=s2; // b=False<br>
|
||||
b:=s2<>s; // b=True<br>
|
||||
b:=s<=s2; // b=False<br>
|
||||
b:=s1>=s; // b=True</code></p>
|
||||
<p><code><b>var</b> s1,s2,s: <b>set</b> <b>of</b> byte;<br>
|
||||
s1 := [1..4];<br>
|
||||
s2 := [2..5];<br>
|
||||
s := [1,2]; <br>
|
||||
<strong>var </strong>b := s1=s2; // b = False<br>
|
||||
b := s2 <> s; // b = True<br>
|
||||
b := s <= s2; // b = False<br>
|
||||
b := s1 >= s; // b = True</code></p>
|
||||
</blockquote>
|
||||
<p>Наконец, операция <code><b>in</b></code>
|
||||
определяет, принадлежит ли элемент множеству:</p>
|
||||
|
|
@ -113,17 +108,17 @@ b=1</code>, то <code>b <b>shl</b> 10=1024</code>, а <code><b>not</b> b=254</c
|
|||
Первыми выполняются операции, имеющие высший приоритет. Операции, имеющие
|
||||
одинаковый приоритет, выполняются слева направо.</p>
|
||||
<p><b>Таблица приоритетов операций</b></p>
|
||||
<table border="0" width="444" id="table1">
|
||||
<table border="0" width="544" id="table1">
|
||||
<tr>
|
||||
<td><code>@</code>,
|
||||
<b><code>not</code></b>,
|
||||
<code>^</code>, <code>+</code>, <code>-</code> (унарные), <code>new</code>
|
||||
</td>
|
||||
<td>1 (наивысший)</td>
|
||||
<td style="width: 173px">1 (наивысший)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>**</code></td>
|
||||
<td style="width: 142px">2</td>
|
||||
<td style="width: 173px">2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>*</code>,
|
||||
|
|
@ -135,18 +130,18 @@ b=1</code>, то <code>b <b>shl</b> 10=1024</code>, а <code><b>not</b> b=254</c
|
|||
<code><b>shr</b></code>,
|
||||
<code><b>as</b></code>,
|
||||
<code><b>is</b></code></td>
|
||||
<td>3</td>
|
||||
<td style="width: 173px">3</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>+</code>,
|
||||
<code>-</code> (бинарные),
|
||||
<code><b>or</b></code>,
|
||||
<code><b>xor</b></code> </td>
|
||||
<td>4</td>
|
||||
<td style="width: 173px">4</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>..</code></td>
|
||||
<td>5</td>
|
||||
<td style="width: 173px">5</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>=</code>,
|
||||
|
|
@ -156,11 +151,11 @@ b=1</code>, то <code>b <b>shl</b> 10=1024</code>, а <code><b>not</b> b=254</c
|
|||
<code><=</code>,
|
||||
<code>>=</code>,
|
||||
<code><b>in</b></code></td>
|
||||
<td>6</td>
|
||||
<td style="width: 173px">6</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>?: </code> </td>
|
||||
<td>7 (низший)</td>
|
||||
<td style="width: 173px">7 (низший)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
|
|
|
|||
|
|
@ -49,9 +49,9 @@ Base</code> возвращают <code>True</code>,
|
|||
<p><code><b>var</b> b: Base;</code></p>
|
||||
<p><code><b>begin</b><br>
|
||||
b := new Base;<br>
|
||||
writeln(b <b>i</b><b>s</b> Derived);<br>
|
||||
Println(b <b>i</b><b>s</b> Derived);<br>
|
||||
b := new Derived;<br>
|
||||
writeln(b <b>i</b><b>s</b> Derived);<br>
|
||||
Println(b <b>i</b><b>s</b> Derived);<br>
|
||||
<b>end</b>. </code></p>
|
||||
</blockquote>
|
||||
<p>первый раз выводится <code>False</code>,
|
||||
|
|
|
|||
|
|
@ -12,18 +12,18 @@
|
|||
<p><b>Таблица приоритетов операций</b></p>
|
||||
<table border="0" width="444" id="table1">
|
||||
<tr>
|
||||
<td style="width: 320px"><code>**</code></td>
|
||||
<td style="width: 360px"><code>**</code></td>
|
||||
<td width="120">1 (наивысший)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="width: 320px"><code>@</code>,
|
||||
<td style="width: 360px"><code>@</code>,
|
||||
<b><code>not</code></b>,
|
||||
<code>^</code>, <code>+</code>, <code>-</code> (унарные), <code>new</code>
|
||||
</td>
|
||||
<td width="120">2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="width: 320px"><code>*</code>,
|
||||
<td style="width: 360px"><code>*</code>,
|
||||
<code>/</code>,
|
||||
<code><b>div</b></code>,
|
||||
<code><b>mod</b></code>,
|
||||
|
|
@ -35,18 +35,18 @@
|
|||
<td width="120">3</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="width: 320px"><code>+</code>,
|
||||
<td style="width: 360px"><code>+</code>,
|
||||
<code>-</code> (бинарные),
|
||||
<code><b>or</b></code>,
|
||||
<code><b>xor</b></code> </td>
|
||||
<td width="120">4</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="width: 320px"><code>..</code></td>
|
||||
<td style="width: 360px"><code>..</code></td>
|
||||
<td width="120">5</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="width: 320px"><code>=</code>,
|
||||
<td style="width: 360px"><code>=</code>,
|
||||
<code><></code>,
|
||||
<code><</code>,
|
||||
<code>></code>,
|
||||
|
|
@ -56,7 +56,7 @@
|
|||
<td width="120">6</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="width: 320px"><code>?: </code> </td>
|
||||
<td style="width: 360px"><code>?: </code> </td>
|
||||
<td width="120">7 (низший)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
|
|
|||
|
|
@ -17,12 +17,11 @@
|
|||
<body><H1>Строковые операции</H1>
|
||||
<p>К <a href="../Types/string.html">строкам</a> применимы все <a href="relop.html">операции сравнения</a> <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>, <code>=</code>, <code><></code>.
|
||||
Сравнение строк на неравенство осуществляется <strong>
|
||||
лексикографически</strong>: <span class="auto-style2">s1 < s2</span> если для
|
||||
первого несовпадающего символа с номером i <span class="auto-style2">s1[i]<s2[i]</span>
|
||||
или все символы строк совпадают, но <span class="auto-style2">s1</span> короче
|
||||
<span class="auto-style2">s2</span>.
|
||||
</p>
|
||||
<p>Кроме этого, к строкам и символам применима операция
|
||||
лексикографически</strong>: <code>s1 < s2</code> если для
|
||||
первого несовпадающего символа с номером i <code>s1[i]<s2[i]</code>
|
||||
или все символы строк совпадают, но <code>s1</code> короче
|
||||
<code>s2</code>.
|
||||
</p><p>Кроме этого, к строкам и символам применима операция
|
||||
конкатенации (слияния) <code>+</code>, ее результат имеет строковый тип.
|
||||
</p>
|
||||
<p>Например, <code>'a'+'b'='ab'</code>. </p>
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
Derived = <b>class</b>(Base) ... <b>end</b>;</code></p>
|
||||
<p><code><b>var</b> b: Base := new Derived;</code></p>
|
||||
<p><code><b>begin</b><br>
|
||||
writeln(b.GetType = <b>typeof</b>(Derived)); <br>
|
||||
Println(b.GetType = <b>typeof</b>(Derived)); <br>
|
||||
<b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
|
||||
|
|
|
|||
|
|
@ -49,10 +49,9 @@
|
|||
<code><b>begin<br>
|
||||
</b>
|
||||
<b> var</b> a,b: integer;<br>
|
||||
<b>var</b> r: real;<br>
|
||||
readln(a,b);<br>
|
||||
x := a/b;<br>
|
||||
writeln(x);<br>
|
||||
(a,b) := ReadInteger2;<br>
|
||||
<strong>var </strong>x: real := a/b;<br>
|
||||
Println(x);<br>
|
||||
<b>end.</b></code></blockquote>
|
||||
</body>
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ exit</H1>
|
|||
<p><code>flag := False;<br>
|
||||
<b>for</b> <b>var</b> i:=1 <b>to</b> 10 <b>do</b><br>
|
||||
<b>begin</b><br>
|
||||
read(x);<br>
|
||||
<strong>var</strong> x := ReadInteger;<br>
|
||||
<b>if</b> x<0 <b>then</b> <b>continue</b>; //
|
||||
пропуск текущей итерации цикла<br>
|
||||
<b>if</b> x=5 <b>then</b><br>
|
||||
|
|
@ -51,6 +51,17 @@ exit</H1>
|
|||
</blockquote>
|
||||
<p>Вызов <code><b>exit</b></code> в разделе операторов
|
||||
основной программы приводит к ее немедленному завершению.</p>
|
||||
<p>Оператор <code><b>exit</b></code> внутри функции может быть вызван с
|
||||
параметром для немедленного возврата значения из функции:</p>
|
||||
<blockquote>
|
||||
<p><code><b>function</b> Analyze(x: integer): boolean;<br>
|
||||
<b>begin</b><br>
|
||||
<b>if</b> x<0 <b>then</b> <br>
|
||||
<b>exit</b>(False)<br>
|
||||
...<br>
|
||||
<b>end</b>;</code></p>
|
||||
</blockquote>
|
||||
|
||||
<p>Более точно, <code><b>break</b></code>, <code><b>continue</b></code>
|
||||
и <code><b>exit</b></code> в <b>
|
||||
PascalABC.NET</b> являются операторами вызова специальных внутренних процедур.</p>
|
||||
|
|
|
|||
|
|
@ -84,13 +84,13 @@
|
|||
<br> Возвращает последовательность из указанных элементов</td></tr>
|
||||
<tr><td><code><b>function</b> SeqFill<T>(count: integer; x: T): <b>sequence </b> <b>of</b> T;</code>
|
||||
<br> Возвращает последовательность из count элементов x</td></tr>
|
||||
<tr><td><code><b>function</b> SeqGen<T>(count: integer; f: integer->T): <b>sequence </b> <b>of</b> T;</code>
|
||||
<tr><td><code><b>function</b> SeqGen<T>(count: integer; f: integer > T): <b>sequence </b> <b>of</b> T;</code>
|
||||
<br> Возвращает последовательность из count элементов, заполненных значениями f(i)</td></tr>
|
||||
<tr><td><code><b>function</b> SeqGen<T>(count: integer; f: integer->T; from: integer): <b>sequence </b> <b>of</b> T;</code>
|
||||
<br> Возвращает последовательность из count элементов, заполненных значениями f(i), начиная с i=from</td></tr>
|
||||
<tr><td><code><b>function</b> SeqGen<T>(count: integer; first: T; next: T->T): <b>sequence </b> <b>of</b> T;</code>
|
||||
<br> Возвращает последовательность из count элементов, начинающуюся с first, с функцией next перехода от предыдущего к следующему</td></tr>
|
||||
<tr><td><code><b>function</b> SeqGen<T>(count: integer; first, second: T; next: (T,T) ->T): <b>sequence </b> <b>of</b> T;</code>
|
||||
<tr><td><code><b>function</b> SeqGen<T>(count: integer; first, second: T; next: (T,T) > T): <b>sequence </b> <b>of</b> T;</code>
|
||||
<br> Возвращает последовательность из count элементов, начинающуюся с first и second,с функцией next перехода от двух предыдущих к следующему</td></tr>
|
||||
<tr><td><code><b>function</b> SeqRandom(n: integer := 10; a: integer := 0; b: integer := 100): <b>sequence </b> <b>of</b> integer;</code>
|
||||
<br> Возвращает последовательность из n случайных целых элементов</td></tr>
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
<p><code><b>procedure</b> PrintTwo(a,b: integer; delim: char
|
||||
:= ' ');<br>
|
||||
<b>begin</b><br>
|
||||
write(a,delim,b);<br>
|
||||
Write(a,delim,b);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code>...<br>
|
||||
PrintTwo(3,5);<br>
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@
|
|||
<b>procedure</b> A(i: integer);
|
||||
<b>begin</b>
|
||||
...
|
||||
B(i-1);
|
||||
B(i - 1);
|
||||
<b>end</b>;<b>
|
||||
procedure</b> B(i: integer);
|
||||
<b>begin</b>
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
<b>var </b>i: integer;
|
||||
<b>begin</b>
|
||||
// к глобальной переменной i внутри процедуры нельзя обратиться
|
||||
i:=5; // присваивание локальной переменной i; ...
|
||||
i := 5; // присваивание локальной переменной i; ...
|
||||
<b>end</b>;</code>
|
||||
</pre>
|
||||
</blockquote>
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@
|
|||
<p><code><b>uses</b> un2,un1;</code></p>
|
||||
<p><code><b>procedure</b> p(i: integer);<br>
|
||||
<b>begin</b><br>
|
||||
write(1);<br>
|
||||
Print(1);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>begin</b><br>
|
||||
p(2.2);<br>
|
||||
|
|
@ -95,7 +95,7 @@
|
|||
<p><code><b>unit</b> un2;</code></p>
|
||||
<p><code><b>procedure</b> p(r: real);<br>
|
||||
<b>begin</b><br>
|
||||
write(3);<br>
|
||||
Print(3);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
|
|
@ -104,7 +104,7 @@
|
|||
<p><code><b>unit</b> un1;</code></p>
|
||||
<p><code><b>procedure</b> p(r: real);<br>
|
||||
<b>begin</b><br>
|
||||
write(2);<br>
|
||||
Print(2);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>end</b>.</code></p>
|
||||
</blockquote>
|
||||
|
|
@ -126,12 +126,12 @@
|
|||
<blockquote>
|
||||
<p><code><b>procedure</b> p(i: integer);<br>
|
||||
<b>begin</b><br>
|
||||
write(1);<br>
|
||||
Print(1);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>procedure</b> p(<b>params</b> a: <b>array</b> <b>of</b>
|
||||
integer);<br>
|
||||
<b>begin</b><br>
|
||||
write(2);<br>
|
||||
Print(2);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>begin</b><br>
|
||||
p(1) <br>
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@
|
|||
<blockquote>
|
||||
<code><b>procedure</b> PrintSquare(i: integer);<br>
|
||||
<b>begin</b><br>
|
||||
writeln(i*i);<br>
|
||||
Println(i*i);<br>
|
||||
<b>end</b>;</code></blockquote>
|
||||
Тогда при вызове <code>PrintSquare(5*a-b)</code> значение <code>5*a-b</code> будет вычислено и присвоено переменной <code>i</code>, после чего
|
||||
выполнится тело процедуры.<p class="pabcmain">Если параметр передается по ссылке, то при вызове
|
||||
|
|
@ -72,9 +72,9 @@
|
|||
</b> Person = <b>record</b><br>
|
||||
name: string;<br>
|
||||
age,height,weight: integer;<br>
|
||||
<b>end</b>;</code><p><code><b>procedure</b> Print(<b>const</b> p: Person);<br>
|
||||
<b>end</b>;</code><p><code><b>procedure</b> PrintPupil(<b>const</b> p: Person);<br>
|
||||
<b>begin<br>
|
||||
</b> write(p.name,' ',p.age,' ',p.height,' ',p.weight);<br>
|
||||
</b> Print(p.name,p.age,p.height,p.weight);<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p><code><b>procedure</b> IncAge(<b>var</b> p: Person);<br>
|
||||
<b>begin</b><br>
|
||||
|
|
|
|||
|
|
@ -12,6 +12,13 @@
|
|||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1251">
|
||||
<title></title>
|
||||
<link rel="StyleSheet" href="../../default.css">
|
||||
<style type="text/css">
|
||||
.auto-style1 {
|
||||
font-family: Consolas, monospace;
|
||||
font-size: 12pt;
|
||||
color: #000080;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
|
|
@ -112,11 +119,35 @@
|
|||
<br>
|
||||
Result := x;<br>
|
||||
<b>end</b>;</code></p>
|
||||
<p ><code><strong>begin</strong><br> var a := Seq(1,5,3);<br>
|
||||
writeln(MinElement(a) + Sum(2,3));<br><strong>end</strong>.</code></p>
|
||||
<p ><code><strong>begin</strong><br> <strong>var</strong> a := [1,5,3];<br>
|
||||
Println(MinElement(a) + Sum(2,3));<br><strong>end</strong>.</code></p>
|
||||
</blockquote>
|
||||
<p >Если внутри функции не присвоить переменной <code>Result</code> некоторое
|
||||
значение, то функция вернет в результате своего вызова непредсказуемое значение.</p>
|
||||
<p >Вместо присваивания Result в теле функции можно вызвать оператор exit с
|
||||
параметром - это приведет к немедленному выходу из функции и возврату значения:</p>
|
||||
<blockquote>
|
||||
<p ><code><b>function</b> Find<T>(a: <b>
|
||||
array of</b> T; x: T): boolean;<br>
|
||||
<b>begin</b><br>
|
||||
<b>foreach</b> <strong>var </strong>y <b>in</b>
|
||||
a <b>do</b><br>
|
||||
<b>if</b> y = x <b>then</b>
|
||||
<br>
|
||||
<strong>exit</strong>(True);<br> Result :=
|
||||
False;<br>
|
||||
<b>end</b>;</code></p>
|
||||
</blockquote>
|
||||
<p >Функция может возвращать кортеж значений:</p>
|
||||
<blockquote>
|
||||
<p ><code><b>function</b> DivMod(a,b: integer): (integer,integer);<br><strong>
|
||||
begin</strong><br> Result := (a <strong>div </strong>b, a <strong>mod</strong>
|
||||
b);<br><strong>e</strong></code><span class="auto-style1"><strong>nd</strong>;</span></p>
|
||||
</blockquote>
|
||||
<p >При вызове такой функции ее результат обычно распаковывается в переменные</p>
|
||||
<blockquote>
|
||||
<p ><code><strong>var</strong> (a,b) := DivMod(7,2);</code></p>
|
||||
</blockquote>
|
||||
<h2 >Упрощенный синтаксис описания подпрограмм</h2>
|
||||
<p >В <span lang="en-us">PascalABC.NET </span>имеется упрощенный синтаксис
|
||||
описания однооператорных процедур: </p>
|
||||
|
|
@ -129,7 +160,9 @@
|
|||
</blockquote>
|
||||
<p >При этом в ряде случаев для возвращаемого значения функции возможен автовывод типов:</p>
|
||||
<blockquote>
|
||||
<p ><code><b>function</b> Add(a,b: real)<span lang="en-us"> := </span>a + b;</code></p>
|
||||
<p ><code><b>function</b> Add(a,b: real)<span lang="en-us"> := </span>a + b;<br><b>function</b>
|
||||
DivMod(a,b: integer) := (a <strong>div</strong> b, a <strong>mod</strong>
|
||||
b);</code></p>
|
||||
</blockquote>
|
||||
</body>
|
||||
|
||||
|
|
|
|||
|
|
@ -45,13 +45,13 @@
|
|||
<p>Данный способ хорош тем, что позволяет совместить описание массива и
|
||||
выделение под него памяти:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> <br> a: <b>array of</b> integer := new integer[5];<br>
|
||||
b: <b>array</b> [,] <b>of</b> real := new real[4,3]; </code></p>
|
||||
<p><code><b>var</b> a: <b>array of</b> integer := new integer[5];<br>
|
||||
<b>var</b> b: <b>array</b> [,] <b>of</b> real := new real[4,3]; </code></p>
|
||||
</blockquote>
|
||||
<p>Описание типа можно при этом опускать - тип автовыводится:</p>
|
||||
<blockquote>
|
||||
<p><code><b>var</b> <br> a := new integer[5];<br>
|
||||
b := new real[4,3]; </code></p>
|
||||
<p><code><b>var</b> a := new integer[5];<br>
|
||||
<b>var</b> b := new real[4,3]; </code></p>
|
||||
</blockquote>
|
||||
<p>Второй способ выделения памяти под динамический массив использует стандартную процедуру <code>SetLength</code>: </p>
|
||||
<blockquote>
|
||||
|
|
@ -62,6 +62,15 @@
|
|||
<p>Процедура <code>SetLength</code> обладает тем преимуществом, что при ее
|
||||
повторном вызове старое содержимое массива сохраняется.</p>
|
||||
<h2>Инициализация динамического массива</h2>
|
||||
<p>Проще всего инициализировать динамический массив, используя инициализатор []
|
||||
- при этом выделяется память:</p>
|
||||
<blockquote>
|
||||
<p><code><strong>var</strong> a := [1,3,5,7,9];</code></p>
|
||||
</blockquote>
|
||||
<p>Инициализатор при использовании различных типов выбирает самый общий тип:</p>
|
||||
<blockquote>
|
||||
<p><code>[1,3.4,5]; // array of real<br>['a','','fgh'] // array of string</code></p>
|
||||
</blockquote>
|
||||
<p>Можно инициализировать динамический массив при выделении под него память
|
||||
операцией new:</p>
|
||||
<blockquote>
|
||||
|
|
@ -81,7 +90,7 @@
|
|||
<p>При этом происходит выделение памяти под указанное справа количество
|
||||
элементов. </p>
|
||||
<p>Инициализация одномерного массива проще всего осуществляется стандартными
|
||||
функциями Seq..., которые выделяют память нужного размера и заполняют массив
|
||||
функциями Arr..., которые выделяют память нужного размера и заполняют массив
|
||||
указанными значениями:</p>
|
||||
<blockquote>
|
||||
<p><code><strong>var</strong> a := Arr(1,3,5,7,8);
|
||||
|
|
@ -115,21 +124,21 @@
|
|||
<p>После выделения памяти ввод динамического массива можно осуществлять
|
||||
традиционно в цикле:</p>
|
||||
<blockquote><code><strong>for var</strong> i:=0 <strong>to</strong> a.Length-1
|
||||
<strong>do</strong><br> read(a[i]);</code></blockquote>
|
||||
<strong>do</strong><br> Read(a[i]);</code></blockquote>
|
||||
<p>Ввод динамического массива можно осуществлять
|
||||
с помощью стандартной функции ReadArrInteger:</p>
|
||||
<blockquote><code><strong>var</strong> a := ReadArrInteger(10);</code></blockquote>
|
||||
<p>При этом под динамический массив выделяется память нужного размера.</p>
|
||||
<h2>Вывод динамического массива</h2>
|
||||
<p>Процедура write выводит динамический массив, заключая элементы в квадратные
|
||||
<p>Процедура Write выводит динамический массив, заключая элементы в квадратные
|
||||
скобки и разделяя их запятыми:</p>
|
||||
<blockquote><code><strong>var </strong> a := Arr(1,3,5,7,9);<strong><br></strong>
|
||||
writeln(a); // [1,3,5,7,9] </code> <span class="auto-style2"><font size="2">
|
||||
<blockquote><code><strong>var </strong> a := Arr(1,3,5,7,9);<strong><br></strong>
|
||||
Writeln(a); // [1,3,5,7,9] </code> <span class="auto-style2"><font size="2">
|
||||
</font></span></blockquote>
|
||||
<p>n-мерный динамический массив выводится так, что каждая размерность
|
||||
заключается в квадратные скобки:.</p>
|
||||
<blockquote><code><strong>var </strong> m := new integer[3,3]
|
||||
((1,2,3),(4,5,6),(7,8,9));<strong><br></strong>writeln(m); //
|
||||
((1,2,3),(4,5,6),(7,8,9));<strong><br></strong>Writeln(m); //
|
||||
[[1,2,3],[4,5,6],[7,8,9]] </code></blockquote>
|
||||
<p>Динамический массив можно выводить также методом расширения Print или
|
||||
Println:</p>
|
||||
|
|
|
|||
|
|
@ -57,14 +57,21 @@
|
|||
bs: ByteSet := [1,3,5,20..25];<br>
|
||||
fios: StringSet := ['Иванов','Петров','Сидорова'];</code></p>
|
||||
</blockquote>
|
||||
<p>Начиная с версии PascalABC.NET 3.10, при создании множества с помощью [] надо
|
||||
обязательно указывать тип переменной. Если этого не сделать , то по умолчанию
|
||||
типом конструкции в [] будет массив:</p>
|
||||
<blockquote>
|
||||
<p><code><strong>var </strong>s: set of integer := [1,2,3];<br><strong>var</strong>
|
||||
a := [1,2,3]; // array of integer</code></p>
|
||||
</blockquote>
|
||||
<p>Значения в списке могут отсутствовать, тогда множество является пустым:</p>
|
||||
<blockquote>
|
||||
<p><code>bs:=[];</code></p>
|
||||
</blockquote>
|
||||
<p>Пустое множество-константа <code>[]</code> совместимо по присваиванию с множеством любого типа.
|
||||
Однако тип пустого множества-константы не выводится автоматически: </p>
|
||||
<p>Константа <code>[]</code> совместима по присваиванию с множеством любого типа.
|
||||
Однако тип [] не выводится автоматически: </p>
|
||||
<blockquote>
|
||||
<p><code><strong>var</strong> bs:=[]; // Ошибка!</code></p>
|
||||
<p><code><strong>var</strong> s: <strong>set of</strong> integer := [];<strong><br>var</strong> bs:=[]; // Ошибка!</code></p>
|
||||
</blockquote>
|
||||
<p>Множество, задаваемое конструктором множества, может иметь элементы различных
|
||||
типов, например:</p>
|
||||
|
|
|
|||
|
|
@ -31,11 +31,11 @@
|
|||
Count = 10;<br>
|
||||
Name = 'Mike';<br>
|
||||
DigitsSet = ['0'..'9'];<br>
|
||||
Arr: <b>array</b> [1..5] <b>of</b> <b>integer</b> = (1,3,5,7,9);<br>
|
||||
Arr: <b>array</b> <b>of</b> <b>integer</b> = (1,3,5,7,9);<br>
|
||||
Rec: <b>record</b> name: <b>string</b>;
|
||||
age: integer <b>end</b> = (name: 'Иванов';
|
||||
age: 23);<br>
|
||||
Arr2: <b>array</b> [1..2,1..2] <b>of</b>
|
||||
Arr2: <b>array</b> <b>of</b>
|
||||
real = ((1,2),(3,4));</code></p>
|
||||
</blockquote>
|
||||
<p> </p>
|
||||
|
|
|
|||
|
|
@ -68,11 +68,10 @@ uses</strong></span>, каждая из которых
|
|||
<code><b>program</b> MyProgram;<br>
|
||||
<b>var</b> <br>
|
||||
a,b: integer;<br>
|
||||
x: real;<br>
|
||||
<b>begin<br>
|
||||
</b> readln(a,b);<br>
|
||||
x := a/b;<br>
|
||||
writeln(x);<br>
|
||||
</b> (a,b) := ReadInteger2;<br>
|
||||
<strong> var </strong>x := a/b;<br>
|
||||
Println(x);<br>
|
||||
<b>end</b>.</code></blockquote>
|
||||
<p>или</p>
|
||||
<blockquote>
|
||||
|
|
@ -81,6 +80,16 @@ uses</strong></span>, каждая из которых
|
|||
</b> <strong>var</strong> x := 100;<br> <strong>var</strong> y :=
|
||||
100;<br> <strong>var</strong> r := 50;<br> Circle(x,y,r);<br>
|
||||
<b>end</b>.</code></blockquote>
|
||||
<p>Глобальные описания переменных до begin основной программы в основном
|
||||
используются редко и считаются устаревшим стилем. Глобальные описания переменных
|
||||
могут использоваться в учебных программах, в которых несколько процедур
|
||||
используют эти переменные:</p>
|
||||
<blockquote>
|
||||
<code><b>uses</b> GraphWPF;<br><br><strong>var</strong> x: integer;<br><br>
|
||||
<strong>procedure</strong> Draw := Circle(x,300,5);<br><br>
|
||||
<b>begin<br>
|
||||
</b> x := 100;<br> Draw;<br>
|
||||
<b>end</b>.</code></blockquote>
|
||||
<p>Кроме того, имеется возможность записывать программы без внешнего begin-end.
|
||||
Для этого в начале программы используется префикc ##:</p>
|
||||
<blockquote>
|
||||
|
|
@ -91,16 +100,10 @@ uses</strong></span>, каждая из которых
|
|||
секцию uses и описывать процедуры и функции:</p>
|
||||
<blockquote>
|
||||
<code>
|
||||
<div class="language-pascal highlighter-rouge">
|
||||
<div class="highlight">
|
||||
<pre class="highlight"><span class="p">##
|
||||
<strong>uses</strong> GraphWPF;</span>
|
||||
<span class="k"><strong>function</strong></span> <span class="n">Draw</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">:</span> real<span class="p">)</span> <span class="p">:=</span> Circle(x,y,5)<span class="p">;</span>
|
||||
<span class="p">Draw(100,100);</span></pre>
|
||||
</div>
|
||||
</div>
|
||||
</code></blockquote>
|
||||
<p> </p>
|
||||
<span class="p">##<br>
|
||||
<strong>uses</strong> GraphWPF;</span><br>
|
||||
<span class="k"><strong>function</strong></span> <span class="n">Draw</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">:</span> real<span class="p">)</span> <span class="p">:=</span> Circle(x,y,5)<span class="p">;</span><br>
|
||||
<span class="p">Draw(100,100);</span></code></blockquote>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
|
|
|||
|
|
@ -39,10 +39,10 @@
|
|||
конструкции. Так, следующий код корректен: </p>
|
||||
<blockquote>
|
||||
<p><code><b>var </b>a: <b>array of</b> integer := (3,5,7);<b><br>
|
||||
for</b> i: integer := 1 <b>to</b> 9 <b>do</b> <br>
|
||||
write(a[i]); <br>
|
||||
<b>foreach</b> i: integer <b>in</b> a <b>do</b> <br>
|
||||
write(i);</code></p>
|
||||
for</b> <strong>var </strong>i := 1 <b>to</b> 9 <b>do</b> <br>
|
||||
Print(a[i]); <br>
|
||||
<b>foreach</b> <strong>var </strong>i <b>in</b> a <b>do</b> <br>
|
||||
Print(i);</code></p>
|
||||
</blockquote>
|
||||
<p>
|
||||
Идентификатор с тем же именем, определенный во вложенном пространстве имен, <i>скрывает</i>
|
||||
|
|
@ -75,14 +75,14 @@
|
|||
<a href="../Classes/inherited.html">inherited</a></code></b>:</p>
|
||||
<blockquote>
|
||||
<p><code><b>type</b><br>
|
||||
A=<b>class</b><br>
|
||||
A =<b> class</b><br>
|
||||
i: integer;<br>
|
||||
<b>procedure</b> p;<br>
|
||||
<b>begin</b><br>
|
||||
i := 5;<br>
|
||||
<b>end</b>;<br>
|
||||
<b>end</b>;<br>
|
||||
B=<b>class</b>(A)<br>
|
||||
B =<b> class</b>(A)<br>
|
||||
i: integer;<br>
|
||||
<b>procedure</b> p;<br>
|
||||
<b>begin</b><br>
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@
|
|||
<p>Распаковка кортежа в переменные часто используется при возвращении функцией
|
||||
кортежа:</p>
|
||||
<blockquote>
|
||||
<code><strong>function</strong> SP(a,b: real) := (a*b,2*(a+b)); </code> <br>
|
||||
<code><strong>function</strong> SP(a,b: real) := (a*b, 2*(a+b)); </code> <br>
|
||||
...<br>
|
||||
<code><strong>var</strong> (S,P) := SP(2,3); </code>
|
||||
</blockquote>
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -521,7 +521,15 @@ namespace Languages.Pascal.Frontend.Core
|
|||
}
|
||||
expr.source_context.begin_position.line_num = str.source_context.begin_position.line_num;
|
||||
expr.source_context.end_position.line_num = str.source_context.end_position.line_num;
|
||||
mc.parameters.Add(expr);
|
||||
|
||||
method_call applyO2S = new method_call();
|
||||
applyO2S.dereferencing_value = new ident("__ApplyO2S", expr.source_context);
|
||||
applyO2S.parameters = new expression_list();
|
||||
applyO2S.parameters.Add(expr);
|
||||
applyO2S.source_context = expr.source_context;
|
||||
|
||||
//mc.parameters.Add(expr);
|
||||
mc.parameters.Add(applyO2S); // добавляем обернутое выражение
|
||||
}
|
||||
|
||||
mc.source_context = str.source_context;
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
3.11.0.3693
|
||||
3.11.0.3699
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
!define VERSION '3.11.0.3693'
|
||||
!define VERSION '3.11.0.3699'
|
||||
|
|
|
|||
|
|
@ -72,6 +72,9 @@ const
|
|||
AllDelimiters = ' <>=^`|~$№§!"#%&''()*,+-./:;?@[\]_{}«·»'#9#10#13;
|
||||
//{{{--doc: Конец секции стандартных констант для документации }}}
|
||||
|
||||
// Внутренняя функция для интерполированных строк
|
||||
///--
|
||||
function __ApplyO2S(obj: object): object;
|
||||
|
||||
///--
|
||||
const
|
||||
|
|
@ -2437,6 +2440,7 @@ function CommandLineArgs: array of string;
|
|||
/// Преобразует объект в строковое представление
|
||||
function ObjectToString(obj: object): string;
|
||||
|
||||
|
||||
// -----------------------------------------------------
|
||||
//>> Подпрограммы для работы с динамическими массивами # Subroutines for array of T
|
||||
// -----------------------------------------------------
|
||||
|
|
@ -2561,14 +2565,14 @@ function SeqRandomInteger(n: integer := 10; a: integer := 0; b: integer := 100):
|
|||
/// Возвращает последовательность из n случайных вещественных элементов
|
||||
function SeqRandomReal(n: integer := 10; a: real := 0; b: real := 10; digits: integer := 1): sequence of real;
|
||||
/// Возвращает последовательность из count элементов, заполненных значениями f(i)
|
||||
function SeqGen<T>(count: integer; f: integer->T): sequence of T;
|
||||
function SeqGen<T>(count: integer; f: integer → T): sequence of T;
|
||||
/// Возвращает последовательность из count элементов, заполненных значениями f(i), начиная с i=from
|
||||
function SeqGen<T>(count: integer; f: integer->T; from: integer): sequence of T;
|
||||
/// Возвращает последовательность из count элементов, начинающуюся с first, с функцией next перехода от предыдущего к следующему
|
||||
function SeqGen<T>(count: integer; first: T; next: T->T): sequence of T;
|
||||
/// Возвращает последовательность из count элементов, начинающуюся с first и second,
|
||||
///с функцией next перехода от двух предыдущих к следующему
|
||||
function SeqGen<T>(count: integer; first, second: T; next: (T,T) ->T): sequence of T;
|
||||
function SeqGen<T>(count: integer; first, second: T; next: (T,T) → T): sequence of T;
|
||||
/// Возвращает последовательность элементов с начальным значением first,
|
||||
///функцией next перехода от предыдущего к следующему и условием pred продолжения последовательности
|
||||
function SeqWhile<T>(first: T; next: T->T; pred: T->boolean): sequence of T;
|
||||
|
|
@ -5067,6 +5071,13 @@ begin
|
|||
Result := res.ToString;
|
||||
end;
|
||||
|
||||
function __ApplyO2S(obj: object): object;
|
||||
begin
|
||||
if obj is System.IFormattable then
|
||||
Result := obj
|
||||
else Result := ObjectToString(obj);
|
||||
end;
|
||||
|
||||
function NumberFormat(DecimalSeparator: string; GroupSeparator: string): NumberFormatInfo;
|
||||
begin
|
||||
var nfi := new NumberFormatInfo;
|
||||
|
|
|
|||
|
|
@ -2,5 +2,5 @@
|
|||
|
||||
begin
|
||||
var s := $'{f1} {0}';
|
||||
assert(s = 'formatstring8.$delegate0 0');
|
||||
assert(s = 'function f1(b: byte): integer 0');
|
||||
end.
|
||||
|
|
@ -72,6 +72,9 @@ const
|
|||
AllDelimiters = ' <>=^`|~$№§!"#%&''()*,+-./:;?@[\]_{}«·»'#9#10#13;
|
||||
//{{{--doc: Конец секции стандартных констант для документации }}}
|
||||
|
||||
// Внутренняя функция для интерполированных строк
|
||||
///--
|
||||
function __ApplyO2S(obj: object): object;
|
||||
|
||||
///--
|
||||
const
|
||||
|
|
@ -2437,6 +2440,7 @@ function CommandLineArgs: array of string;
|
|||
/// Преобразует объект в строковое представление
|
||||
function ObjectToString(obj: object): string;
|
||||
|
||||
|
||||
// -----------------------------------------------------
|
||||
//>> Подпрограммы для работы с динамическими массивами # Subroutines for array of T
|
||||
// -----------------------------------------------------
|
||||
|
|
@ -2561,14 +2565,14 @@ function SeqRandomInteger(n: integer := 10; a: integer := 0; b: integer := 100):
|
|||
/// Возвращает последовательность из n случайных вещественных элементов
|
||||
function SeqRandomReal(n: integer := 10; a: real := 0; b: real := 10; digits: integer := 1): sequence of real;
|
||||
/// Возвращает последовательность из count элементов, заполненных значениями f(i)
|
||||
function SeqGen<T>(count: integer; f: integer->T): sequence of T;
|
||||
function SeqGen<T>(count: integer; f: integer → T): sequence of T;
|
||||
/// Возвращает последовательность из count элементов, заполненных значениями f(i), начиная с i=from
|
||||
function SeqGen<T>(count: integer; f: integer->T; from: integer): sequence of T;
|
||||
/// Возвращает последовательность из count элементов, начинающуюся с first, с функцией next перехода от предыдущего к следующему
|
||||
function SeqGen<T>(count: integer; first: T; next: T->T): sequence of T;
|
||||
/// Возвращает последовательность из count элементов, начинающуюся с first и second,
|
||||
///с функцией next перехода от двух предыдущих к следующему
|
||||
function SeqGen<T>(count: integer; first, second: T; next: (T,T) ->T): sequence of T;
|
||||
function SeqGen<T>(count: integer; first, second: T; next: (T,T) → T): sequence of T;
|
||||
/// Возвращает последовательность элементов с начальным значением first,
|
||||
///функцией next перехода от предыдущего к следующему и условием pred продолжения последовательности
|
||||
function SeqWhile<T>(first: T; next: T->T; pred: T->boolean): sequence of T;
|
||||
|
|
@ -5067,6 +5071,13 @@ begin
|
|||
Result := res.ToString;
|
||||
end;
|
||||
|
||||
function __ApplyO2S(obj: object): object;
|
||||
begin
|
||||
if obj is System.IFormattable then
|
||||
Result := obj
|
||||
else Result := ObjectToString(obj);
|
||||
end;
|
||||
|
||||
function NumberFormat(DecimalSeparator: string; GroupSeparator: string): NumberFormatInfo;
|
||||
begin
|
||||
var nfi := new NumberFormatInfo;
|
||||
|
|
|
|||
Binary file not shown.
Loading…
Reference in a new issue