Главная страница

Переменные, константы и их типы - Конспект. Язык Delphi. Переменные, константы и их типы


Скачать 45.5 Kb.
НазваниеЯзык Delphi. Переменные, константы и их типы
Дата06.10.2022
Размер45.5 Kb.
Формат файлаdocx
Имя файлаПеременные, константы и их типы - Конспект.docx
ТипДокументы
#716856

Язык Delphi. Переменные, константы и их типы

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

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

    Место описания данных в программе - вне логических блоков begin / end. В модуле перед ключевым словом implementation есть блок описания:

Var

  Form1: TForm1;

Именно здесь, начиная со следующей строки, удобно объявлять глобальныепеременные и константы. Как видим, одна (Form1) уже есть!

Команда объявления переменных в языке Delphi:

   var имя_переменной : тип_переменной ;

    Слово var - ключевое. Именем может быть любой идентификатор, если он не был описан ранее и не является одним из ключевых или зарезервированных слов языка Delphi. Если нужно описать несколько переменных одного типа, то их перечисляют, отделяя запятой: 

    var A, B, C : Integer;

    Если несколько описаний следуют друг за другом, то ключевое слово varповторно можно не указывать:

var A, B : Integer;

        C, D : String;

    Постоянную величину иначе называют константой. Конечно, в программе можно использовать числа и строки непосредственно: 3.1415 или 'Это значение числа пи', но иногда удобнее присвоить их идентификатору. Описание констант аналогично описанию переменных, но используется ключевое слово const, за именем идентификатора следует тип, затем знак равенства и его значение. Причём тип константы допускается не указывать:

const pi=3.1415 ;
         ZnakPi : String = 'Это значение числа пи';

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

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

   Строкой называется последовательность символов, заключённая в одиночные кавычки:

'это текстовая строка'

Если текст должен содержать сам символ кавычки, то его надо повторить дважды:
'это '' - символ одиночной кавычки'

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

   Самый популярный строковый тип - String. Строка типа String может содержать переменное количество символов объёмом до 2 Гбайт. Если нужно ограничить размер строки фиксированным значением, то после ключевого словаString в квадратных скобках указывается число, определяющее количество символов в строке: String[50]. Более полно работа со строками Delphi описывается далее. 

   Одиночный символ имеет тип Char и записывается в виде знака в одиночных кавычках: 'a'. Есть символы, которые на экране отобразить невозможно, например, символ конца строки (равен #13), символ переноса строки (равен #10). Такие символы записываются в виде их числового кода (в кодировке ANSI), перед которым стоит знак #. Например, #0.

   Наконец, существуют так называемые нуль-терминированные строки. Отсчёт символов в таких строках начинается с нуля, а заканчивается символом с кодом0 (#0). Такие строки имеют тип PChar.
   Числа бывают целые и дробные.

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


   Integer

   -2147483648 .. +2147483647

   Cardinal

   0 .. 4294967295

   Shortint

   -128 .. +127

   Smallint

   -32768 .. +32767

   Int64

   -263 .. +263-1

   Byte

   0 .. +255

   Word

   0 .. +65535




Наиболее удобным для использования в программах является тип Delphi Integer. Другие целые типы используются для уменьшения места, занимаемого данными в памяти компьютера.


   Дробные числа имеют дробную часть, отделяемую десятичной точкой. Допускается использование символа e (или E), за которым следует число, указывающее, что левую часть нужно умножить на 10 в соответствующей степени: 5e25 - пять умножить на десять в двадцать пятой степени.

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

   Real

   5*10-324 .. 1.7*10308

   Real48

   2.9*10-39 .. 1.7*1038

   Singl

   1.5*10-45 .. 3.4*1038

   Double

   5*10-324 .. 1.7*10308

   Extended

   3.6*10-4951 .. 1.1*104932-1

   Comp

   -263 .. +263-1

   Currency

   922337203685477.5807




Наиболее удобным для использования в программах является тип Delphi Real. Ему эквивилентен тип Double, но в будущем это может быть изменено. Вычисления с дробными числами выполняются приближённо, за исключением типа Currency (финансовый), который предназначен для минимизации ошибок округления в бухгалтерских расчётах.

   Следующим типом данных является логический Boolean, состоящий всего из двух значений: True (Истина) и False (Ложь). При этом True > False.

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

Про консольные программы я здесь не говорю! А в нормальных оконных Windows-приложениях это значение нужно поместить в какой-нибудь компонент, имеющий свойства Text или Caption. Это, например, такие компоненты как Labelи Edit, да и сама Форма имеет свойство Caption, куда тоже можно выводить информацию. Однако, в Delphi информацию перед выводом, как правило, необходимо преобразовывать. Так как присвоение возможно только между переменными одного типа, то такая программа (не пытайтесь её исполнять):

   var A, B, C: Integer ;
  begin
   A := 5 ;
   B := 10 ;
   C := A+B ;
   Label1.Caption := C ;
  end ;

вызовет ошибку, так как свойство Caption имеет текстовый тип String, а использованные переменные - цифровой тип Integer. Значит, нужно преобразовать значение переменной C в текстовый тип. Для этого есть встроенная функция IntToStr. Строка в нашей "программе", вызывавшая ошибку, должна выглядеть так:

   Label1.Caption := IntToStr(C) ;

   Такая программа, кроме показа числа 15, ни на что не способна. Мы должны научиться вводить в программу другие числа. Используем компоненты Edit. Введённые числа будут содержаться в свойстве Text этих компонентов. Расположим на форме два компонента Edit, один компонент Label и кнопкуButton, по нажатию на которую и будем проводить вычисления. В компоненты Edit1 и Edit2 будем вводить числа для суммирования. Чтобы переместиться в редактор кода, щёлкнем дважды по нашей кнопке Button1. Мы попадём прямо в сформированную для нас средой Delphi заготовку обработчика нажатия на кнопку, непосредственно между операторами begin и end. Напишем такой простой код:

  procedure TForm1.Button1Click(Sender: TObject);
  var A, B, C: Integer;//Не забудьте описание переменных
  begin
  //Начало кода:
   A := Edit1.Text;
   B := Edit2.Text;
   C := A+B;
   Label1.Caption := IntToStr(C);
  //Конец кода
  end ; 

При попытке исполнить этот код Delphi покажет ошибки по аналогичной причине - переменные A и B имеют цифровой тип Integer, а свойство Text – текстовый тип String. Исправить ошибки поможет встроенная функция StrToInt, выполняющая обратное преобразование - текст в целое число. Операторы присвоения переменным A и B должны выглядеть так:

   A := StrToInt(Edit1.Text);
   B := StrToInt(Edit2.Text);

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

   Label1.Caption:=IntToStr(StrToInt(Edit1.Text)+StrToInt(Edit2.Text));

Аналогично, имеются функции и для преобразования в строку и обратно действительных чисел c плавающей (Floating англ.) запятой, имеющих тип Real. Для преобразования в строку - FloatToStr, обратно - StrToFloat.
   Часто результаты вычислений, имеющие тип Delphi Real, имеют после запятой длинный "хвост" цифр. При выводе такой переменной в текстовом виде необходимо ограничить количество цифр после запятой. Как это можно сделать, описывается также в Уроке Delphi Работа со строками Delphi.

Выражения и операторы Delphi

Выражения Delphi


   В программах Delphi применяются

  • математические выражения

  • логические выражения

  • выражения со строками

и другие.

Математические выражения


   В математических выражениях используются операции присваивания :=, сложения +, вычитания -, умножения *, деления /, целочисленного деления div, остатка отделения mod. При использовании этих операций важен приоритет их выполнения, так как в программировании на языке Delphi, как и в обычной математике, выражения выполняются не в порядке следования, а с учётом приоритета. У операций умножения и деления более высокий приоритет, чем у операций сложения и вычитания.

   То есть, результат выражения

X:=1+2*3-4/5;
будет равен не 1, как в случае последовательного выполнения, а 6.2 .

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

X:=((1+2)*3-4)/5;

Вот теперь X будет равен 1.

   Помимо четырёх математических действий в Delphi доступно множество математических функций, таких, например, как тригонометрические, логарифмические, и т.д. Они становятся доступны в программе после добавления в секцию Interface uses модуля Math. Их описание также можно найти в модулеMath.pas (можно найти воспользовавшись поиском Windows). Многие из них можно реализовать и самому, но встроенные функции наверняка будут работать быстрее и лучше, т.к. написаны на языке ассемблера.

Логические выражения


   Логические выражения выполняются над операндами логического типа, то есть имеющими тип Boolean Delphi. Они применяются в основном в условных операторах.

Операторы Delphi


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

  • оператора присваивания

  • условного оператора

  • оператора цикла

   Оператор присваивания ":=" работает следующим образом. Переменная, стоящая в левой части оператора, становится равной той величине, которая находится справа. Типы этих величин должны совпадать. В выражении, стоящем справа, также может использоваться переменная, стоящая слева. С математической точки зрения это неправильно, но в программировании это означает, что из ячейки памяти берётся исходное значение, производятся вычисления, и результат записывается в эту же ячейку памяти, затирая прежнее значение. Пример:
   var A, B : Integer;
   begin
     A:=3;
     B:=4;
     A:=A*A+B*B;
   end

В начале фрагмента переменная A равна 3, а в конце -25.
   Условный оператор позволяет изменить порядок выполнения операторов в зависимости от выполнения некоторого условия. Вот как он записывается:
   if условие then действие else альтернатива ;
Слова if (если), then (тогда), else (иначе) - зарезервированные. Действие и else альтернатива - это любые операторы Delphi, или несколько операторов, заключённых в логические скобки begin/end, или вызов подпрограммы. Если условие истинно, то выполняется действие, если ложно, то выполняется альтернатива.
   Условие представляет собой логическое выражение. В нём сравниваются значения выражений (в том числе также и логических), вызов функций, возвращающих значения типа Boolean, и комбинирование этих значений с помощью логических операций:


Знак
операции


Название операции

   Логические операции могут комбинироваться с помощью связок:
   and (логическое И)
   or (логическое ИЛИ)
   xor (исключающее ИЛИ)
Для некоторых типов данных есть дополнительные операции. Например, для множеств - операторin, которая проверяет, входит ли некоторое значение в множество. Например:
      X := [2, 4, 5, 7, 8, 10] ;
Выражение 2 in X истинно (имеет значение true);
Выражение 6 in X ложно (имеет значение false);

   =   

   Равно   

   <>   

   Не равно   

   >   

   Больше   

   <   

   Меньше   

   >=   

   Больше или равно   

   <=   

   Меньше или равно   

   not   

Логическое Не - отрицание

   Результат выполнения операции логического И равен true, если оба операнда равны true.

   Результат выполнения операции логического ИЛИ равен true, если хотя бы один из операндов равен true.

   Результат выполнения операции исключающего ИЛИ равен true, если операнды не равны друг другу.

   Операторы цикла позволяют организовать многократное повторение одной и той же последовательности действий. В Delphi имеются три оператора, позволяющих это сделать:

  • "простой" оператор цикла

  • условный оператор цикла

  • условный оператор повторения


Простой оператор цикла применяется, когда известно количество повторений цикла. Он записывается так:

   for счётчик := выражение-1 to выражение-2
   do действие ;
Счётчик - это переменная, которая должна быть объявлена перед логическим блоком, в котором оператор цикла расположен, и её тип должен относиться к одному из перечислимых типов, обычно Integer.

Выражение-1 и выражение-2 могут быть как константой или идентификатором, так и вызовом функции.

Действие - один или несколько операторов Delphi. Если это группа операторов, то они должны быть заключены в логические скобки begin/end.

   В начале работы оператора переменная-счётчик получает значение выражения-1. Если при этом значение счётчика окажется меньше или равно значениювыражения-2, то выполняются операторы, входящие в действие. Это и есть один цикл. Затем переменная-счётчик принимает значение, следующее за текущим, и начинается новый цикл, то есть сравнение счётчика и выражения-2, выполнение действия, и так далее, до тех пор, пока значение переменной-счётчика не превысит значение выражения-2.

   Возможна работа оператора цикла, при котором переменная-счётчик будет не увеличиваться, а уменьшаться. В этом случае ключевое слово to заменяется на downto:

   for счётчик := выражение-1 downto выражение-2 do действие ;

Соответственно, выражение-1 должно быть больше или равно выражению-2.
Условный оператор цикла удобно использовать в том случае, когда количество повторений заранее не известно:

   while условие do
   тело цикла ;

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

   Нужно очень внимательно следить за написанием условия и контролем завершения цикла, так как в результате ошибки цикл while будет повторяться бесконечное количество раз, что приведёт к "зацикливанию" и "зависанию" программы.
Условный оператор повторения сначала выполняет тело цикла, а затем уже проверяет выполнение условия:

   repeat
   тело цикла
   until условие ;

Таким образом, этот вариант цикла гарантирует, что тело цикла будет выполнен по крайней мере один раз. И будет выполняться до тех пор, пока условие не станет истинным (т.е. true). Стоит отметить, что это единственный оператор Delphi, в котором тело цикла не требуется заключать в логические скобки begin/end. Начало и конец тела цикла определяются по ключевым словам repeat и until.
   Вместе с операторами цикла используются специальные команды:

  • команда прерывания цикла

  • команда продолжения цикла

   Команда прерывания цикла применяется, если в процессе выполнения операторов тела цикла выясняется необходимость его завершения. Вот эта команда:
   Break ;

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

   Continue ;
   Справедливости ради стоит рассказать об ещё одном операторе, позволяющем изменить последовательность выполнения программы. Это оператор перехода:

   goto метка ;

В качестве метки может использоваться любой допустимый идентификатор или число в диапазоне от 0 до 9999. Метку предварительно необходимо объявить в разделе описания переменных, но с помощью не ключевого слова var, а ключевого слова label:

   label меткa ;

или

   label список меток ;
Переходить можно как вниз, так и вверх по программе. Двоеточие отделяет метку от оператора, на который производится переход. Пример использования оператора перехода:
   var X, Y: Integer;
   label A, B;
   begin
    A: X:=5 ;
       . . .
    операторы программы

    goto B;
       . . .
    B: Y:=25;
    goto A;
   end;
Из этого примера видно, что оператор end ; завершающий программу, никогда не будет выполнен, то есть программа зациклится. Именно поэтому, вообще, использование оператора перехода является плохим стилем программирования, и без его использования вполне можно обойтись использованием условных операторов и операторов цикла. Единственный случай, когда использование оператора goto может быть оправдано - это выход из нескольких вложенных циклов, что иначе требует применения нескольких операторов Break.

Пример. Сортировка одномерного массива

Рассматриваются процедуры программы, приводятся подробные комментарии. Цикл while и операторы goto использованы только для демонстрации работы с ними

   Параллельно замечу, что сортировка массива "методом пузырька" - неэффективный метод. Количество итераций (проходов цикла) растёт гораздо быстрее роста количества элементов, пропорционально n2. Сортировка 50 000 элементов выполняется на моём компьютере секунд за пять. Но сортировка 100 000 - не за 10 секунд, а около 35 секунд! Можете поэкспериментировать, для этого достаточно во 2 варианте установить в описании массива нужное количество элементов.

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

type Point=Record //Объявляем тип: Запись
    n, digit: Integer; //номер и значение: целые числа
  end;
var
  Form1: TForm1;
  tab: array[1..20] of Point; //Создаём массив записей типа Point

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
 StringGrid1.Cells[0, 0]:='Номер';//Инициализируем столбцы таблицы
 StringGrid1.Cells[1, 0]:='Значение';
end;

procedure TForm1.Button1Click(Sender: TObject);
var i: Integer;
begin
 Randomize; //Инициализируем "случайную" процедуру
 For i:=1 to StringGrid1.RowCount-1 do
  begin
   tab[i].n:=i; //Присваиваем ячейкам массива порядковые номера
   tab[i].digit:=Random(100); //Присваиваем ячейкам массива случайные значения в диапазоне от 0 до 100
   StringGrid1.Cells[0, i]:=IntToStr(i)+'.'; //Нумеруем таблицу
   StringGrid1.Cells[1, i]:=IntToStr(tab[i].digit); //Переписываем в таблицу значения
  end;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
 Application.Terminate; //Процедура завершения программы
end;

      


procedure TForm1.Button2Click(Sender: TObject);
var i, n: Integer; //переменные цикла
 Sort: Boolean; //Переменная - признак окончания сортировки
 Obmen: Point; //Служебная переменная перестановки значений массива
 Label manual1, manual2; //Метки операторов перехода
begin
Sort:=True; //Признак неотсортированности массива
n:=StringGrid1.RowCount-1; //Количество строк в таблице (без заголовка)
if RadioButton1.Checked then goto manual1; //Переход на ручной режим
while(Sort=True) do //Начало автоматического режима: в предыдущем цикле было событие сортировки
manual1: //Начало ручного режима
 begin
  Sort:=False; //Допустим, что массив уже отсортирован (сортировка не нужна)
  for i:=1 to n-1 do //Опять проверяем все значения от 1 до n
   if(tab[i+1].digit < tab[i].digit) then //Проверка на возрастание значений. Равные значения не трогаем
    begin        //Если неверно, то переставляем соседние значения:
     Obmen:=tab[i];    //1. Сохраняем одно из значений
     tab[i]:=tab[i+1]; //2. На его место переписываем соседнее значение
     tab[i+1]:=Obmen;  //3. Переписываем сохранённое значение на новое место
     Sort:=True;       //Признак того, что состоялось событие сортировки
    end;
if RadioButton1.Checked then goto manual2; //Пропускаем переход к новому циклу автоматического режима
   end; //Здесь заканчивается очередной цикл авторежима и осуществляется переход к новому
manual2:
for i:=1 to n do //Переписываем отсортированные значения массива в таблицу
 begin
  StringGrid1.Cells[0, i]:=IntToStr(tab[i].n)+'.';
  StringGrid1.Cells[1, i]:=IntToStr(tab[i].digit);
 end;
end;

end.

   Есть возможность немного улучшить процедуру сортировки, что ускорит её примерно на четверть. Дело в том, что после каждого завершённого цикла наибольший ещё неотсортированный элемент перемещается на своё место в низ таблицы. То есть, очередной k-й цикл уже последние k элементов может не просматривать. Для реализации этого нужно ввести переменную - счётчик циклов, и отнять её от переменной цикла. При этом те же 100 000 элементов сортируются уже за 24 секунды!


написать администратору сайта