Pascal abc net руководство

Редактировать

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

В большинстве случаев переменные описываются в блоке begin-end и описание совмещается с инициализацией:

begin
  var a := 5;
  var r := 3.14;
  var s := 'ABC';
end.

Это решает сразу несколько проблем:

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

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

begin
  var sum := 0;
  loop 10 do
    sum += ReadReal;
end.

Для исправления этой ошибки всё равно придётся говорить о типах и инициализировать sum одним из двух способов:

или

Цикл for var

Переменная — счётчик цикла for всегда должна описываться в заголовке цикла:

for var i:=1 to 9 do
  Print(i);
for var i:=21 to 29 do
  Print(i);

Это делает невозможным использование счётчика цикла вне цикла

Цикл loop

Если количество повторений цикла заранее известно, но неважен номер повторения, то используется цикл loop:

Множественное описание переменных с инициализацией

Можно инициализировать сразу несколько переменных в момент описания:

var (a,b) := (1,2);
var (Имя,Возраст) := ('Иванов',15);

Вывод

Для вывода вместо процедуры Write предпочтительно использовать процедуру Print. В отличие от Write она разделяет элементы вывода пробелами. Например:

begin
  var (a,b,c) := (1,2,3);
  Println(a,b,c);
  for var i:=1 to 9 do
    Print(i);
end.

Для вывода нескольких значений с пояснениями рекомендуется использовать интерполированные строки:

begin
  var (a,b) := ReadInteger2;
  Println($'Сумма {a} и {b} равна {a + b}');
end.

вместо режущего глаз

Writeln('Сумма ', a ' и ', b, ' равна ', a + b);

Ввод

Ввод принято осуществлять, используя функции вида ReadInteger, ReadReal и т.д.:

begin
  var a := ReadInteger;
end.

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

begin
  var a := ReadReal('Введите a: ');
  var (m,n,p) := ReadInteger3;
  var (x,y) := ReadReal2('Введите координаты точки: ');
end.

Для ввода с контролем ошибок используется функция TryRead. Она возвращает False если ввод осуществлён неверно (введено не число или число выходит за границы диапазона). Типичный пример её использования:

begin
  var i: integer;
  while not TryRead(i,'Введите i:') do
    Println('Повторите ввод!');
end.

Тип BigInteger

Для работы с длинными целыми используется тип BigInteger. Например, чтобы вычислить 100!, достаточно написать следующий код:

begin
  var p: BigInteger := 1;
  for var i := 2 to 100 do
    p *= i;
  Println(p);  
end.

Константу BigInteger можно также создать, используя суффикс bi — тогда предыдущий код изменится следующим образом:

begin
  var p := 1bi;
  for var i := 2 to 100 do
    p *= i;
  Println(p);  
end.

Некоторые полезные стандартные процедуры, функции и операции

Для обмена значений двух переменных a и b используйте стандартную функцию Swap(a,b):

begin
  var (a,b) := ReadReal2;
  Println(a,b);
  Swap(a,b);
  Println(a,b);
end.

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

begin
  var a,b := ReadReal2;
  Println(a,b);
  var t := a;
  a := b;
  b := t;
  Println(a,b);
end.

Но далее следует использовать Swap.

Минимальное и максимальное среди множества значений можно вычислить, используя стандартные функции Min и Max:

begin
  var a,b,c,d := ReadReal4;
  Println(Min(a,b),Max(c,d));
  Println(Min(a,b,c,d)); // произвольное количество значений
end.

Для возведения в степень используется операция **:

begin
  Println(2 ** 10);
  Println(2 ** 0.5);
end.

Возведение в целую степень оптимизировано и работает быстрее стандартной функции Power(a,n).

Для проверки принадлежности диапазону используется конструкция x in a..b:

begin
  var x := ReadInteger;
  if x in 10..99 then
    Print('Двузначное число');
end.

Эта операция эффективна и переводится в

begin
  var x := ReadInteger;
  if (x >= 10) and (x <= 99) then
    Print('Двузначное число');
end.

Диапазоны также можно использовать для вещественных значений и для символов:

r in 2.5..3.8
c in 'a'..'z'

Для проверки принадлежности множеству значений используется либо множество:

либо массив:

Мы рекомендуем второй способ — он существенно более эффективен по скорости и по памяти.

Условная операция

Если переменной необходимо присвоить значение в зависимости от условия, то вместо условного оператора иногда нагляднее использовать условную операцию:

begin
  var (a,b) := ReadInteger2;
  var min := if a<b then a else b;
  Print(min);
end.

Методы в стандартных типах

В PascalABC.NET внутри каждого типа имеется ряд полезных методов. В отличие от внешних процедур и функций, они “вшиты” в тип — переменная знает все свои методы и может вызывать их, используя точечную нотацию.

Например, чтобы вывести значение переменной базового типа, можно
использовать метод Print:

begin
  var i: integer := 5;
  i.Print;
end.

Из других интересных методов для начинающих для целых типов отметим:

i.IsEven - является ли i чётным
i.IsOdd - является ли i нечётным
i.InRange(a,b) - находится ли значение i между a и b (включительно)
i.Sqrt - квадратный корень

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

begin
  var count := 0;
  loop 10 do
  begin
    var x := ReadInteger;
    if i.IsEven and i.InRange(10,99) then // не требует написания скобок
      count += 1;
  end;
  count.Print
end.

Для вещественных значений полезными являются методы

r.Sqrt
r.Round
r.Trunc
r.InRange(a,b) - находится ли значение r между a и b (включительно)

В частности, удобно использовать цепочечную точечную нотацию:

begin
  var x := 17;
  var IsPrime := True;
  for var i:=2 to x.Sqrt.Round do
    if x mod i = 0 then
    begin
      IsPrime := False;
      break
    end;
  IsPrime.Print;
end.

Для всех числовых типов также определены константы MinValue и MaxValue. Чтобы обратиться к ним, следует использовать имя типа:

integer.MinValue
real.MaxValue

Кортежи

Кортежи представляют собой способ объединить несколько значений в одно целое. Значения типа Кортеж записываются в круглых скобках: (1,2,3) или ('Иванов',15). с помощью кортежей можно выполнять одновременные присваивания нескольким переменным:

begin
  var a,b: integer;
  (a,b) := (3,5);
  (a,b) := (b,a);
end.

Присваивание (a,b) := (b,a) позволяет поменять значения двух переменных.

Использование кортежей даже в начальных задачах крайне многообразно.

Пример 1. Нахождение наибольшего общего делителя

begin
  var (a,b) := ReadInteger2; 
  while b>0 do
    (a,b) := (b, a mod b);
  Print('НОД = ', a); 
end.

Пример 2. Числа Фибоначчи

begin
  var (a,b) := (1,1); 
  loop 20 do
  begin
    Print(a); 
    (a,b) := (b, a + b);
  end;
end.

1. Основы
2. Таблица типов
3. Справочные примеры PascalABC

Синтаксис программ[править]

Минимальная структура программы:

begin
  {main code here}
end.

Пример:

begin
  writeln('Hello world');
end.

Константы[править]

В данной секции располагаются определенные пользователем константы. Синтаксис объявления констант выглядит так:

const
  <имя> = <значение>;

Например:

const
  a = 12;
  s = 'ABC.NET';

Секция «var»[править]

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

Простейшие типы[править]

Тип строка[править]

Тип строка — это тип переменных, который позволяет хранить в переменной любой текст. Объявление строковой переменной:

Строки могут быть не более 255 символов. Изначальное значение строковых переменных — это «пустая строка» — ».

Тип целое число integer[править]

Кроме типа string в PascalABC.Net есть еще тип целое число — «integer». Само число a может принимать (в PascalABC.Net) значения от -32768 до 32767. Пример объявления переменной типа integer:

Тип вещественное число real[править]

Декларация переменной типа real:

Пример присваивания переменной данного типа:

a := 1.0; // Не 1,0!
a := 1; // Эквивалентно 1.0.

Тип символ[править]

Тип символ или «char» используется в основном для хранения одного любого символа вне зависимости от того, является ли данный символ буквой или цифрой. Объявление переменной символьного типа:

Секция «begin — end»[править]

Данный раздел программы содержит все команды, выполняемые при ее запуске. Данная секция программы выглядит так:

begin
 <команда_1>;
 ...
 <команда_n>;
end.

Комментарии[править]

Комментарий — это часть кода, которую игнорирует компилятор. Он создается следующим образом:

Или:

Массивы[править]

Массивы — это именованный список элементов одного типа.

P. S. Для работы с массивами существует учебный модуль Arrays.

Статические[править]

Статические массивы имеют фиксированный размер. Общий синтаксис объявления данных массивов выглядит так:

var
  <имя>: array [0..N - 1] of <тип>;

, где N — длина массива.

Пример:

const
  N = 5;

var
  A: array [0..N] of integer;
  K: integer;
  j: integer;
  Found: boolean;

begin
  Found := false;
  K := ReadInteger('K:');
  
  for var i := 0 to N - 1 do
  begin
    if not Found then
      Readln(A[i])
    else
      Readln(A[i + 1]);
    
    if not Found and (A[i] = K) then
    begin
      Found := true;
      j := i + 1;
    end;
  end;
  
  A[j] := A[N];
  
  for var i := 0 to N do
    WriteFormat('{0} ', A[i]);
end.

Посмотреть статью с примером.

Матрицы[править]

Двумерные[править]

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

var
  <имя>: array [0..N - 1, 0..M - 1] of <тип>;

, где N, M количество строчек и столбцов соответственно.

Трехмерные[править]

Трехмерный матрицы обладают третьим измерением:

var
  <имя>: array [0..N - 1, 0..M - 1, 0..K - 1] of <тип>;

N-мерные матрицы[править]

Декларация N-мерной матрицы:

var
  <имя>: array [0..A - 1, 0..B - 1, ..., 0..Z - 1] of <тип>;

, где A..Z означают количество элементов в соответствующем измерении.

Статические и динамические массивы[править]

Динамические массивы позволяют управлять количеством элементом в каждом из их измерений во время выполнения программы.

<имя>: array [0..N - 1] of <тип>

<имя>: array of <тип>

SetLength(<имя>, N)

<имя>: array [0..N - 1, 0..M - 1] of <тип>

<имя>: array [,] of <тип>

SetLength(<имя>, N, M)

<имя>: array [0..N - 1, 0..M - 1, 0..K - 1] of <тип>

<имя>: array [,,] of <тип>

SetLength(<имя>, N, M, K)

Понятие индекса массива[править]

Индекс массива — это номер элемента массива. Индекс может принимать значения [0, N — 1], где N — количество элементов некоторой размерности. Обращение к элементу одномерного массива с некоторым индексом:

Составим таблицу, которую следует запомнить:

<имя>[i]

A[1]

<имя>[i, j]

A[1, 1]

<имя>[i, j, k]

A[1, 1, 1]

Где i, j, k — индексы.

Индекс в виде значения элемента массива[править]

Индексом может быть значение элемента массива:

Операторы, стандартные процедуры и функции[править]

Вывода на экран[править]

Вывод текста[править]

Вывести текст — это значит отобразить текст на экране. Общий синтаксис для вывода текста выглядит так:

Вывод значений переменных[править]

Вывод значений произвольного количества переменных:

Write(<имя_1>, <имя_2>, ... , <имя_n>);

Например:

var
  A, B, C: integer;

begin
  A := 1;
  B := 6;
  C := 2;
  Write(A, B, C);
end.

Для перехода на новую строку после вывода последнего значения используйте Writeln вместо Write.

Ввод данных с клавиатуры[править]

Чтение с клавиатуры — это процесс ввода данных с клавиатуры и запись в соответствующий элемент программы этих данных. Элементами программы являются как переменные, так и элементы массивов. Тип данных, вводимых с клавиатуры, должен соответствовать типу элемента, в который записываются данные с клавиатуры. Использование Readln для чтения с клавиатуры и перехода на новую строку:

Readln(<имя_переменной_1>, <имя_переменной_2>, ... ,<имя_переменной_n>);

Условный оператор[править]

Общий синтаксис условного оператора if:

if (<условие>) then
begin
  <команда_1>;
  ...
  <команда_N>;
end;

Команды <команда_1>…<команда_N> будут выполнены только при истинности условия.

Сравнение[править]

Условные обозначения в программировании операций сравнения приведены в таблице:

Общий синтаксис сравнения двух величин:

<элемент_1><знак_сравнения><элемент_2>;

Пример:

const
  N = 10;

var
  A: array of integer; 
  Max: integer;

begin
  SetLength(A, N);
  for var i := 0 to N - 1 do A[i] := Random(100); 
  
  Max := integer.MinValue; 
  for var i := 0 to N - 1 do 
    if A[i] > Max then Max := A[i];
  
  Writeln(A); 
  Writeln(Max); 
end.

Посмотреть статью с примером.

Оператор case[править]

Оператор case используется для сопоставления значения некоторого выражения с константными значениями:

case <выражение> of
  <константное_значение_1>: begin <операторы_1>; end;
  ...
  <константное_значение_n>: begin <операторы_n>; end;
  else <операторы>
end;

Если некоторое i-тое константное выражение совпадает с значением выражения, то i-ая группа операторов будет выполнена. Группа операторов после else будет выполнена, если значение выражения не совпало ни с одной из констант. begin — end не нужны, если после двоеточия только один оператор.

Пример:

var
  S, S2: string;
  i: integer := 1;

// Выделение слова из строки:
function GetWord(s: string; var from: integer): string;
begin
  while (from <= Length(s)) and char.IsLetter(s.Chars[from]) do
  begin
    Result += s.Chars[from];
    Inc(from);
  end;
end;

begin
  Readln(S);
  
  var L := Length(S);
  while i <= L do
  begin
    while (i <= L) and not char.IsLetter(S.Chars[i]) do
    begin
      S2 += S.Chars[i];
      Inc(i);
    end;
    var w := GetWord(S, i);
    // Преобразование числа в слово:
    case LowerCase(w) of
      'ноль', 'нуль': S2 += '0';
      'один': S2 += '1';
      'два': S2 += '2';
      'три': S2 += '3';
      'четыре': S2 += '4';
      'пять': S2 += '5';
      'шесть': S2 += '6';
      'семь': S2 += '7';
      'восемь': S2 += '8';
      'девять': S2 += '9';
      else S2 += w
    end;
  end;
  S := S2;
  
  Writeln(S2);
end.

Посмотреть статью с примером.

Оператор цикла while[править]

Оператор цикла позволяет выполнять группу операторов (или один) циклически пока условие является истинным.

while (<условие>) do
begin
  <оператор_1>;
  ...
  <оператор_n>
end;

Пример:

var
  S, S2: string;
  i: integer := 1;

begin
  Readln(S);
  // Пока не дошли до конца строки:
  while i <= Length(S) do
  begin
    if S.Chars[i] = ' ' then
    begin
      S2 += ' ';
      Inc(i);
    end;
    // Пропускаем все лишние пробелы.
    while (i <= Length(S)) and (S.Chars[i] = ' ') do Inc(i);
    // Бежим по строке до тех пор пока не встретим пробел.
    while (i <= Length(S)) and (S.Chars[i] <> ' ') do
    begin
      S2 += S.Chars[i];
      Inc(i);
    end;
  end;
  S := S2;
  Writeln(S);
end.

Посмотреть статью с примером.

Счетчик[править]

«Счетчик» — это оператор цикла for, выполняющий группу операторов определенное количество раз.
Общий синтаксис оператора цикла for:

for var <переменная_цикла> := <значение_1> to <значение_2> do
begin
  <оператор_1>;
  ...
  <оператор_n>;
end;

Если второе значение меньше первого — используйте downto вместо to.

Пример:

const
  N = 10;

var
  A: array of integer;

begin
  SetLength(A, N); 
  for var i := 0 to N - 1 do Readln(A[i]); 
  Writeln(A); 
end.

Посмотреть статью с примером.

Оператор break[править]

Для выхода из цикла можно использовать break:

const
  N = 9;

var
  A: array [0..N - 1] of integer;


begin
  for var i := 0 to N - 1 do
  begin
    Readln(A[i]);
    if A[i] mod 2 = 0 then
      break;
  end;
end.

Новая итерация цикла[править]

Для завершения текущей итерации цикла и начала другой используйте оператор continue.

Функции[править]

Общий синтаксис описания функции:

function <имя>(<описание_параметров>): <тип_возвращаемого_значения>;
begin
  <оператор_1>;
  ...
  <оператор_n>;
end;

или:

function <имя>(<описание_параметров>) := <выражение>; // Вывод типа возвращаемого значения производится на основе типа выражения.

Можно устанавливать значение переменной Result для указания возвращаемого значения.

Пример:

function F(a, b: integer): integer;
begin
  if a < b then Result := a else Result := F(a - b, b);
end;

begin
  Writeln(F(ReadlnInteger('A:'), ReadlnInteger('B:')));
end.

Посмотреть статью с примером.

Процедуры[править]

Синтаксис объявления процедуры:

procedure <имя>(<описание_параметров>);
begin
  <оператор_1>;
  ...
  <оператор_n>;
end;

или:

procedure <имя>(<описание_параметров>) := <оператор>;

Пример:

uses Crt, GraphABC, ABCButtons;
var
  B: ButtonABC;

procedure P() := Writeln('Привет мир!'); // Сокращённый синтаксис объявления процедур, содержащих один оператор.

begin
  B := new ButtonABC(0, 0, 100, 40, 'Button', clRed);
  B.OnClick := P;
end.

Посмотреть статью с примером.

Оператор exit[править]

Для выхода из некоторой функции или процедуры можно использовать оператор exit.

Встроенные процедуры и функции[править]

Random(<максимальное_значение>)

Inc(<имя>)

Dec(<имя>)

Succ(<символ>)

Pred(<символ>)

Подключение модулей[править]

Модуль — это часть программы, вынесенная в отдельный файл. Для подключения модуля следует писать в разделе uses его имя:

uses <имя_модуля_1>, <имя_модуля_2>, ... , <имя_модуля_n>;

Свои типы[править]

Примеры объявления своих типов:

type
  Int = integer; // Тип числа.
  ShortStr = string[255]; // Тип короткой строки.
  Numbers = (One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten); // Тип названия числа.
  TArray<T> = array of T; // Тип одномерного массива с элементами типа T.
  TMatrix<T> = array [,] of T; // Тип матрицы с элементами типа T.

Пример вывода обобщённого массива:

type
  TArray<T> = array of T;

procedure Show<T>(a: TArray<T>);
begin
  for var i := 0 to a.Length - 1 do
    Writeln(a[i]);
end;

begin
  Show(ArrRandom());
end.

Примеры[править]

Мигание текста[править]

uses System;

begin
  var rnd := new Random();
  while true do
  begin
    Console.SetCursorPosition(0, 0);
    Console.ForegroundColor := ConsoleColor(rnd.Next(15));
    Console.Write('Hello world!');
    Sleep(200);
  end;
end.

Класс ввода данных пользователя[править]

uses FormsABC;
const
  Width = 50;

type
  TUserData = class
  private 
    _Name, _Password: Field;
    _LogIn: Button;
    _W: integer;
    
    function GetW()  := _W;
    
    procedure SetW(v: integer);
    begin
      _Name.FieldWidth := v;
      _Password.FieldWidth := v;
      _W := v;
    end;
  
  public 
    property Name: Field read _Name;
    property Password: Field read _Password;
    property LogIn: Button read _LogIn;
    property W: integer read GetW write SetW;
    
    constructor(nText, pText, logInText: string);
    begin
      _Name := new Field(nText, Width);
      _Password := new Field(pText, Width);
      _LogIn := new Button(logInText);
    end;
  end;

begin
  var UserInput := new TUserData('Name', 'Password', 'Ok');
end.

var x, y: real;
begin

  writeln('введите введите x');
  readln(x);
  if x>0 then y:=sqrt(x)  else  y:=sqr(x);
  writeln(y);
  writeln('введите x');
  readln(x);
  if x=0 then y:=0 else y:=0;
  writeln(y);
  writeln('введите x');
  readln(x);
  if x<0 then y:=x+x else y:=x+x;
  writeln(y);
  end.

Содержание:

От автора.

Глава I. Основы языка Pascal.

§1. Основные сведения о языке программирования Pascal. Первая программа.

§2. Переменные. Основы ввода вывода. Имена программ. Комментарии.

§3. Оператор присваивания. Арифметические выражения.

§4. Процедуры и функции. Константы.

§5. Условия. Логические выражения. Оператор выбора Case.

§6. Оператор безусловного перехода. Циклы. Блок-схемы.

Глава II. Типы данных.

§7. Типы данных. Порядковые типы. Целые типы.

§8. Логический, символьный, перечисляемый типы и тип-диапазон.

§9. Системные подпрограммы для работы с порядковыми типами. Вещественные типы.

§10. Структурированные типы. Массивы. Записи. Множества.

§11. Строки.

§12.Файлы. Типизированные и текстовые файлы.

§13.Нетипизированные файлы. Подпрограммы для работы с файлами.

Глава III. Дополнительные сведения к пройденному материалу.

§14. Сведения по различным темам.

Цикл For downto do.

Процедуры Halt и Sleep.

Математические функции.

Тригонометрические функции.

Создание переменных в теле программы.

Идентификаторы.

Венгерская нотация.

Инициализация переменных.

§15. Сведения по подпрограммам.

Работа подпрограммы с переменной напрямую.

Вызов подпрограммы подпрограммой.

Рекурсия.

Специальная переменная Result.

Подпрограммы с одним именем.

§16. Работа в PascalABC.NET.

Глава IV. Модули. Программирование под ОС DOS.

§17. Модули.

§18. Сведения необходимые для программирования под ОС DOS.

Консольное приложение. Исполняемый файл.

Текущий каталог.

Модуль CRT.

§19. Клавиатурный тренажёр. Игра «Гонки».

Глава V. Графика. Программирование под ОС Windows.

§20. Модуль GraphABC.

Текст.

Цвета.

Точка.

Отрезок.

Подпрограммы для настройки пера.

§21. Геометрические фигуры.

Круг и окружность.

Подпрограммы для работы с кистью.

Дуга. Часть круга.

Прямоугольник.

Прямоугольник со скруглёнными краями.

Эллипс.

Заливка области заданным цветом.

Движущийся предмет.

§22. Модель мяча.

§23. Отталкивающиеся мячи.

§24. Процедурный тип. Использование клавиатуры и мыши.

§25. Программа «Калькулятор».

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

§26. Принципы ООП. Инкапсуляция.

§27. Наследование. Полиморфизм. Абстрактные методы.

§28. Свойства. Видимость членов класса.

§29. Оставшиеся темы по ООП. Подготовка объектов для игры «Гонки».

Глава VII. Заключительная часть.

§30. Динамическая память.

Динамическая память, указатели.

Динамический список.

Динамические массивы.

§31. Исключения.

§32. Обзор классов и модулей PascalABC.NET.

§33. Задачи для закрепления пройденного материала.

Заключение.

Небольшое предисловие

Язык программирования «Pascal» подходит многим пользователям компьютера и одобрен Министерством Образования Российской Федерации. Большинство начинающих программистов и разработчиков консольных программ считают его эталоном при изучении языка программирования начального уровня. На нашем скромном сайте нет споров по этому поводу.

Во многих школах России ученики работают на старом Turbo Pascal, который был выпущен 1980 году. Его оболочка создана под дисковую операционную систему DOS. Работа в древней версии Pascal на компьютерах нового поколения — это просто смешно.

Сделав выводы, я подобрал для этого сайта российскую систему программирования PascalABC.NET. Эта среда разработки работает на бесплатной основе, оснащена собственным редактором кода, позволяет «создавать» приложения разных типов.

В PascalABC.NET вы «пишете» приложения консольного типа, то есть без графической оболочки и интерфейса и графические программы, которые запускаются в OS Windows. Главная особенность этой версии языка «Pascal» — это его простота и функциональность платформы . NET. Перейдите на сайт pascalabc.net, чтобы установить  PascalABC.NET.

Основная настройка PascalABC.NET.

Работая в этой среде программирования, вы, наверное, не входили в настройки и ничего не меняли вручную. Небольшие изменения и настройка параметров системы программирования упростит работу с «Pascal».

Откройте меню «Сервис» и выберите пункт «Настройки».

Далее, вы увидите окно с разделами «Общие», «Редактор», «Опции» и Intelisense.

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

Перейдите в «Опции компилятора».

Снимите галочку с пункта «Удалять EXE файл». После этого, вы запустите приложение, написанное под консоль без входа среду разработки. Если приложение создано в исполнительном файле – его можно запускать с любого источника без «Паскаля».

Откройте раздел Intellisense.

Поставьте галочки, как показано на скрине.

После настроек среды программирования проверьте результат. В этом уроке воспользуемся функцией Intellisense.

Когда вы вводите «оператор» или прочие данные, появляется подсказка. Прокручивайте список, используя «Стрелки».

Начните писать приложение в PascalABC.NET, используя набор готовые шаблоны текста (snippets). Напишите несколько символов кода и щёлкните сочетание клавиш «Shift + Пробел», чтобы вызвать список с шаблонами.

Основные шаблоны программы

Далее по тексту знак «|», будет обозначать положение курсора после вставки шаблона

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

Посмотрите пример:

Отличительная черта нового Паскаля: переменные могут указываться в теле программы. Такая особенность помогает при написании длинного кода для приложения. Допустим, в вашем коде не указана какая-то переменная. Есть два варианта: поверить весь код, вернувшись в начало, а потом дописать её в разделе, где «объявляются переменные» или написать в самом «теле».

Для закрепления знаний, решите задачу на обмен значениями.

Последний плюс новой версии инструментального ПО — определение типов в автоматическом режиме.

Пример:

На этом все!

Подпишитесь на наш сайт и не забывайте нажимать по кнопкам!