Описания и константы


Содержание

Переменные и константы в языке программирования Паскаль

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

Переменная — это именованная величина определенного типа, способная в процессе работы программы менять свое значение.

Обычно переменная получает текущее значение в результате выполнения оператора присваивания (например, s := 0 – переменной s присваивается значение 0). Это значение будет сохраняться до тех пор, пока этой переменной не будет присвоено новое значение (при этом предыдущее значение теряется безвозвратно!)

Важно: попытка присвоить переменной значение иного типа является ошибкой.

Описание переменных

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

  • список имен: тип;
  • или
  • имя: тип := выражение;
  • или
  • имя: тип = выражение; // для совместимости с Delphi
  • или
  • имя := выражение;

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

  • var
  • a1, a2, a3: integer;
  • p: real := 5.7;
  • str := ‘PascalABC.NET’;
  • k := 1;

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

PascalABC.NET позволяет описывать переменные внутри составного оператора begin-end в специальном операторе описания переменной. Такие описания называются внутриблочными. Для внутриблочного описания можно использовать формы приведенные выше. Например:

  • begin
  • var a1,a2,a3: integer;
  • var p: real := 2.5;
  • var str := ‘ ‘;
  • end;

Описание констант

Константы – это элементы данных, значения которых устанавливаются в разделе описаний и не изменяются в процессе выполнения программы

Раздел описания именованных констант в языке программирования Паскаль начинается с ключевого слова const после которого следуют описания в следующих формах:

  • имя константы = значение;
  • или
  • имя константы : тип = значение;
  • const
  • MaxLen = 100;
  • Pi = 3.14;
  • g = 9.8;
  • Day = ‘Sunday’;

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

Copyright © 2014-2020, Урок информатики
Все права защищены

Синтаксис описания констант и переменных.

Алфавит языка.

Алфавит C++ включает: 1) прописные и строчные латинские буквы и знак подчеркивания; 2)арабские цифры от О до 9; 3) специальные знаки; 4) пробельные символы: пробел, символы табуляции, символы перехода на новую строку.

Из символов алфавита формируются лексемы языка: 1)идентификаторы; 2)ключевые (зарезервированные) слова; 3)знаки операций; 4)константы; 5)разделители (скобки, точка, запятая, пробельные символы).


Границы лексем определяются другими лексемами, такими, как разделители или

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

Идентификатор — это имя программного объекта. В идентификаторе могут использоваться латинские буквы, цифры и знак подчеркивания. Первым символом идентификатора может быть буква или знак подчеркивания, но не цифра. Пробелы внутри имен не допускаются. Длина идентификатора по стандарту не ограничена. Идентификатор создается на этапе объявления переменной, функции.

При выборе идентификатора необходимо иметь в виду следующее: 1) идентификатор не должен совпадать с ключевыми словами и именами используемых стандартных объектов языка; 2)не рекомендуется начинать идентификаторы с символа подчеркивания; 3) на идентификаторы, используемые для определения внешних переменных, налагаются ограничения компоновщика.

Ключевые слова и символы.

Ключевые слова — это зарезервированные идентификаторы, которые имеют специальное значение для компилятора. Их можно использовать только в том смысле, в котором они определены. Список ключевых слов C++ приведен в табл. 1.1.

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

Знак операции — это один или более символов, определяющих действие над операндами. Внутри знака операции пробелы не допускаются. Операции делятся на унарные, бинарные и тернарную по количеству участвующих в них операндов. Один и тот же знак может интерпретироваться по-разному в зависимости от контекста. Все знаки операций за исключением [ ], ( ) и ? : представляют собой отдельные лексемы. Знаки представлены в таблице 1.2.

Ключевые слова С++

asm auto bool break case catch char class const const_cast continue default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new operator private protected public register reinterpret_cast return short signed sizeof static static__cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while
Бинарные, тернарные и унарные операции:
+ Бинарный плюс
бинарный минус
* умножение
/ деление (при делении двух целых чисел получается целая часть от частного)
% получение остатка от деления
> сдвиг вправо
больше
>= больше или равно
== равно
!= не равно
&& логическое И
|| логическое ИЛИ
& операция взятия адреса
* операция обращения по адресу
унарный минус
+ унарный плюс
! отрицание
++ автоувеличение на 1
— — автоуменьшение на 1
sizeof операция вычисления размера в байтах

Синтаксис описания констант и переменных.

Константами называют неизменяемые величины. Различаются целые, вещественные, символьные и строковые константы. Компилятор, выделив константу в качестве лексемы, относит ее к одному из типов по ее внешнему виду.

Если требуется сформировать отрицательную целую или вещественную константу, то перед константой ставится знак унарной операции изменения знака (-), например: -218,-022, -ОхЗС, -4.8, -0.1е4.

Вещественная константа в экспоненциальном формате представляется в виде мантиссы и порядка. Мантисса записывается слева от знака экспоненты (Е или е), порядок — справа от знака. Значение константы определяется как произведение мантиссы и возведенного в указанную в порядке степень числа 10. Обратите внимание, что пробелы внутри числа не допускаются, а для отделения целой части от дробной используется не запятая, а точка.

Символьные константы, состоящие из одного символа, занимают в памяти один байт и имеют стандартный тип char. Двухсимвольные константы занимают два байта и имеют тип int, при этом первый символ размещается в байте с меньшим адресом (о типах данных рассказывается в следующем разделе).

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

• кодов, не имеющих графического изображения (например, \а — звуковой сигнал, \п — перевод курсора в начало следующей строки);

• символов апострофа ( ‘ ), обратной косой черты (\), знака вопроса ( ? ) и кавычки (“);

• любого символа с помощью его шестнадцатеричного или восьмеричного кода, например, \073, \0xF5. Числовое значение должно находиться в диапазоне от О до 255.

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

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

«Издательский дом \»Питер\»»

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

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

int а; float х;

Общий вид оператора описания переменных:

[класс памяти] [const] тип имя [инициализатор];

Рассмотрим правила задания составных частей этого оператора: 1) необязательный класс памяти может принимать одно из значений auto, extern, static и register; 2) модификатор const показывает, что значение переменной изменять нельзя. Такую переменную называют именованной константой, или просто константой; 3) при описании можно присвоить переменной начальное значение, это называется инициализацией. Инициализатор можно записывать в двух формах — со знаком равенства:

= значение или в круглых скобках: ( значение ).

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

short int а = 1; // целая переменная а const char С = ‘ С ; // символьная константа С char s. sf = ‘f’; // инициализация относится только к sf char t (54); float с = 0.22. x(3). sum;

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

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

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

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

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

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

Время жизни может быть постоянным (в течение выполнения программы) и временным (в течение выполнения блока).

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

Для задания класса памяти используются следующие спецификаторы:

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

extern — означает, что переменная определяется в другом месте программы (в другом файле или дальше по тексту). Используется для создания переменных, доступных во всех модулях программы, в которых они объявлены i. Подробнее об употреблении внешних переменных рассказывается в разделе «Внешние объявления».

static — статическая переменная. Время жизни — постоянное. Инициализируется один раз при первом выполнении оператора, содержащего определение переменной. В зависимости от расположения оператора описания статические переменные могут быть глобальными и локальными. Глобальные статические переменные видны только в том модуле, в котором они описаны.

register — аналогично auto, но память выделяется по возможности в регистрах процессора. Если такой возможности у компилятора нет, переменные обрабатываются как auto.

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

Описание переменной может выполняться в форме объявления или определения.

Объявление информирует компилятор о типе переменной и классе памяти, а определение содержит, кроме этого, указание компилятору выделить память в соответствиис типом переменной. В C++ большинство объявлений являются одновременнои определениями. Переменная может быть объявлена многократно, но определена только в одномместе программы, поскольку объявление просто описывает свойства переменной,а определение связывает ее с конкретной областью памяти.

Основные типы данных.

Основные (стандартные) типы данных часто называют арифметическими, поскольку их можно использовать в арифметических операциях. Для описания основных типов определены следующие ключевые слова: 1) int (целый); 2) char (символьный); 3) wchar_t (расширенный символьный); 4) bool (логический); 5) float (вещественный); 6) double (вещественный с двойной точностью).

Первые четыре типа называют целочисленными (целыми), последние два — типами с плавающей точкой. Код, который формирует компилятор для обработкицелых величин, отличается от кода для величин с плавающей точкой.

Существует четыре спецификатора типа, уточняющих внутреннее представление и диапазон значений стандартных типов: 1) short (короткий); 2) long (длинный); 3) signed (знаковый); 4) unsigned (беззнаковый).

1) Целый тип (int)

Размер типа int не определяется стандартом, а зависит от компьютера и компилятора. Для 16 разрядного процессора под величины этого типа отводится 2 байта, для 32-разрядного — 4 байта. Спецификатор short перед именем типа указывает компилятору, что под число требуется отвести 2 байта независимо от разрядности процессора.


Спецификатор long означает, что целая величина будет занимать 4 байта. Таким образом, на 16-разрядном компьютере эквиваленты int и short int, а на 32-разрядном — int и long int.

Внутреннее представление величины целого типа — целое число в двоичном коде. При использовании спецификатора signed старший бит числа интерпретируется как знаковый (О — положительное число, 1 — отрицательное).

Спецификатор unsigned позволяет представлять только положительные числа, поскольку старший разряд рассматривается как часть кода числа. Таким образом, диапазон значений типа int зависит от спецификаторов.

По умолчанию все целочисленные типы считаются знаковыми, то есть спецификатор signed можно опускать. Константам, встречающимся в программе, приписывается тот или иной тип в соответствии с их видом. Если этот тип по каким-либо причинам не устраивает программиста, он может явно указать требуемый тип с помощью суффиксов L, l (long) и U, u (unsigned). Например, константа 32L будет иметь тип long и занимать 4 байта. Можно использовать суффиксы L и U одновременно, например, Ox22UL или 05LU.

2) Символьный тип (char)

Под величину символьного типа отводится количество байт, достаточное для размещения любого символа из набора символов для данного компьютера, что и обусловило название типа. Как правило, это 1 байт. Тип char, как и другие целые типы, может быть со знаком или без знака. В величинах со знаком можно хранить значения в диапазоне от -128 до 127. При использовании спецификатора unsigned значения могут находиться в пределах от О до 255. Этого достаточно для хранения любого символа из 256-символьного набора ASCH. Величины типа char применяются также для хранения целых чисел, не превышающих границы указанных диапазонов.

3) Расширенный символьный тип (wchar_t)

Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта, например, Unicode. Размер этого типа зависит от реализации; как правило, он соответствует типу short. Строковые константы типа wchar_t записываются с префиксом L, например, L»Gates».

Илон Маск рекомендует:  Принципы функционирования sram

4) Логический тип (bool)

Величины логического типа могут принимать только значения true и false, являющиеся зарезервированными словами. Внутренняя форма представления значения false — О (нуль). Любое другое значение интерпретируется как true. При преобразовании к целому типу true имеет значение 1.

5) Типы с плавающей точкой (float, double и long double)

Стандарт C++ определяет три типа данных для хранения вещественных значений: float, double и long double. Типы данных с плавающей точкой хранятся в памяти компьютера иначе, чем целочисленные. Внутреннее представление вещественного числа состоит из двух частей — мантиссы и порядка. В IBM PC-совместимых компьютерах величины типа float занимают 4 байта, из которых один двоичный разряд отводится под знак мантиссы, 8 разрядов под порядок и 23 под мантиссу. Мантисса — это число, большее 1.0, но меньшее 2.0. Поскольку старшая цифра мантиссы всегда равна 1, она не хранится.

Для величин типа double, занимающих 8 байт, под порядок и мантиссу отводится 11 и 52 разряда соответственно. Длина мантиссы определяет точность числа, а длина порядка — его диапазон. Как можно видеть из табл. 1.4, при одинаковом количестве байт, отводимом под величины типа float и long int, диапазоны и допустимых значений сильно различаются из-за внутренней формы представления.

Спецификатор long перед именем типа double указывает, что под величину отводится 10 байт. Константы с плавающей точкой имеют по умолчанию тип double. Можно явно указать тип константы с помощью суффиксов F, f (float) и L, 1 (long). Например, константа 2E+6L будет иметь тип long double, а константа 1.82f — тип float.

Подробное изложение теоретических вопросов, затронутых в первой лекции, можно найти в литературе [1, 3]. Практические аспекты этих вопросов можно отыскать в работах [2, 4,5,6,7,8].

Знания следует самостоятельно проверить путем ответов на контрольные вопросы.

Список использованной литературы:

а) основная литература:

1. Т, А. Павловская C/C++ Программирование на языке высокого уровня. Год издания: 2012.

2. Литвиненко Н. А. — Технология программирования на С++. Год издания: 2013. Издательство: БХВ-Петербург.

б) дополнительная литература:

3. Коплиен Дж. — Мультипарадигменное проектирование для с++.

4. Богуславский Ан.А., Соколов С.М. Основы программирования на языке Си++: Для студентов физико-математических факультетов педагогических институтов. Часть I. Введение в программирование на языке Си++. — Коломна: КГПИ, 2012. — 490 с.

5. Дейтел Х.М, Дейтел П.Д. Как программировать на С: пер. с англ. – М.: БИНОМ, 2014.— 908 с.: ил.

6. Шилдт Г. Полный справочник по C++: Пер. с англ. – М.: Вильямс, 2013 .— 699 с.

7. Подбельский В.В. Язык Си++: учебное пособие для вузов.

8. Степанов Е.О., Чириков С.В. Стиль программирования на C++. Учебное пособие. — СПб.: СПбГИТМО(ТУ), 2015. — 48 с.

| следующая лекция ==>
А) спорт как средство удовлетворения зрелищных запросов человека; |

Дата добавления: 2020-12-05 ; просмотров: 697 | Нарушение авторских прав

Константы

Константы с Плавающей Точкой

C++ дает возможность записи значений основных типов: символьных констант, целых констант и констант с плавающей точкой. Кроме того, ноль (0) может использоваться как константа любого указательного типа, и символьные строки являются константами типа char[]. Можно также задавать символические константы. Символическая константа — это имя, значение которого не может быть изменено в его области видимости. В C++ имеется три вида символических констант:

любому значению любого типа можно дать имя и использовать его как константу, добавив к его описанию ключевое слово const;

множество целых констант может быть определено как перечисление;

любое имя вектора или функции является константой.

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

1234 976 12345678901234567890

Д есятичная константа имеет тип int, при условии, что она влезает в int, в противном случае ее тип long. Компилятор должен предупреждать о константах, которые слишком длинны для представления в машине.

К онстанта, которая начинается нулем за которым идет x (0x), является шестнадцатиричным числом (с основанием 16), а константа, которая начинается нулем за которым идет цифра, является восьмеричным числом (с основанием 8). Вот примеры восьмеричных констант:

02 077 0123

их десятичные эквиваленты — это 0, 2, 63, 83. В шестнадцатиричной записи эти константы выглядят так:

0x0 0x2 0x3f 0x53

Б уквы a, b, c, d, e и f, или их эквиваленты в верхнем регистре, используются для представления чисел 10, 11. 12, 13, 14 и 15, соответственно. Восьмеричная и шестнадцатиричная записи наиболее полезны для записи набора битов; применение этих записей для выражения обычных чисел может привести к неожиданностям. Например, на машине, где int представляется как двоичное дополнительное шестнадцатеричное целое, 0xffff является отрицательным десятичным числом -1; если бы для представления целого использовалось большее число битов, то оно было бы числом 65535.

Константы с Плавающей Точкой

К онстанты с плавающей точкой имеют тип double. Как и в предыдущем случае, компилятор должен предупреждать о константах с плавающей точкой, которые слишком велики, чтобы их можно было представить. Вот некоторые константы с плавающей точкой:

1.23 .23 0.23 1. 1.0 1.2e10 1.23e-15

З аметьте, что в середине константы с плавающей точкой не может встречаться пробел. Например, 65.43 e-21 является не константой с плавающей точкой, а четырьмя отдельными лексическими символами (лексемами):

и вызовет синтаксическую ошибку.
Е сли вы хотите иметь константу с плавающей точкой типа float, вы можете определить ее так :

const float pi = 3.14159265;

Х отя в C++ и нет отдельного символьного типа данных, точнее, символ может храниться в целом типе, в нем для символов имеется специальная и удобная запись. Символьная константа — это символ, заключенный в одинарные кавычки; например, «a» или «0». Такие символьные константы в действительности являются символическими константами для целого значения символов в наборе символов той машины, на которой будет выполняться программа (который не обязательно совпадает с набором символов, применяемом на том компьютере, где программа компилируется). Поэтому, если вы выполняетесь на машине, использующей набор символов ASCII, то значением «0» будет 48, но если ваша машина использует EBCDIC, то оно будет 240. Употребление символьных констант вместо десятичной записи делает программу более переносимой. Несколько символов также имеют стандартные имена, в которых обратная косая \\ используется как escape-символ:

«\\b» возврат назад
«\\f» перевод формата
«\\n» новая строка
«\\r» возврат каретки
«\\t» горизонтальная табуляция
«\\v» вертикальная табуляция
«\\\\» обратная косая (обратный слэш)
«\\»» одинарная кавычка
«\\»» двойная кавычка
«\\0» null, пустой символ, целое значение 0

В опреки их внешнему виду каждое является одним символом. Можно также представлять символ одно-, дву- или трехзначным восьмеричным числом (символ \\, за которым идут восьмеричные цифры), или одно-, дву- или трехзначным шестнадцатиричным числом (\\x, за которым идут шестнадцатиричные цифры). Например:

«\\6» «\\x6» 6 ASCII ack
«\\60» «\\x30» 48 ASCII «0»
«\\137» «\\x05f» 95 ASCII «_»

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


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

К аждая строковая константа содержит на один символ больше, чем кажется; все они заканчиваются пустым символом «\\0» со значением 0.

С трока имеет тип «вектор из соответствующего числа символов», поэтому «asdf» имеет тип char[5]. Пустая строка записывается «» (и имеет тип char[1]). Заметьте, что для каждой строки s strlen(s)==sizeof(s)-1, поскольку strlen() не учитывает завершающий 0.
Соглашение о представлении неграфических символов с обратной косой можно использовать также и внутри строки. Это дает возможность представлять в строке двойные кавычки и escape-символ \\. Самым обычным символом этого рода является, безусловно, символ новой строки «\\n».

cout В строке невозможно иметь «настоящую» новую строку:

«это не строка,
а синтаксическая ошибка»

О днако в строке может стоять обратная косая, сразу после которой идет новая строка; и то, и другое будет проигнорировано.

cout Н овая строка, перед которой идет escape (обратная косая), не приводит к появлению в строке новой строки, это просто договоренность о записи.

В строке можно иметь пустой символ, но большинство программ не будет предполагать, что есть символы после него. Например, строка «asdf\\000hjkl» будет рассматриваться стандартными функциями, вроде strcpy() и strlen(), как «asdf».

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

char v1[] = «a\\x0fah\\0129»; // «a» «\\xfa» «h» «\\12» «9»
char v2[] = «a\\xfah\\129»; // «a» «\\xfa» «h» «\\12» «9»
char v3[] = «a\\xfad\\127»; // «a» «\\xfad» «\\127»

И мейте в виду, что двузначной шестнадцатиричной записи на машинах с 9-битовым байтом будет недостаточно.

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

К лючевое слово const может добавляться к описанию объекта, чтобы сделать этот объект константой, а не переменной.

const int model = 145;
const int v[] = < 1, 2, 3, 4 >;

П оскольку константе ничего нельзя присвоить, она должна быть инициализирована. Описание чего-нибудь как const гарантирует, что его значение не изменится в области видимости:

model = 145; // ошибка
model++; // ошибка

З аметьте, что const изменяет тип, то есть ограничивает способ использования объекта, вместо того, чтобы задавать способ размещения константы. Поэтому например вполне разумно, а иногда и полезно, описывать функцию как возвращающую const:

const char* peek(int i)
<
return private[i];
>

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

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

И спользование указателя вовлекает два объекта: сам указатель и указываемый объект. Снабжение описания указателя «префиксом» const делает объект, но не сам указатель, константой.

const char* pc = «asdf»; // указатель на константу
pc[3] = «a»; // ошибка
pc = «ghjk»; // ok

Ч тобы описать сам указатель, а не указываемый объект, как константный, используется операция const*.

char *const cp = «asdf»; // константный указатель
cp[3] = «a»; // ok
cp = «ghjk»; // ошибка

Ч тобы сделать константами оба объекта, их оба нужно описать const.

const char *const cpc = «asdf»; // const указатель на const
cpc[3] = «a»; // ошибка
cpc = «ghjk»; // ошибка

О бъект, являющийся константой при доступе к нему через один указатель, может быть переменной, когда доступ осуществляется другими путями. Это в частности полезно для параметров функции. Посредством описания параметра указателя как const функции запрещается изменять объект, на который он указывает.

char* strcpy(char* p, const char* q); // не может изменить q

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

int a = 1;
const c = 2;
const* p1 = &c; // ok
const* p2 = &a; // ok
int* p3 = &c; // ошибка
*p3 = 7; // меняет значение c

К ак обычно, если тип в описании опущен, то он предполагается int.

Е сть другой метод определения целых констант, который иногда более удобен, чем применение const.

определяет три целых константы, называемы перечислителями, и присваивает им значения. Поскольку значения перечислителей по умолчанию присваиваются начиная с 0 в порядке возрастания, это эквивалентно записи:

const ASM = 0;
const AUTO = 1;
const BREAK = 2;

П еречисление может быть именованным.

И мя перечисления становится синонимом int, а не новым типом. Описание переменной keyword, а не просто int, может дать как программисту, так и компилятору подсказку о том, что использование преднамеренное.

keyword key;
switch (key) <
case ASM:
// что-то делает
break;
case BREAK:
// что-то делает
break;
>

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

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

enum int16 <
sign=0100000, // знак
most_significant=040000, // самый значимый
least_significant=1 // наименее значимый
>;

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

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

Переменные

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

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

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

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

В Pascal прописные и строчные буквы в именах переменных не различаются.

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

В примере ниже происходит ввод значений трех переменных разных типов и выполнение допустимых для их типов операций. Если тип переменных integer, то им можно присваивать только целые числа в диапазоне от -32768 до 32767. Под тип integer в языке программирования Паскаль отводится 2 байта, что равно 16 битам, а это значит, что можно хранить 2 16 (65536) значений (отрицательные и положительные числа, а также ноль). В этих диапазонах переменные int1 и int2 могут принимать какие угодно значения. При попытке записи в переменную значения не ее типа возникнет ошибка.

Илон Маск рекомендует:  outline-offset в CSS

Пример работы программы:

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

Длина переменных

Ранние версии компиляторов Паскаля имели ограничение на учитываемую длину имен переменных. В имени учитывались лишь первые восемь символов. Поэтому, например, такие переменные как variable1 и variable2 компилятор воспринимал как одно и тоже, т.к. первые восемь символов совпадали.


В современных версиях компиляторов с языка Pascal таких ограничений нет. Например, в результате работы приведенной ниже программы как в среде Free Pascal, так и Turbo Pascal 7.1 на экран выводятся два разных числа (10 и 20). Это значит, что компиляторы учитывают больше восьми символов в именах переменных (и других идентификаторов: именах констант, процедур и др.).

Константы

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

Главное преимущество констант заключается в том, что они описываются в начале программы и им сразу там же присваивается значение, а при выполнении программы константы не изменяются. Но если при правке кода, программист решит поменять значение константы, он впишет в ее описание другое значение, а сам код программы редактировать не придется. Поэтому, если в программе часто планируется использоваться какое-то значение, опишите его в разделе констант, который в программе располагается до раздела переменных:

Значениями констант могут быть данные большинства типов, используемых в языке Паскаль.

Рассмотрим такую программу:

В ней используется константа n со значением 10. Программа считает сумму десяти чисел в диапазоне от 1 до 10. Если нам захочется посчитать сумму чисел до 20, то достаточно будет изменить значение константы в начале программы. Если бы константа не использовалась, то пришлось бы просмотреть весь код программы и исправить значение 10 на 20. Если программа большая, то легко ошибиться: не найти или исправить не то значение.

Типизированные константы

В языке Паскаль помимо обычных констант используются типизированные константы. Можно сказать, что они занимают промежуточное положение между переменными и константами. Они получают значение при описании (как константы), но могут его менять в теле программы (как переменные).

Описываются типизированные константы в разделе констант:

Константы и переменные, типы данных.

Как и другие языки программирования, Паскаль интерпретирует данные как константы и переменные. Они определяются идентификаторами (именами), по которым к ним можно обращаться в программе.

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

Пример 2.CONST а=2.2; s=3;

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

Каждая переменная и константа в программе принадлежит к определенному типу данных. Тип констант автоматически распознается компилятором без предварительного описания. Тип переменных должен быть обязательно (в отличие от ТВ) описан в разделе описания типов данных (см. структуру программы). Для описания переменных служит команда:

Пример 3.VAR n, I, j: integer; x, z: real;

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

Классификация типов данных представлена на рис. 2.7.

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

Вещественные типы данных (табл. 2.2) представляют собой вещественные значения, которые используются в арифметических выражениях. Паскаль допускает представление вещественных значений как с плавающей, так и с фиксированной точкой.

Рис. 2.7. Классификация типов данных.

Таблица 2.1. Целочисленные типы данных.

Тип Диапазон значений Требуемая память, байт
Byte Shortint Integer Word Longint 0…255 -128…127 -32768…32767 0…65535 -21474836482147483647

Таблица 2.2. Вещественные типы данных.

Тип Диапазон Требуемая память, байт
Real Single Double Extended Comp 2.9*10E-39…1.7*10E38 1.6*10E-45…3.4*10E38 5.0*10E-324…1.7*10E308 1.9*10E-4951…1.1*10E4932 -2E+63+1…2E+63+1

Литерный (символьный) тип определяется множеством значений кодовой таблицы персонального компьютера. В программе значения переменных и констант типа char должны быть заключены в апострофы.

Булевский тип (boolean) представлен двумя значениями True (истина) и False (ложь) и используется в логических выражениях и выражениях отношения.

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

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

Строка – это последовательность символов кодовой таблицы ЭВМ. При использовании в выражении строка заключается в апострофы. Над строковыми данными (string) допустимы операции сцепления (+) и операции отношения (=, <>, , >=,

Для описания массива предназначено словосочетание ARRAY OF. Описать массив можно в разделе описания переменных или в разделе описания типов данных, используя следующие операторы:

1) TYPE_имя типа=ARRAY[тип индекса]_OF_тип элементов массива;

2) VAR_имя массива1[, имя массива2…]:имя типа;

Пример 4. а) Описание массивов в разделе описания типов данных (задаются одномерные массивы из пяти элементов вещественного типа с именами m1, rez).

TYPE mass=array [1..5]of real;

VAR m1, rez: mass;

б) Описание массива в разделе описания переменных.

VAR matrix: array [1..5,1..7] of integer;

Множество – это структурированный тип данных, представляющий набор взаимосвязанных по какому-либо признаку или группе признаков объектов, которые можно рассматривать как единое целое. Все элементы множества должны принадлежать к одному из скалярных типов, кроме вещественного. Для описания множественного типа используется словосочетание SET OF, описание аналогично описанию массива. При работе с множествами допускается применение операций отношения (=,<>,>=,

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

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

Описания и константы

В этой главе описаны основные типы (char, int, float и т.д.) и основные способы построения из них новых типов (функций, векторов, указателей и т.д.). Имя вводится в программе посредством описания, которое задает его тип и, возможно, начальное значение. Даны понятия описания, определения, области видимости имен, времени жизни объектов и типов. Описываются способы записи констант в C++, а также способы определения символических констант. Примеры просто демонстрируют характерные черты языка. Более развернутый и реалистичный пример приводится в следующей главе для знакомства с выражениями и операторами языка C++. Механизмы задания типов, определяемых пользователем, с присоединенными операциями представлены в Главах 4, 5 и 6 и здесь не упоминаются.

8 Описания
Прежде чем имя (идентификатор) может быть использовано в C++ программе, он должно быть описано. Это значит, что надо задать его тип, чтобы сообщить компилятору, к какого вида объектам относится имя.

8 Имена
Имя (идентификатор) состоит из последовательности букв и цифр.

8 Типы
Каждое имя (идентификатор) в C++ программе имеет ассоциированный с ним тип. Этот тип определяет, какие операции можно применять к имени (то есть к объекту, на который оно ссылается), и как эти операции интерпретируются.

8 Константы
C++ дает возможность записи значений основных типов: символьных констант, целых констант и констант с плавающей точкой.

8 Экономия Пространства
В ходе программирования нетривиальных разработок неизбежно наступает время, когда хочется иметь больше пространства памяти, чем имеется или отпущено. Есть два способа выжать побольше пространства из того, что доступно.

Компонентный Паскаль/Переменные и константы

Содержание

Под понятием «Тип данных» скрывается семантическое свойство информации. Для компьютера, все байты информации представляют собой пакеты из 8 бит. Каждый из битов может быть включенным или выключенным. В зависимости от того, как принято понимать эти состояния (прямая или инверсная логика) — эти значения принимаются равными «0» или «1». Больше о содержимом ячеек памяти компьютер не знает ничего.

Но для программиста даже один байт может содержать различные типы информации. Например, 8 бит (= 1 байт), с точки зрения программиста — может содержать числа от 0 до 255. А может и код символа в в однобайтовой кодировке («а», «б», «в». ). А может и вообще что-то иное. Но все байты одинаковы, у них нет признака того, что они хранят [1] . В какой-то момент, программист вполне может решить, что вот эта ячейка памяти хранит число от 0 до 255. А на самом деле, в самом начале, программист задумывал хранить в этой ячейке памяти код символа для последующей печати. Более того, вполне может быть, что программист решил использовать под свои нужды не одну, а сразу две (или даже тысячу) ячеек? Помнить где расположена каждая ячейка? И такие ошибки встречаются и у новичков, и у опытных программистов. Как решить эту проблему?

Проблема решается тем, что помнить о том, где расположена каждая ячейка памяти, и что она хранит — должен Компонентный Паскаль. Этой информации нет в самой ячейке, зато есть у языка программирования. Это и есть семантическое свойство информации, в данном случае — её тип. Таким образом описанная ячейка называется переменная. Свой тип она не меняет с момента её описания, до момента окончания выполнения программы. Исключений не бывает. [2]


Целые числа Править

Логический тип Править

Логический тип, в полном смысле этого слова не является целым. Но и к дробным числам этот тип можно отнести ещё меньше. Переменная такого типа может принимать только два значения. В Компонентном Паскале эти два значения определены как TRUE («Истина») и FALSE(«ложь»). Этот тип переменных используется даже шире, чем об этом задумываются многие программисты. Логический тип можно использовать явно (через переменную), а можно и неявно (например, через сравнение двух чисел, строк, результатов вызовов процедур). Обозначается такой тип через ключевое слово BOOLEAN. Пример:

Стоит обратить внимание на выравнивание двоеточий и ключевых слов. Двоеточие, если проводить аналогию с русским языком может выступать как указатель на обстоятельство, как во фразе: «Итак: всё плохо!». Только в случае с КП этот разделитель служит для указания типа (справа) для переменной (что слева).

Байтовый тип Править

Или просто байт. Обозначается ключевым словом BYTE. Переменная такого типа может принимать значения от 0 до 255. Это совсем не много, но для многих целей может оказаться вполне достаточно. Например, не существует минут и секунд более 60. Или например не бывает дня в месяце с номером 32. Пример описания переменной типа BYTE:

Важно не забывать ставить точку с запятой после всех определений переменных (после определения последней переменной точку с запятой можно не ставить). Кроме того, следует помнить, что особенности современных компьютеров: они не работают с одним байтом, они работают, скажем, сразу с 4-мя байтами. Поэтому возможны такие эффекты, как неэкономное расходование памяти. Как избежать таких эффектов будет рассмотрено в дальнейших частях.

Короткое целое Править

Короткое целое число в БлэкБоксе/КП определено как 2 байта. В последней редакции сказано, что размеры типов не зависят от аппаратной платформы, но в текущей реализации КП, которая была скомпилирована под архитектуру 32 бита, короткое целое именно 2 байта. Диапазон чисел, которые умещаются в эти 2 байта составляет примерно от -32000 до +32000. Короткое целое обозначается ключевым словом SHORTINT.

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

Как видно, в целом, определение переменных базовых типов однообразно и их легко запомнить.

Целое Править

Целое число является основным типом целых чисел для машин с 32 битами на машинное слово. Для КП это именно тот случай. Целое число занимает в памяти 4 байта. Такого количества памяти хватает на описание числа примерно от -2,1 млрд. до +2,1 млрд. Не часто встречаются числа с таким динамическим размахом. Целый тип описывается ключевым словом INTEGER:

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

Длинное целое Править

Самый широкий диапазон целых чисел, который встроен в КП. Занимает 8 байт, представляет целые числа в диапазоне примерно от -9,2*10^18 до 9,2*10^18. Даже сложно представить, где такие числа вообще могут потребоваться обычным людям. Обозначаются такие переменные как LONGINT:

Следует помнить, что сборка BlackBox Red (впрочем, как и другие) оптимизированы под 32-х битную архитектуру, поэтому работа с такими числами будет существенно медленней, чем с типом INTEGER.

Вещественные числа Править

Вещественные (дробные, рациональные) числа называются так потому, что в окружающем мире редко встречаются «целые» объекты. Например, слоны. Они вроде все слоны. Но слонёнок по массе — это целый слон? Если нет, то как отразить его массу через целого слона? Кроме того, очень часто приемлемо записывать числа с заданной точностью. Они для этого подходят как никто. Таким образом, вещественные числа находят более чем широкое применение в промышленности.

Короткое вещественное Править

Такие числа соответствуют вещественным числам в языке Си. В памяти они занимают 4 байта, но в отличии от целых чисел они имеют особый формат при хранении. Это приводит к тому, что точность таких чисел ограничивается 7-8 десятичных цифр. На зато диапазон этих чисел раздвигается до -3,4*10^(38). -10^(-38) в отрицательной области, и до 10^(-38). 3,4*10^(38) в области положительных чисел. Даже по сравнению с типом LONGINT это очень много. Но есть и обратная сторона медали. Если в типе LONGINT точность до последнего знака, то в данном случае (как уже было выше упомянуто) только до 7-8. Поэтому, если в вычислениях важна точность, надо помнить о том, что точность больших чисел огрубляет точность малых чисел. Это правило определяет порядок работы с вещественными числами: «сначала маленькие, потом большие» при увеличении, и «сначала большие, потом маленькие» при уменьшении. Такие числа обозначаются ключевым словом SHORTREAL:

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

Вещественное число Править

Этот тип чисел занимает в памяти в 2 раза ячеек больше, чем короткое вещественное — 8 байт и соответствует числу с двойной точностью стандарта «IEEE 754». Диапазон, который охватывают такие числа, если записывать от руки без научного формата — утомит очень быстро (примерно -10^308. 10^308). Точность составляет 15-17 десятичных знаков. Если через метры записывать диаметры ядер атомов — такой точности как раз должно хватить [3] . Переменная вещественного типа описывается ключевым словом REAL:

Литерные типы Править

Литерными типами называют такие типы данных, которые имеют какое-либо отношение к отображению. Например, буквы, строки, тексты, цифры, управляющие символы (перевод строки, новая строка, гудок и т.д.). Дело в том, что такие символы крайне важны для человека (и к ним совершенно равнодушен компьютер). Но на экране, принтере, плоттере — любой из этих символов состоит из множества точек (матрицы). И такая матрица может достигать размера 1200х2400 точек. Да ещё и они могут быть цветные, и таким образом потребуется непомерное количество байтов для хранения всех возможных изображений литер и их цветов. И это ещё не говоря о всяких графических пиктограммах (смайлики, флажки, стрелки, дома и т.д.). Поэтому в своё время был предложен компромиссный вариант для хранения литер. Суть идеи состояла в том, что печатной (служебной) литере должен соответствовать свой код-число. А уж если потребуется, потом можно добавить различные способы вывода кода этой литеры на экран, принтер, плоттер и т.д. Тогда хранение литеры в памяти компьютера становится компактным и универсальным.

Илон Маск рекомендует:  Что такое код msg_receive

Литеры набора Latin-1 Править

Эти литеры занимают в памяти ПК всего 1 байт. Если речь идёт исключительно о латинском алфавите (22 буквы), то им вполне можно пользоваться. Но вот проблема: если будет желание выводить символы на национальном алфавите, вместо ожидаемого результата будет непонятно что. А суть этой проблемы в том, что этот набор литер принимался как стандарт на заре компьютерной эпохи. Мало кто задумывался об этой проблеме, поэтому литеры набора Latin-1 даны скорее для обратной совместимости со старыми программами, чем для реального использования. Переменные такого типа описываются ключевым словом SHORTREAL:

Стоит добавить, что кроме букв и цифр в литерах Latin-1 есть ещё и разные интересные значки, которые, иногда, могут и пригодиться [4] .

Литеры набора Unicode Править

Этот набор литер по сравнению с предыдущим является более прогрессивным. Он лишён недостатков Latin-1, но у каждой медали две стороны. Да, теперь в этот набор Unicode помещаются литеры всех языков мира существующих, или когда-либо существовавших. Туда же помещаются различного рода пиктограммы из всех сфер жизни (значки Солнца, Луны, Земли и даже «Серп и молот»). Но, если байтовые литералы было легко сравнивать, так как они располагались в алфавитном порядке, то как понять, какой код меньше и на каком основании: английский литерал «а» или русский литерал «а»? А это совершенно разные литералы. К счастью, все (или почти все) процедуры для работы с литералами Unicode написаны, и сомнительно, что программисту придётся писать что-то своё (с высокой степенью вероятности это будет велосипед, как говорят программисты). Такой тип переменных описывается ключевым словом CHAR:

Ещё раз стоит обратить внимание — в данном примере (в наборе Unicode) русские и английские литеры кодируются различными кодами, хотя внешне и выглядят одинаково [5] .

Константы Править

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

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

Форма их определения существенно отличается от формы определения переменных:

Форма описания констант определена не через двоеточие, а через знак «равно». И в данном случае это вполне соответствует законам логики и математики. Также стоит обратить внимание, что константа «wery_good» и её знак «равно» не выровнены со всеми константами. Это допущение вполне приемлемо при оформлении кода. Ну что делать, если имя переменной, такое длинное?

Язык Компонентный Паскаль был спроектирован, а не сочинён. Поэтому правила преобразования типов просты, понятны и предсказуемы.

Преобразования числовых типов Править

Как уже было выше описано, самым мощным диапазоном представления чисел является тип REAL. В случае преобразований при необходимости, этот тип преобразуется в более ограниченный — SHORTREAL. Если этот тип придётся преобразовывать, он в свою очередь сужается до LONGINT. Тип длинное целое при сжатии переходит в тип INT (4 байта). После типа целого сжатие диапазона идёт в сторону SHORTINT (2 байта). Короткое целое тоже может быть сжато до BYTE. Дальше диапазон числа уменьшить нельзя. Тип BOOLEAN, строго говоря числовым не является, хотя и содержит логические «0» и «1». Обратное преобразование также верно. Например, если разделить два целых числа 3 и 2 — результат будет вещественное число. КП прекрасно понимает, что без этого результат очень неточным. Поэтому, если результат такого деления попытаться присвоить целочисленной переменной — такой модуль даже не удастся скомпилировать — Компонентный Паскаль просто не позволит это сделать! В то же время, если сумма двух целых превышает динамический диапазон целого — КП на стадии компиляции постарается выяснить этот факт, и потребует результат присваивать длинному целому. Если выяснить на этапе компиляции это невозможно, КП во время исполнения остановит программу, и не позволит проскочить момент переполнения и «улететь программе в космос». Те же самые правила касаются и остальных преобразований типов. Коротко схему преобразования типов можно отобразить так:

REAL >= SHORTREAL >= LONGINT >= INTEGER >= SHORTINT >= BYTE

Преобразования литеральных типов Править

То, что выше было написано про числовые типы, применимо и к литеральным типам. Также надо учитывать, что приведение SHORTCHAR к CHAR будет затруднено, так как КП просто не будет знать, какая была национальная кодировка типа SHORTCHAR. Коротко схему преобразования типов можно отобразить так:

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

  • Описание переменных всегда в КП выносится в отдельную секцию модуля, которая обозначается ключевым словом VAR (variable, переменная).
  • Описание констант всегда в КП выносится в отдельную секцию модуля, которая обозначается ключевым словом CONST (constante, постоянная/неизменяемая).

Необходимо обратить внимание, что константе «с» не нужно присваивать значение, а её тип (судя по всему) компилятор определил, как INTEGER. Наоборот, переменной «i» необходимо присвоить значение, так как при запуске программы, в ней находится «мусор» — случайные значения, оставшиеся от работы предыдущей программы (которая пользовалась этим участком памяти). Переменной «i1» также не нужно присваивать начальное значение, так как нам оно — не интересно. Переменная «i1» получает своё значение в результате вычислений.

Если всё сделано правильно, то можно будет увидеть результат, примерно такой, как на скриншоте справа. Удивляемся размеру программы (88 байт), убеждаемся, что деление двух целых чисел привело к результату REAL, вспоминаем как вставить КОММАНДЕР и использовать его.

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

Здесь могут возникнуть вопросы, поэтому ниже приводятся необходимые пояснения:

  • В первом случае, при присвоении константе «с» значения «3» — стоит знак равно. И это правильная математическая форма записи.
  • Во втором случае, переменная «i1» содержит «мусор», который никак не может быть равен «с/i», и чтобы подчеркнуть этот факт, что это не математическое уравнение, а инструкция присваивания в КП принято в инструкциях использовать символ «:=», как не нарушающий математические соглашения.
  • В ряде языков (в том числе, таком популярном, как Си) знак равно используется и для сравнения чисел в условиях, и это очень часто является источником ошибок. В Компонентном Паскале такие ситуации исключены. Ведь этот язык (в том числе) и для промышленного программирования.

Описание констант


5. Описание констант

В Object Pascal различается два вида констант – обыкновенные и типизованные. Описание констант следует после слова Const.

5.1. Обыкновенные константы

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

Тип константы определяется автоматически по виду ее значения.

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

Pi = 3.1415926536E+00 (тип Real)

False, True ( Boolean)

MaxInt = 32767 ( Integer)

MaxLongInt = 2147483647 ( LongInt)

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

IntArr: Array[1..ArrMax] of Integer;

StrArrr: Array[1..ArrMax] of String[nSt];

Такой способ описания позволяет при необходимости легко изменить размер массивов, изменив всего лишь значение константы (в данном случае константы ArrMax). При этом произойдут автоматические изменения определений как в текущем, так и в других модулях, если они содержат определения, опирающиеся на эту константу. Явное определение массивов через значение 100 потребовало бы соответствующих явных изменений этого значения на другое всюду, где такие описания имели бы место. Для больших программ это могло бы стать причиной ошибок, если часть изменений не была бы выполнена по недосмотру.

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

Простые типизованные константы. Общий вид константы:

CurrentPosition: Word = 11000;

LastLetter: Char = ‘z’;

HeadOfModule: String[26] = ‘Начало программного модуля’;

Типизованные константы нельзя использовать для описания динамических структур. Следующий пример демонстрирует недопустимое описание динамического массива Arr через типизованную константу ArrMax:

ArrMax: Integer = 100;

IntArr: Array [1..ArrMax] of Integer;

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

Типизованные константы типа «массив». Этот тип констант позволяет обозначить постоянной величиной целый массив однотипных значений, например:

tVotes = (Yes, No, UnDef);

tVoteArr = array [tVotes] of String [7];

Votes : tVoteArr = ( ‘Да’, ‘Нет’, ‘Не знаю’ );

Здесь в секции Type сначала описан перечислимый тип tVote из трех значений Yes, No, Undef. Затем через этот тип определен новый тип tVoteArr как тип-массив из трех элементов, каждый из которых является строкой длины 7. Далее в секции Const определена типизованная константа Votes, которая определена как массив трех строковых значений (‘Да’, ‘Нет’, ‘Не знаю’). Затем в секции Var описаны переменные V и S разных типов. Предпоследняя и последняя строки являются исполняемыми операторами присваивания. Сначала переменной V присвоено начальное значение – константа Votes. Затем переменной S присвоено значение третьего элемента массива V. В результате значением строковой переменной S будет ‘Не знаю’.

Типизованные константы типа «запись». Это комбинированный тип констант, основанный на конструкциях типа Record (см. параграф 7.1), которые состоят из полей. Константы такого типа определяются по правилу «имя поля : значение поля».

Year : 1951 .. 2050;

D1 : (Week : Sun; Num : 26; Month : 10; Year : 2001 D1, которая представляет конкретную дату «Воскресенье, 26, октябрь);

Здесь в секции Type описана запись, состоящая из четырех полей и характеризующая день года. Назначения этих полей понятно из сопроводительных комментариев. Затем в секции Const описана типизованная константа (Sun; 26; 12; 2001), т. е. » Воскресенье, 26 октября 2001 года».

Типизованные константы типа «множество». Эти константы могут быть построены как подмножества базовых или производных от них типов.

tChildNameSet = set of [‘Таня’, ‘Валя’, ‘Володя’, ‘Гена’];

Girls2Set : tGirlsNamesSet = [‘Валя’, ‘Гена’];

Indexes: set of integer = [300 .. 500, 1777,3700];

Здесь в секции Type описано множество из четырех имен детей. Ниже в секции Const описано две константы, каждая из которых представляет подмножества. Первая – подмножество имен, объявленных ранее в tChildNameSet, вторая – подмножество целых чисел типа Integer.

Урок №37. const, constexpr и символьные константы

Обновл. 7 Апр 2020 |

До этого момента, все переменные, которые мы рассматривали, были не константами. Их значения можно было изменить в любое время. Например:

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

Константы

Возьмём к примеру величину силы тяжести на Земле: 9.8м/с^2. Она вряд ли поменяется в ближайшее время. Использовать константу в этом случае будет наилучшим вариантом, так как мы предотвратим, таким образом, любое (даже случайное) изменение этого значения.

Чтобы сделать переменную константой — используйте ключевое слово const перед типом переменной или после него. Например:

Несмотря на то, что C++ позволяет размещать const как перед типом данных, так и после него, хорошей практикой считается размещать const перед типом данных.

Константы должны быть инициализированы при объявлении. Изменить их значения с помощью операции присваивания нельзя:

Объявление константы без её инициализации также вызовет ошибку компиляции:

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

const является наиболее полезным (и наиболее часто используемым) с параметрами функций:

Таким образом, при вызове функции, константа-параметр сообщает и гарантирует нам то, что функция не изменит значение переменной myValue.

Время компиляции и время выполнения

Когда вы находитесь в процессе компиляции программы, то это время компиляции (англ. «compile time»). Компилятор проверяет вашу программу на синтаксические ошибки и, если их нет, конвертирует код в объектные файлы.

Когда вы находитесь в процессе запуска вашей программы или когда ваша программа уже выполняется, то это время выполнения (англ. «runtime»). Код выполняется строка за строкой.

Спецификатор constexpr

В C++ есть два вида констант:

Константы времени выполнения. Их значения определяются только во время выполнения программы. Переменные типа usersAge и myValue выше являются константами времени выполнения, так как компилятор не может определить их значения во время компиляции. usersAge зависит от пользовательского ввода (который можно получить только во время выполнения программы), а myValue зависит от значения, переданного в функцию (которое станет известным также во время выполнения программы).

Константы времени компиляции. Их значения определяются во время компиляции программы. Например, переменная со значением силы тяжести на Земле является константой времени компиляции, так как мы её определяем во время написания программы (до начала её выполнения).

В большинстве случаев, не важно какой тип константы вы используете: времени выполнения или времени компиляции. Однако, всё же есть несколько ситуаций, когда C++ может требовать константу времени компиляции вместо времени выполнения (например, при определении длины массива фиксированного размера — мы рассмотрим это несколько позже). Так как есть 2 типа констант, то компилятору нужно постоянно отслеживать, к какому из них относится определённая переменная. Чтобы упростить это задание, в C++11 добавили спецификатор constexpr, который сообщает компилятору, что текущая переменная является константой времени компиляции:

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

В этой статье поговорим о том, какие есть переменные и константы в Паскале.

Переменные Паскаль:

Переменная — это элемент программы, предназначенный для коррекции, хранения, передачи данных внутри программы. Перед тем как приступать к созданию очередной программы, необходимо объявить (в разделе var) все используемые нами в дальнейшем переменные.

Константы Паскаль:

Чтобы постоянно не прописывать много раз одно и тоже число (которое может окажется слишком громоздким), символ или строку, в Турбо Паскаль предусмотрено использование констант. Константа — это идентификатор, который обозначает некоторую не меняющуюся величину заданного программистом типа. Константы объявляются в соответствующем разделе — разделе const.

Виды констант Паскаль:

В языке Pascal представлены следующие виды констант:

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

Пример:

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

Пример:

  • Символьная константа — некоторый символ, заключенный в апострофы.

Пример:

  • Строковые константы — последовательность любых символов, которая заключена в апострофы.

Пример:

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

Примеры:

simvol: char = ‘?’;

tip: real = 12.47;

Приведем простой пример программы на константы Паскаль:

Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL