Основы кода

Оператор присваивания значения

На примере вышеприведенного кода мы могли заметить, что значения переменным присваиваются с помощью оператора присваивания

:=
    

То есть, двоеточие и знак "равно", следующий сразу за ним, без пробелов. Присвоение происходит справа-налево: вначале вычисляется значение, указанное ПОСЛЕ этого оператора, затем оно присваивается переменной, указанной ДО оператора присваивания. Например:

var
   i: integer;  //объявили переменную с типом integer - целое число
begin
   i:= 3;  //присвоили этой переменной значение 3
    

Значение, которое мы присваиваем переменной, может быть и сложным, составным. Мы можем указать не просто значение, а целое выражение, причем использовать в нем предыдущее значение самой переменной! Взгляните на пример:

var
   i: integer;
begin
   i:= 3;
   i:= 2 * 5 + 36 * i;  //сложное выражение
    

Тут мы объявили целочисленную переменную i. Этой переменной мы присвоили значение 3. Потом мы присвоили новое значение, которое сначала высчитывается компьютером из сложного выражения, а затем только присваивается переменной. Какое же значение теперь в i? Давайте считать. Из уроков математики мы знаем, что сначала вычисляются такие операторы, как умножение и деление, а только потом - сложение и вычитание. То есть, сначала высчитывается 2 * 5 = 10 (для компьютера знак "*" - это умножение, если кто-то не знает). Затем вычисляется 36 * i, а i - это 3, мы делали это присваивание строчкой выше. Так что получаем 36 * 3 = 108. Затем складываем эти значения: 10 + 108 = 118. Именно столько и попадет, в конце концов, в переменную i.

Здесь у кого-то может возникнуть вопрос: а почему автор советовал давать переменным осмысленные имена, а сам назначил простое имя i? Вопрос справедливый, отвечу так. Это - не реальная программа со множеством подпрограмм и переменных, это простой пример с одной переменной, и мы в любом случае, не запутаемся. Кроме того, переменная была назначена не для какой-то конкретной цели, а лишь для демонстрации присваивания ей значения. Поэтому и имя у переменной простое. В более сложных примерах и в лабораторных работах я постараюсь придерживаться своих же рекомендаций.

Если вы заметили, то в нашей программе мы также присваивали переменной не просто значение, а составное выражение:

MyName:= 'Привет, ' + Edit1.Text + '!';
    

Здесь мы строку "Привет, " соединяли с тем, что хранилось в поле ввода Edit1, добавляли восклицательный знак, а результат уже присваивали переменной MyName. Обратите внимание, что после слов "Привет" мы вписали не просто запятую, а запятую с последующим пробелом. Если бы мы не указали этот пробел, то в результате текст сливался бы, а это не очень красиво:

Привет,Дмитрий!
    

Константы

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

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

i:= 3; //здесь 3 - это числовая константа
s:= 'строка'; // 'строка' - строковая константа
    

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

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

1. Когда не хочется запоминать реального значения, или когда оно довольно длинное. Например, число ПИ равно 3,141 592 653 589 793 238 462 643 383 279 502 88. Хочется вам запоминать такое значение? Не проще ли определить константу pi и записать в нее это число? Тогда в дальнейшем, вместо указания этого числа мы будем указывать константу pi. Компилятор сам подставит нужное значение вместо имени этой константы.
2. Когда какое-то значение используется в программе без изменений, но со временем оно может стать другим. Например, минимальная зарплата (МРОТ - Минимальный Размер Оплаты Труда) на 2013 год принята в размере 5205 руб. Наша программа, к примеру, вычисляет зарплату сотрудников, для этого МРОТ может умножаться на различные коэффициенты, например, коэффициент выслуги лет. Поскольку такое вычисление будет многократным - для каждого сотрудника отдельно, да еще с различными условиями (отпуск, больничный, премия и т.п.), то разумно объявить константу mrot со значением 5205, и в дальнейшем использовать ее вместо реального значения. Почему такой подход удобен? Во-первых, наша программа может попасть в другой регион, а там может оказаться свой размер МРОТ. Например, в Ленинградской области принят МРОТ в размере 6800 руб., а в г. Москве и вовсе 12200 руб. Во-вторых, на 2014 год размер МРОТ наверняка увеличится, а значит, его значение изменится. В обоих этих случаях достаточно будет изменить значение константы в начале модуля, и во всех местах кода, где эта константа применяется, автоматически будет использовано новое значение. Нам не придется кропотливо выискивать по всему коду, где же мы использовали при расчетах размер МРОТ, чтобы вписать туда новое значение.

Итак, правило:

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

Константы объявляются в разделе const (англ. constants - постоянные, константы), причем этот раздел должен располагаться до раздела var. Объявление константы и присвоение ей значения в отличие от переменных, происходит одновременно:

const
  mrot = 5205;
    

Здесь мы создали раздел констант, в котором объявили константу mrot, и сразу же присвоили ей значение 5205. Как видите, вместо оператора присваивания ":=", как это было у переменных, здесь используется простой знак "равно", а тип константы не указывается. Компилятор сам, в зависимости от указанного значения, присваивает константе наиболее подходящий тип.

Вернемся к нашему примеру, и снова доработаем код события нажатия на кнопку:

procedure TfMain.Button1Click(Sender: TObject);
const
  priv = 'Привет, ';
var
  MyName: String;
begin
  MyName:= priv + Edit1.Text + '!';
  ShowMessage(MyName);
  MyName:= 'Рады вас видеть, ' + Edit1.Text + '!';
  ShowMessage(MyName);
end;
    

В этом примере мы объявили константу priv и присвоили ей текст - начало приветствия. Причем раздел const мы поместили до раздела var. В строке

MyName:= priv + Edit1.Text + '!';
    

компилятор вместо "priv" подставит значение "Привет, " и мы получим прежний текст приветствия.

Комментарии

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

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

Комментарии улучшают восприятие кода программистом, а если проект разрабатывается не одним программистом, а группой, тут без комментариев и вовсе не обойтись. Говорят, в компании Microsoft, когда принимают на работу нового программиста, смотрят на стиль его кода. И если там комментариев меньше, чем 1/3 от всей программы, ему отказывают в вакансии. Это и понятно - если кто-то другой будет подключать ваш модуль к общей программе, без комментариев ему будет трудно разобраться, что у вас к чему. Даже если вы сами вернетесь к вашей программе через какое-то время, без комментариев вам будет трудно вспомнить, где и что у вас хранится, иной раз проще написать такую программу заново. Поэтому использование комментариев обязательно для каждого программиста, уважающего свое собственное время, и время коллег.

Комментарии бывают однострочными и многострочными.

Однострочный комментарий начинается с символов "//" и может располагаться как на отдельной строке, так и после действующего оператора. Примеры мы уже видели:

i:= 3;  //присвоили этой переменной значение 3
    

Здесь текст после "//" - однострочный комментарий. Мы могли бы расположить его и на отдельной строке:

//присваиваем переменной новое значение:
i:= 10;
    

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

//присваиваем переменной новое значение:   i:= 10;
    

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

//*************************************************
…какой-то код
//*************************************************
Или так:
//------------ НАЧАЛО БЛОКА КОДА -----------------------------
…какой-то код
//------------ КОНЕЦ БЛОКА КОДА -------------------------------
    

В общем, для улучшения читабельности программы, после "//" вы можете использовать собственные разделители.

Многострочный комментарий. Когда комментарий содержит много пояснительного текста, его делают многострочным. Для этого его помещают в фигурные скобки "{…}". Всё, что находится внутри таких скобок, считается комментарием:

{Пример комментария}

{Пример длинного
 многострочного комментария}

{
Пример длинного
многострочного комментария
}
    

Также в Паскале вместо фигурных скобок для многострочного комментария можно применять символы комментариев языка С: "(*…*)":

(*
Пример многострочного комментария
в стиле С/С++
*)
    

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

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

var
   i: integer;  //объявили переменную с типом integer - целое число
begin
   i:= 3;  //присвоили этой переменной значение 3
    

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