Переменные бывают разных типов. Тип переменной определяет набор допустимых значений и операций. Типы делятся на простые, составные, строковые, варианты и классы.
Простые типы
Простые типы делятся на порядковые, вещественные и дата-время.
Порядковые типы имеют конечное множество возможных значений, их можно определенным образом упорядочить (отсюда и название) и сопоставить некоторое целое число.
Вещественные типы, строго говоря, тоже имеют конечное число значений, которое определяется форматом внутреннего представления вещественного числа. Однако количество возможных значений вещественных типов настолько велико, что сопоставить с каждым из них целое число (его номер) не представляется возможным.
Тип дата-время предназначен для хранения даты и времени. Фактически для этих целей он использует вещественный формат.
Порядковые типы
К порядковым типам относятся целые, логические, символьный и перечисляемый. К любому из них применима функция Ord(x), которая возвращает порядковый номер значения выражения X.
Вычисление значений переменной в цикле for
Для целых типов функция Ord(x) возвращает само значение х, т. е. Ord(X) = х для х, принадлежащего любому целому типу. Применение Ord(x) к логическому, символьному и перечисляемому типам дает положительное целое число в диапазоне от 0 до 1 (логический тип), от 0 до 255 (символьный), от 0 до 65535 (перечисляемый).
К порядковым типам можно также применять функции:
pred(x) — возвращает предыдущее значение порядкового типа, которое соответствует порядковому номеру ord (X) -1, т. е. Ord(Pred(X)) = Ord(X) — 1 ;
succ(X) — возвращает следующее значение порядкового типа, которое соответствует порядковому номеру ord (X) +1, т. е. Ord(Succ(X)) = Ord(X) + 1 .
Например, если в программе определена переменная:
var с : Char; begin с := ‘5’; end;
то функция Pred(C) вернет символ ‘4’, а функция Succ(C) — символ ‘6’.
Если представить себе любой порядковый тип как упорядоченное множество значений, возрастающих слева направо и занимающих на числовой оси некоторый отрезок, то функция pred(x) не определена для левого, a succ(X) – для правого конца этого отрезка.
Целые
Ниже приведена таблица поддерживаемых целых типов и диапазон допустимых значений:
| Тип данных | Длина, байт | Диапазон допустимых значений |
| Byte | 1 | 0 .. 255 |
| Shortint | 1 | -128 .. +127 |
| Smallint | 2 | -32 768 .. +32 767 |
| Word | 2 | 0 .. 65 535 |
| Integer | 4 | -2 147 483 648 .. +2 147 483 647 |
| Longint | 4 | -2 147 483 648 .. +2 147 483 647 |
| Cardinal | 4 | 0 .. 4 294 967 295 |
| LongWord | 4 | 0 .. 4 294 967 295 |
| Int64 | 8 | -9*10 18 .. +9*10 18 |
Вопросы на Интервью — Перестановка значений переменных местами
При использовании процедур и функций с целочисленными параметрами следует руководствоваться «вложенностью» типов, т. е. везде, где может использоваться Word, допускается использование Byte (но не наоборот), в Longint «входит» Smallint, который, в свою очередь, включает в себя Shortint.
Логические
Логический тип может принимать 2 значения: True или False. К логическим типам относят: Boolean, ByteBool, WordBool, LongBool. Первый тип является стандартным типом Паскаля, а последние три введены для совместимости с Windows. В данной реализации языка функция Ord вернет для True – 1, для False – 0.
В Pascal Script функция Ord для переменной типа Boolean также возвращает результат типа Boolean.
var b: Boolean; bb: ByteBool; begin b := True; bb := True; Debug(Ord(b)); // True Debug(Integer(Ord(b))); // 1 Debug(Ord(bb)); // 1 end;
Символьный
К символьному типу относится тип Char, вмещает в себя 1 байт, символы с кодом 0..255. Переменной этого типа можно присвоить один символ:
var c: Char; n: Byte; begin c := ‘A’; c := #65; // Код символа A n := Ord(‘E’); // Возвращает код символа end;
Для кодировки символов используется таблица ASCII . Первая половина символов от 0 до 127 является стандартной и приведена в таблице. Вторая половина от 128 до 255 зависит от шрифта.
Символы с кодами 0..31 относятся к служебным кодам. Если эти коды используются в символьном тексте программы, они считаются пробелами.
Перечисляемый тип
Перечисляемый тип задается перечислением тех значений, которые он может получать. Каждое значение именуется некоторым идентификатором и располагается в списке, обрамленном круглыми скобками, например:
type TColors = (Red, White, Blue); var Color: TColors; begin Color := Red; end;
Применение перечисляемых типов делает программы нагляднее. Соответствие между значениями перечисляемого типа и порядковыми номерами этих значений устанавливается порядком перечисления: первое значение в списке получает порядковый номер 0, второе — 1 и т. д. Максимальная мощность перечисляемого типа составляет 65536 значений, поэтому фактически перечисляемый тип задает некоторое подмножество целого типа Word и может рассматриваться как компактное объявление сразу группы целочисленных констант со значениями 0, 1 и т. д.
В Object Pascal присваивание переменным разных перечисляемых типов значений не своего типа приводит к ошибке несовместимости типов.
type TColors = (Red, Green, Blue); TNum = (One, Two, Three, Four); procedure Form_Create; var n: TNum; c: TColors; begin n := One; c := Four; // Несовместимость типов Debug(Ord(c)); // Значение 3 end;
Однако компилятор Pascal Script не увидит ошибку и код будет работать. Будьте внимательны.
Вещественные типы
В отличие от порядковых типов, значения которых всегда сопоставляются с рядом целых чисел и, следовательно, представляются в ПК абсолютно точно, значения вещественных типов определяют произвольное число лишь с некоторой конечной точностью, зависящей от внутреннего формата вещественного числа. Pascal Script поддерживает следующие вещественные типы:
| Тип данных | Длина, байт | Количество значащих цифр | Диапазон допустимых значений |
| Single | 4 | 7-8 | 1.5*10e-45 .. 3.4*10e38 |
| Double | 8 | 15-16 | 5.0*10e324 .. 1.7*10e308 |
| Extended | 10 | 19-20 | 3.4*10-4951 .. 1.1*10e4932 |
| Currency | 8 | 19-20 | +/-922 337 203 685 477,5807 |
В DataExpress числовые поля имеют тип Double.
Сравнение вещественных чисел
Из-за того, что вещественные числа хранят приблизительное значение числа, их нельзя проверять на равенство с числовыми константами. Для сравнения используйте функцию SameValue. Пример:
var d: Double; begin d := 0.2; // Это условие не выполнится if d = 0.2 then … // Можно так. Это условие выполнится if d – 0.2 < 0.001 then … // Так правильно сравнивать вещественные числа if SameValue(d, 0.2, 0) then … end;
Тип дата-время
Тип дата-время определяется стандартным идентификатором TDateTime и предназначен для одновременного хранения и даты, и времени. Во внутреннем представлении он занимает 8 байт и подобно Currency представляет собой вещественное число с фиксированной дробной частью: в целой части числа хранится дата, в дробной — время.
Дата определяется как количество суток, прошедших с 30 декабря 1899 года, а время — как часть суток, прошедших с 0 часов, так что значение 36444,837 соответствует дате 11.10.1999 и времени 20:05. Количество суток может быть и отрицательным, однако значения меньшие -693594 (соответствует дате 00.00.0000 от Рождества Христова) игнорируются функциями преобразования даты к строковому типу.
Над данными типа TDateTime определены те же операции, что и над вещественными числами, а в выражениях этого типа могут участвовать константы и переменные целого и вещественного типов. Например, можно без труда определить дату, отстоящую от заданной на сколько-то дней вперед или назад: для этого достаточно соответственно прибавить к заданной дате или отнять от нее нужное целое число. Например, оператор:
IbOutput.Caption := DateToStr(Date + 21);
поместит в метку IbOutput дату, соответствующую текущей дате плюс 3 недели. Чуть сложнее с исчислением времени. Например, чтобы добавить к текущему времени полтора часа, следует использовать выражение:
Time + StrToTime(‘1:30’)
Time+1.5/24
Составные типы
К составным типам относятся: массивы, записи и множества. Они характеризуется множественностью образующих этот тип элементов. Каждый элемент, в свою очередь, может принадлежать структурированному типу, что позволяет говорить о возможной вложенности типов.
В Object Pascal допускается произвольная глубина вложенности типов, однако суммарная длина любого из них во внутреннем представлении не должна превышать 2 Гбайт (в реализации от RemObjects не проверялось).
Строковые типы
Строки представлены типами String, AnyString, AnsiString, WideString и PChar. Для всех типов строк, кроме PChar, память выделяется динамически, по мере необходимости. Типы String, AnyString, AnsiString являются синонимами. Тип String можно представить, как массив символов. Подобно массиву можно обращаться к отдельным символам строки по их индексу. Первый символ строки имеет индекс 1. Примеры работы со строками:
var S: String; begin S := ‘hello, World’; // Строка в кодировке UTF-8 S[1] := ‘H’; // Меняем h на H. Индекс первого символа равен 1. S := S + ‘. ’; // Сложение строк. S := ‘Привет, МИР. ’; // Строка в кодировке UTF-8 Debug(S[1]); // Будет выведен знак «?», потому что для кодирования символов // кириллицы требуется более одного байта.
end;
Строка может хранить данные в кодировке ANSI или UTF-8. В кодировке ANSI символ занимает 1 байт. Символ в кодировке UTF-8 может занимать от 1 до 4 байт. Если строка хранит данные в этой кодировке, то обращение к элементам массива строки уместно только, если обрабатываются символы первой половины таблицы ASCII с кодами от 1 до 127.
В ином случае нужно применять функции для работы со строками UTF-8. Для символов, кодируемых более чем одним байтом, в UTF-8 принята следующая система кодировки: в первом байте от двух до четырёх старших битов заняты единицами — их количество соответствует количеству байт в символе, во втором и последующих байтах первые два бита заняты соответственно единицей и нулём. В символах кодируемых одним байтом старший бит всегда занят нулём. Таким образом, при побайтном рассмотрении строки, однобайтный символ не может быть случайно принят за часть многобайтного.
UTF-8 является основной кодировкой, база данных и скрипты используют именно эту кодировку.
К строкам применимы операции сравнения. Сравнение происходит посимвольно.
S := ‘Hello World’; S2 := ‘Hello world’; // Условие ложно, потому что W <> w if S = S2 then … // Условие истинно, потому что W < wif S < S2 then …
Тип WideString хранит строки в кодировке UTF-16. Каждый символ кодируется двумя байтами (за исключением символов с номерами больше FFFF — для обозначения таких символов используется четыре байта). Несмотря на то, что каждый символ занимает 2 байта, вы можете обратиться к символу по индексу, как если бы для кодирования использовался 1 байт. Строки этого типа используются OLE-объектами и функциями Windows API .
var S: WideString; begin S := ‘Hello, МИР. ’; Debug(S[8]); // Символ «М» end;
Символы, кодируемые четырьмя байтами всегда состоят из пары двухбайтовых слов (т.наз. «суррогатной пары»), первое из которых принадлежит диапазону D800..DBFF, а второе — диапазону DC00..DFFF. Символы, кодируемые двумя байтами не могут входить ни в один из этих диапазонов. Что позволяет при посимвольном обходе строки легко отличать двухбайтовые символы от частей четырёхбайтовых
Тип PChar представляет строки с завершающим нулем. Переменная типа PChar содержит указатель на массив строк. Концом строки считается символ с кодом #0. В чистом виде тип PChar не используется, т. к. Pascal Script не работает с указателями. Предположительно, он введен только для совместимости с функциями Windows API .
Pascal Script автоматически преобразует строку из одного типа в другой, так что работа со строками разных типов является прозрачной для разработчика.
Варианты
Переменная вариантного типа может принимать хранить значение следующих типов: целый, вещественный, логический, строка, дата-время, OLE-объект. Вариант представляет собой структуру, в которой хранятся сведения о типе и значении переменной. В выражениях и при передаче параметров в процедуры происходит попытка преобразования варианта к нужному типу. Если это не удается, будет ошибка “invalid variant type cast”. Вариант может хранить специальное значение Null (пусто, неизвестно).
Любая арифметическая операция с null даст в результате null. Попытка автоматического преобразования null к какому-либо типу (кроме Variant) приведет к ошибке ‘could not convert variant of type (Null) into type (…)’.
var V1, V2, V3, V4, V5: Variant; begin V1 := 1; V2 := ‘4’; V3 := V + V2; // Результат 5 или ‘5’ V4 := V3 + Null; // V4 = Null V5 := V1 + ‘sdfsdf’; // invalid variant type cast MsgBox(‘Сообщение’, V4); // Could not convert variant of type (Null) into type (String) end;
Варианты широко используются при работе с OLE-объектами. С помощью специальных функций можно узнать значение какого типа хранится в варианте или преобразовать значение к нужному типу.
Источник: dataexpress.wiki
Поиск правильных ответов
В заданном фрагменте программы переменная 
примет значение, равное …
✓
Решение:
Значение 
определяется в зависимости от значений переменных 
и 
. Если в сложном условии используется операция логического сложения (or), то оно является истинным, когда истинно хотя бы одно входящее в него простое условие. Следовательно, условие в заданном фрагменте программы является верным и 
.
Основы информатики : учеб. / В. Ф. Ляхович, С. О. Крамаров, И. П. Шамараков. – 7-е изд. – Ростов н/Д : Феникс, 2008. – 715 с. – (Рекомендовано Министерством образования РФ в качестве учеб. для студентов сред. спец. учеб. заведений).
Источник: ruotvet.ru
Объявляем переменные,
вычисляем выражения
Операторы +=, -=, *=,/=, ++, —
Каждая программа что-нибудь вычисляет. Это может быть все что угодно — координаты персонажа в игре, сумма расходов, количество букв в тексте и т.д. Для всех вычислений используются переменные и числовые выражения.
Пусть вам нужно что-то рассчитать. Например, вы хотите примерно оценить сумму своих расходов за год по разным категориям — на продукты, одежду и транспорт. Причем вы знаете, что одежду вы покупаете в год 5 раз, продукты два раза в неделю, а транспортом пользуетесь каждый день, и знаете среднюю стоимость разовой покупки.
Это можно закодить так:
// Объявим по одной переменной для каждого вида расходов // Слева от равно пишем double — значит у нас будет дробное число // transp — имя переменной, мы его выбрали сами // Справа от равно — начальное значение double transp = 100; // на транспорт за один день тратим порядка 100 рублей double food = 500; // на еду за один заход в магазин в среднем 500 рублей double dress = 2000; // на одежду — 2000 //Начальное значение переменной result вычислим по выражению: double result = transp*365 + food*2*4*12 + dress*5; // То есть 365 раз за год потратились на транспорт, // еду покупали 2 раза в неделю, а недель 4 в месяце, а месяцев 12, // одежду купили 5 раз в год. // Теперь переменная result хранит сумму затрат за год — можно ее распечатать, // сравнить с другими переменными или использовать в дальнейших расчетах. // Удобно, что теперь мы можем менять значения исходных данных, // и смотреть, как это отразится на итоговом результате.
Определение. Переменная – это имя, которое обозначает некоторое число. Переменные могут получать начальное значение и потом менять его. У переменных есть тип – либо это целые числа ( int ), либо дробные ( double и float), либо символы ( char ). Переменные участвуют в любых выражениях наравне с обычными числами.
Объявить переменную — значит дать ей имя, указать, какого она типа, и указать начальное значение справа от знака равно. В коде это делается так:
int x = 10;
Это значит завести переменную с именем x , у которой тип – int , сокращенно от integer (по-английски «целое число»). Справа от знака равно ставится начальное значение переменной. Оно может быть просто равно заданному числу, например, 10, а может вычисляться через любое выражение.
В общем случае объявление переменной выглядит так:
тип имя = числовое выражение ;
Типы данных бывают такие – целое число int , дробное число double , символ char . Переменная — это имя, обозначающее заданное число. Вы можете это число по ходу программы менять. Как только вы объявили переменную, под неё выделяется место в оперативной памяти компьютера — ячейка. В ней записаны цифры данного числа в двоичной системе исчисления, где вместо привычных цифр 0, 1, 2, …, 9 есть только цифры 0 и 1.
Давайте поменяем значение переменной x вот так:
int x = 10; x = 200; //изменить значение икс — забыть 10, и запомнить 200 //слева int не указан, значит мы используем уже объявленную переменную
Разберем популярную ошибку — объявление одной и той же переменной дважды:
int x = 100; int x = 300; // ошибка — указав int, мы говорим «объявить новую x», но переменная x уже объявлена // Создадим другую переменную с именем y int y = 100; // Объявим ее еще раз с другим типом double y = 200.5; // ошибка — переменная y уже была раньше объявлена. // Теперь, когда мы указали новый тип, компилятор просто не может определиться, // что же имелось в виду, y — целое, или y — дробное. Вы можете получить ошибку // ambiguous name, то есть многозначное имя.
Посмотрим новый пример с несколькими переменными. Кстати я пишу, что делает очередная строчка в комментарии к ней. Комментарии не исполняются в программе, в них можно просто пояснять код. Комментарии на одну строчку в Java обозначаются // , а также внутри блока /* Можно писать всё что угодно */ — это комментарий на много строчек. Вы легко опознаете комментарии, когда увидите их в этом коде:
package javaapplication1; public class JavaApplication1 < public static void main(String[] args) < //вызовем функцию println System.out.println («Щас будем вычислять!»); // Объявим переменную x целого типа, равную 10 int x = 10; // Объявим переменную y целого типа, равную 30 int y = 30; // Объявим переменную z, равную выражению: int z = x + y /2; // Распечатаем значение z – это будет 25 System.out.println (z); // Изменим z снова, пусть оно будет теперь x/2 z = x / 2; // Выведем на экран новое значение z – это будет 5 System.out.println (z); // Можно объявить несколько переменных в одной строчке int a = 10, b = 20; /* В принципе можно объявить переменную без начального значения, но Java ударит вас по рукам, если вы позже не присвоите ей значение. Лучше так не делать, потому что от переменных без начального значения пользы никакой, а навредить они могут сильно – если вдруг Java не заметит, что вы её используете, то вы получите непредсказуемое поведение программы, каждый раз разное – эту ошибку очень сложно отловить, иногда на её поиск уходят недели. */ int w; // Лучше не надо, поверьте.. w = 5; // Объявим переменную дробного типа double double some = 0.5; // Изменим значение переменной some на новое some = 1.5; // Сделаем some равной y some = y; // Объявим символ с равным коду буквы b char c = ‘b’; /* Здесь можно писать только одну букву или цифру в одинарных кавычках.
Символы нельзя складывать, зато из них можно делать строки и тексты – мы займемся этим на следующих уроках*/ // Объявим дробное d, равное 2.5 double d = 2.5; /* Используем саму переменную, чтобы например, увеличить ее на 5: */ d = d + 5; // теперь d равно 7.5, старое значение забыто >/* В конце переменные, объявленные в main, удаляются — так происходит всегда по достижении конца блока фигурных скобок, внутри которого они были объявлены */ > /* По сути переменная – это число, записанное в ячейке памяти компьютера. Объявить переменную – значит назвать эту ячейку именем.
Имя может быть одной буквой, а может быть и словом. Вы можете поменять число, сидящее в ячейке, или использовать его для вычисления других чисел. Это очень удобно, иначе вам пришлось бы указывать «вон то число», а потом «вот это число», чтобы сделать любые вычисления.
Так писали программы в 80ых годах прошлого века – это было настолько неудобно, что элементарный калькулятор приходилось писать месяцами. Теперь, заводя переменные, мы пишем его за несколько минут. */
Привычные нам знаки арифметических действий +, — , * , / называются операторами, они служат для простых вычислений. Знак = тоже оператор и означает приравнять , то есть изменить старое значение переменной на новое. Но есть еще операторы +=, -= , *= , /= . Они читаются увеличить (уменьшить, умножить, поделить) переменную на значение справа. Рассмотрим пример ниже:
int x = 10; // Увеличим x на 10 x = x + 10; // Ту же фразу можно записать короче с оператором += x += 10;
То есть оператор += является просто сокращением и означает увеличить переменную на значение, стоящее справа. Аналогично, операторы -=, *=, /= вычитают, умножают, делят переменную на значение, стоящее справа, например:
double y = 12; double z = 3; // Поделим y на 3 и запишем новое значение в y y /= z; // Умножим на 4, затем на (z-2) y *= 4; y *= z-2; /* Все это допустимые операции, их удобно делать с операторами +=, -=, *=, /= */
Ещё операцию x += 1 тоже можно записать короче с помощью оператора инкремента ++ . То есть ++ означает «увеличить переменную на один». Аналогично — значит «уменьшить на 1». Посмотрим в коде:
int x = 10; x ++; // теперь x равен 11 x ++; // теперь x равен 12 x —; // теперь x снова 11
Можно писать x++ (постфиксный инкремент), а можно ++x (префиксный инкремент). Аналогично и с декрементом. Если эти операции стоят в коде отдельно от прочих, то оба варианта записи эквивалентны, они увеличивают x на 1. Если же x++ используется прямо в выражении, то разница есть . Поясним в коде:
int a = 10; // зададим a и b равным 10 int b = 10; // a++ означает в выражении использовать старое значение a, но в потом a увеличить int y = 5 + a++; // итого будет 5+10 // ++b означает уже в выражении увеличить b int z = 5 + ++b; // итого будет 5 + 11 System.out.println (a); System.out.println (b); System.out.println (y); System.out.println (z); /* Вывод программы: 11 11 15 16 */
Ещё поясняющий пример:
// вариант с использованием x ++ // постфиксная запись, как бы «увеличить x после» выражения int x = 10; int y = 5 + x++; // будет эквивалентно следующему: int x = 10; int y = 5 + x; // в выражении старое значение x += 1; // уже после выражения мы увеличим x // а теперь то же самое с использование x— // префиксная запись, как бы «увеличить перед» выражением int x = 10; int y = 5 + ++x; // будет эквивалентно следующему: int x = 10; x += 1; // перед выражением мы увеличим x int y = 5 + x; // в выражении новое увеличенное значение // Начинающим обучение можно лишний раз не думать об разнице x++, ++x // Просто не пишите их прямо в выражения, и считайте, что это просто «увеличить на 1» // Но если где-то встретите, то будете готовы 🙂
Более сложные выражения с участием скобок (. )
Скобки позволяют указать программе, что нужно в выражении вычислить раньше, а что потом. Выражения в скобках имеют абсолютный приоритет — сначала вычисляется то что в скобках, потом умножение и деление, потом уже сложение и вычитание. Разберёмся в приоритетах на примере:
double x = 10 + 5 * 2 — 3; // будет конечно 10+10-3, то есть 17 double y = (10 + 5) * 2 — 3; // теперь есть скобки , поэтому 15*2 — 3, то есть 27 double z = 100 / 4 * 2 + 5; // при равнозначном приоритете компилятор читает слева направо: // получится 100/4 — это 25, умножить на 2 — это 50, и добавить 5 — в итоге z=55 // Очень советую поэкспериментировать в коде с такими выражениями. // Усложняйте их постепенно, используйте старые значения переменной в новом выражении. // Несколько полезных примеров: z = z*z; // получается, возвести z в квадрат, // поскольку мы взяли старое значение, умножили его само на себя и записали в z. // Аналогично можно возвести в куб и вообще в любую степень: x = x*x*x ; // возвели x в куб. // Также можно получить обратную к исходной величину: x = 1 / x; // но помните, что если бы x был int, а не double, // то тут часто получался бы чистый ноль, // т.к. при делении целых дробные части отбрасываются. // Теперь пример на несколько скобок x = 10; x = (x + 10) / 2 — 5 * (x-2); // будет 20 / 2 — 5 * 8, то есть -30. // А также вложенные скобки: x = 10; x = (x + 5*(x-1) ) * 2 + 1; // будет (10 + 5 * 9) * 2 + 1 = 55 * 2 + 1 = 111.
Самое главное мы уже освоили. Теперь время решать задачи. Ответьте на несколько вопросов, чтобы лучше усвоился новый материал:
Источник: progtoday.ru