Переменные и константы

Если ключевые слова имеют заранее предопределенный смысл, то значения констант и переменных определяет программист. Но прежде, чем приступить к исследованию констант и переменных, рассмотрим знак, используемый для некоторых операций, поскольку без этого невозможно дальнейшее продвижение. Речь идет о знаке равенства (=), который используется в Delphi в двух значениях - как оператор присваивания и как оператор сравнения.

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

переменная := значение

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

ПРИМЕЧАНИЕ
Более точно выражение можно определить следующим образом: выражение - это набор данных, переменных, операторов и других выражений, которые приводятся к общему значению.

Другой вариант - это использование знака равенства для сравнения 2 операндов. В таком случае он используется самостоятельно:

операнд1 = операнд2

Такая запись означает, что сравниваются левое (операнд1) и правое (операнд2) значения выражения. Однако специально для констант предусмотрен третий вариант, при котором константе присваивается значение правого операнда (как в случае обычного присваивания), но используется знак равенства без двоеточия:

константа = значение

Таким образом, мы переходим к самим константам и переменным, и начнем мы с констант, как наиболее типичного примера подстановки.

Суть использования констант состоит в том, что вместо какого-либо явного значения указывается его условное обозначение - константа. Допустим, что вы пишете программу, в которой неоднократно следует вычислять НДС. Разумеется, вы можете использовать в выражениях явное значение - 0.18 (18%). Но скорее всего, в программе найдется несколько мест, где в вычислениях требуется значение НДС. Таким образом, если НДС в очередной раз изменят, то вам придется отыскивать в программе все эти строки и вносить правку. В таких случаях на помощь приходят константы - достаточно один раз ее определить, а затем во всех тех местах, где требуется ее значение, указывать имя константы.

Определяются константы при помощи ключевого слова const (от англ. constant):

const VAT = 0.18;

Теперь во всех выражениях, где требуется значение НДС, просто используется эта константа:

VATsumm := price * VAT;

В этом выражении задействована константа VAT и 2 переменных - VATsumm, которой присваивается значение, и price, которая используется для его вычисления. Впрочем, price в данном случае тоже может быть константой, в отличие от VATsumm. Дело в том, что константы определяются в момент написания программы, а при компиляции в код автоматически подставляются их действительные значения. Соответственно, для вычисляемых значений, равно как и для значений, которые может вводить пользователь, нужны не константы, а переменные. Так, если бы константа VAT была переменной, то можно было бы предусмотреть в программе опцию изменения значения НДС.

Переменные определяются при помощи ключевого слова var (от англ. variable):

var VAT: float;

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

ПРИМЕЧАНИЕ
Начиная с Delphi 4, в Object Pascal поддерживаются типизированные константы, значения которых можно изменять по ходу выполнения программы. Объявление констант такого типа производится следующим образом: "const : тип = значение". От обычных переменных они отличаются различиями в обработке компилятором, а так же тем, что для них всегда имеется какое-либо предопределенное значение.

Типы данных

Прежде, чем приступить к рассмотрению типов данных, постараемся понять, для чего это вообще надо. Прежде всего, Object Pascal, равно как и его предшественник - язык Pascal, а так же C и C++ относятся к строго типизированным языкам программирования. Типизированные языки, в отличие от нетипизированных (начиная с BASIC и заканчивая различными языками сценариев вроде JavaScript), имеют то преимущество, что уже на этапе синтаксической проверки кода компилятор не допустит заведомо неверных операций. К примеру, вы не сможете сложить строку с числом. Кроме того, типизация положительно сказывается на быстродействии программ: благодаря тому, что компилятор заранее "знает", что за данные ему следует обработать в каждом конкретном случае, он может подбирать оптимальные инструкции при генерации машинного кода.

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

  • Целочисленные (Integer);
  • Вещественные (Real);
  • Булевы (Boolean);
  • Символьные (Character);
  • Строковые (String).

Практически в каждой категории имеется несколько типов данных. В свою очередь это так же вызвано необходимостью более эффективного использования ресурсов компьютера. Например, если для какой-то переменной достаточно диапазона значений от 1 до 100, то зачем для нее выделять память, достаточную для хранения миллиардных значений? Так что начнем подробное с целочисленных типов, как наиболее простых и наглядных.

Всего в современных версиях Delphi предусмотрено 7 различных типов данных для целых чисел, все они приведены в таблице 3.2.

Таблица 3.2. Типы целочисленных данных
Тип Диапазон Байт (бит) памяти Отрицательные значения
Byte от 0 до 255 1 (8) Нет
ShortInt от -128 до 127 1 (8) Да
Word от 0 до 65535 2 (16) Нет
SmallInt от -32768 до 32767 2 (16) Да
LongWord от 0 до 4294967295 4 (32) Нет
LongInt от -2147483648 до 21474483647 4 (32) Да
Int64 от -9223372036854775808 до 9223372036854775807 8 (64) Да

ПРИМЕЧАНИЕ
Здесь следует сразу оговориться про понимание памяти в программировании. Так, память считают в байтах. Каждый байт состоит из 8 бит. Бит - это минимальная единица информации, бит может принимать только 2 значения, 0 или 1. Каждая переменная, в зависимости от типа, занимает то или иное количество байт в памяти. Отметим так же, что 2 байта образуют слово (word), а 4 байта - двойное слово.

Помимо перечисленных основных типов, в Delphi имеется еще 2 автоматических целочисленных типа - Integer и Cardinal. Первое, в типичном случае, является синонимом для LingInt, хотя может быть приведено и к типу Int64. Например, если объявит переменную типа Integer и попробовать записать в нее значение, превышающее максимально допустимый размер для типа LongInt, то она автоматически преобразуется в Int64:

var x: integer; ... x: = 21474483647; // здесь x имеет тип LongInt x: = x + 1; { число 21474483648 не помещается в 4-х байтовый LongInt, переменная x автоматически приводится к 8-байтовому типу int64 }

Что касается Cardinal, то это - устаревшее определение для LongWord, вы сможете встретить его, если будете просматривать исходные коды, написанные во времена первых версий Delphi. Самым распространенным на практике целочисленным типом данных является Integer.

Перейдем к вещественным типам. Для них так же предусмотрены фиксированные типы (правда, в отличие от целочисленных, их не 7, а 6), и один автоматический. Рассмотрим основные типы в таблице 3.3.

Таблица 3.3. Типы вещественных данных
Тип Диапазон Байт памяти Точность
Real48 от ±2.9*10^-39 до 1.7*10^38 11.дек
Single от ±1.5*10^-45 до 3.4*10^38 07.авг
Double от ±5.0*10^-324 до 1.7*10^308 15-16
Extended от ±3.4*10^-4951 до 1.1*10^4932 19-20
Comp от -2^63+1 до 2^63 -1 19-20
Currency от -922337203685477.5808 до 922337203685477.5807 19-20

Имеется так же и автоматический тип - Real, введенный для совместимости с программами, написанными в Delphi 2 или 3. Сейчас тот тип, что был в ранних версиях Delphi, называется Real48 и практически не используется. Вместо него рекомендуется использовать такие типы, как Single или Double. Если же задать тип Real в программе, то он будет автоматически приведен к типу Double.

Нечто подобное можно сказать и про тип Comp - этот 64-разрядный вещественный тип данных изжил себя с момента появления целочисленного типа Int64, и присутствует лишь в целях совместимости со старым программным кодом.

Зато тип Currency активно используется, особенно при работе с базами данных. Как следует из его названия (Currency - валюта), данный тип предпочтительно использовать для финансовых расчетов. И хотя Currency относится к вещественным типам данных, компилятор обращается с ним как с целым, что позволяет добиться меньших ошибок при округлениях.

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

var x: integer; y: double; ... x := 5; y := 5.25; // обратите внимание, что дробная часть отделяется точкой y := x + y; // так делать можно x := x + y; // а так - нельзя, поскольку результатом должно быть целое

Булевы, или логические типы данных представлены в Delphi типами Boolean, ByteBool, WordBool и LongBool. Все они отличаются только размером памяти, выделяемым для хранения значения, причем значений может быть только 2 - false (ложь) и true (истина):

var x, y: Boolean; ... x := true; y := false;

Основным типом является 1-байтовый Boolean (он же ByteBool), 2-байтовый WordBool и 4-байтовый LongBool предусмотрены лишь для совместимости в целях взаимодействия с другими языками и платформами.

Что касается символьных типов данных, то в Delphi предусмотрено 2 их типа - ANSIChar и WideChar. Первый является однобайтовым и может хранить в себе 1 символ из множества символов ANSI, коих насчитывается 256. Второй же тип является 2-байтовым и предназначен для хранения 2-байтовых же символов Unicode. Как и в других случаях, Delphi имеет синоним для символьных типов - Char, который на сегодня является аналогом ANSIChar. Что касается присвоения значений, то обычные символы (буквы и цифры) присваивают переменным символьного типа как есть, лишь заключая их в одиночные кавычки. А специальные символы, например, возврат каретки (Enter) назначают при помощи их номера в таблице ANSI, и выделяют знаком решетки:

var x, y: Char; // x и y получают тип ANSIChar ... x := a; // обычные символы y := #13; // возврат каретки в таблице ANSI имеет номер 13

Наконец, еще одним, причем, в общем-то, уже не совсем простым типом данных являются строки. Строковые типы данных отличаются от символьных тем, что могут хранить не единичный символ, а множество символов. В Delphi имеется 3 типа строк: ShortString, AnsiString и WideString. Первый тип строк - ShortString - достался в наследство от языка Pascal и 16-битной Delphi 1.0. Такие строки могут иметь не более 255 символов, и занимают от 2 до 256 байт памяти, в зависимости от размера: Что касается современных строковых типов - AnsiString и WideString, то они могут иметь практически неограниченную длину (AnsiString - до 2 млрд. символов, WideString - до 1 млрд.) и занимать, соответственно, от 4 байт до 2 Гигабайт памяти. При этом по аналогии с символьными типами, тип AnsiString предназначен для хранения обычных строк, а WideString - для строк в формате Unicode. Ну и еще один тип строк - String является синонимом для типа AnsiString:

var str1: ShortString; // короткая строка var str2: AnsiString; // длинная строка var str3: String; // тоже длинная строка ... str1 := Начало.; // Строковые значения заключаются в одинарные кавычки str2 := Конец.; str3 := str1 + str2; // получим длинную строку, содержащую Начало.Конец.

В целом, несмотря на кажущееся разнообразие типов данных, на практике чаще всего ограничиваются всего лишь 5-6 основными типами. Это: Integer, Double, Boolean, Char, String, и иногда - еще и Currency.

Данные и значения

Очевидно, что сами по себе типы данных ничего не означают. Главное их предназначение - хранить те или иные значения, или данные. Так, для хранения числовых данных применяют целочисленные или вещественные типы, в зависимости от того, какого типа числа следует использовать. На практике это означает, что будут применяться типы Integer и Double.

ПРИМЕЧАНИЕ
Хотя вещественные типы и являются более универсальными, использовать их надо только при реальной необходимости, поскольку они гораздо менее удобны компьютеру для вычислений. Говоря конкретнее, математические операции над вещественными числами выполняются гораздо медленнее, чем над целыми, а ряд иных операций (например, побитовые, инкремент или декремент) вообще недопустимы.

Строковые данные требуют для своего хранения строковых же типов, т.е. String. Исключение может составить тот случай, когда следует сохранить один и только один символ - в таком случае предпочтительно (а иногда - необходимо) использовать тип Char. Ну а в том случае, если требуется привести какое-то значение к однозначному выводу, используют логический тип Boolean. Например, если сравнивать одно число с другим на предмет того, является ли оно больше, то результатом сравнения будет либо "да", либо "нет", т.е. true или false:

var x: boolean; ... x := 5 > 6; // получаем false, т.к. 5 не больше 6

Важно отметить, что переменные одного типа могут хранить данные только такого же типа. Кроме того, произведение каких-либо манипуляций над данными возможно только в том случае, если они относятся к одной категории. Исключение составляют разве что такие пары, как строки-символы и вещественные-целые числа. При этом результирующая переменная должна иметь тип строки для первой пары и вещественного числа - для второй. Впрочем, подробнее все это будет рассмотрено в контексте операций языка Object Pascal.

Операции и их типы

В любом языке программирования имеются знаки операций. Кроме того, некоторые ключевые слова, например такие, как div или mod также обозначают операции. Все операции в Object Pascal можно разделить на следующие типы: логические, арифметические, логические, операции присвоения и отношения, а так же специальные операции. Для их обозначения используются математические символы или ключевые слова. Участвующие в операциях значения (переменные) называются операндами. При этом та или иная операция может работать с операндами определенного типа. А результатом может быть данные как такого же типа, та и другого (например, для того же сравнения).

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

Таблица 3.4. Арифметические операции
Операция Название, тип Описание Операнды Результат
+ Сложение, бинарная Возвращает сумму левого и правого операндов integer, real integer, real
- Вычитание, бинарная Возвращает разницу левого и правого операндов integer, real integer, real
* Умножение, бинарная Возвращает произведение левого операнда на правый операнд integer, real integer, real
/ Деление, бинарная Возвращает результат деления левого операнда на правый операнд. Результат может быть дробным integer, real real
mod Остаток от деления, бинарная Возвращает остаток от деления левого операнда на правый операнд integer integer
div Деление нацело, бинарная Возвращает целую часть числа, получившуюся в результате деления integer integer
- Унарный минус Возвращает число, противоположное операнду integer, real integer, real
+ Унарный плюс Явно указывает знак числа integer, real integer, real

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

Другой распространенный тип операций - логические. В Object Pascal имеются все 4 типа логических операций: не, и, или, исключающее или (таблица 3.5).

Таблица 3.5. Логические операции
Операция Название Описание
not Логическое отрицание (НЕ) Возвращает false, если выражение может быть приведено к истине, в противном случае возвращает true
and Логическое (И) Возвращает true, когда оба выражения истинны. В противном случае возвращает false
or Логическое (ИЛИ) Возвращает true, когда хотя бы одно из выражений истинно. В противном случае возвращает false
xor Логическое (исключающее ИЛИ) Возвращает true, когда только одно из выражений истинно. В противном случае возвращает false

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

not true // возвращает false not false // возвращает true true and true // возвращает true true and false // возвращает false false and false // возвращает false true or true // возвращает true true or false // возвращает true false or false // возвращает false true xor true // возвращает false true xor false // возвращает true false xor false // возвращает false

Логическому сравнению подлежат не только булевские значения, но и любые другие выражения, которые могут быть к ним приведены. Например, выражение "3=4" может быть использовано в качестве логически сравниваемой единицы, поскольку результатом его оценки будет булево значение ложь (false).

Те же самые знаки операций, что используются в логических операциях, задействованы и в другом типе операций - побитовых. Побитовые операции выполняются над числами, представленными в двоичном виде (т.е. только нули и единицы). Однако сами операнды могут быть десятичными, шестнадцатеричными, или восьмеричными целыми числами. Например, десятичное число 5 представляется как двоичное 101, десятичное 6 - как 110, а шестнадцатеричное F3 - как двоичное 11110011.

Хотя побитовые операции выполняются над двоичными данными, возвращаемые значения являются стандартными числами. Список всех побитовых операций приводится в таблице 3.6.

Таблица 3.6. Побитовые операции
Операция Название Описание
and Побитовое И Возвращает число, являющееся результатом побитового сравнения "И"
or Побитовое ИЛИ Возвращает число, являющееся результатом побитового сравнения "включающее ИЛИ"
xor Побитовое исключающее ИЛИ Возвращает число, являющееся результатом побитового сравнения "исключающее ИЛИ"
not Побитовое НЕ Возвращает число, с битами, расположенными в обратном порядке
shl Сдвиг влево Сдвигает первый операнд влево на число разрядов, заданных вторым операндом. Освобождающиеся правые биты заполняются нулями
shr Сдвиг вправо Сдвигает первый операнд вправо на число разрядов, заданных вторым операндом. Освобождающиеся левые биты отбрасываются

Чтобы явно представить себе, как работают побитовые операции, обратимся к следующему примеру. Допустим, имеется 2 переменных - x и y:

var x, y: integer; ... x := 3; y := 5;

В двоичном представлении число 3 будет выглядеть как 0011, а 5 - как 0101. Теперь посмотрим, какие результаты даст каждая из побитовых операций сравнения и операции отрицания над этими числами:

x or y // Получим 7: 0011 | 0101 = 0111 x and y // Получим 1: 0011 & 0101 = 0001 x xor y // Получим 6: 0011 ^ 0101 = 0110 not x // Получим 12: ~0011 = 1100

Что касается операций побитового сдвига, то они дадут следующие результаты:

y shl 2 // Получим 20: 0101 shl 2 = 10100 y shr 2 // Получим 1: 0101 shr 2 = 01 -y shr 2 // Получим -2: -0101 shr 2 = -10

Теперь нам остается исследовать еще один тип операций - операции сравнения. Эти операции всегда требуют наличия двух операндов: они сравнивают значения левого и правого операндов, и возвращают результат сравнения в виде логического значения, которое может принимать значение false или true (ложь или истина). Все имеющиеся в Object Pascal операции сравнения приведены в таблице 3.7.

Таблица 3.7. Операции сравнения
Операция Название Описание Пример, дающий true
= Равно Возвращает истину (true), когда левый и правый операнды равны. 1=1
<> Не равно Возвращает истину, когда левый и правый операнды не равны. 1<>2
> Больше Возвращает истину, когда левый операнд больше правого. 2>1
< Меньше Возвращает истину, когда левый операнд меньше правого. 1<2
>= Больше или равно Возвращает истину, когда левый операнд больше правого или равен ему. 1>=0; 1>>1
<= Меньше или равно Возвращает истину, когда левый операнд меньше правого или равен ему. 0<=0; 0<=1

Операции сравнения могут работать с различными типами данных, включая строки, при этом для строк используется стандартный подход: символы последовательно сравниваются по своим ASCII-кодам, или Unicode-кодам, если используется строковая переменная в формате WideChar.

К операциям сравнения так же можно отнести операцию членства - in. При этом в качестве левого операнда может выступать данные ординарного типа (Byte или Char), а в качестве левого - подмножество значений, совместимых с данным типом. Например, если имеется переменная x типа Char, то можно проверить, является ли ее значение частью некоего набора символов:

var x: Char; z: Boolean; ... x := 'b'; z := x in [a..d];

В данном случае в качестве результата (z) мы получим истину, поскольку символ b является членом указанного множества [a..d], в которое входят символы a, b, c и d. Наконец, в Object Pascal имеется еще 2 операции - as и is. Они служат для приведения типа и проверки типа, соответственно. Например, если мы хотим проверить, является ли некая переменная "x" целым, то можно написать такое выражение:

b := x is Integer; // b получит значение true, если x - целое

Ну а операция as используется для приведения данных одного типа к другому, причем, преимущественно, при работе с объектами:

ObjA as ObjB;

При использовании операции as следует быть осторожным, поскольку приведение одного типа к другому возможно далеко не всегда.






Дата добавления: 2016-07-05; просмотров: 1142; ЗАКАЗАТЬ НАПИСАНИЕ РАБОТЫ


Поиск по сайту:

Воспользовавшись поиском можно найти нужную информацию на сайте.

Поделитесь с друзьями:

Считаете данную информацию полезной, тогда расскажите друзьям в соц. сетях.
Poznayka.org - Познайка.Орг - 2016-2019 год. Материал предоставляется для ознакомительных и учебных целей. | Обратная связь
Генерация страницы за: 0.018 сек.