Литерал в программировании это

BestProg

Литералы

Содержание

1. Что такое литералы в языке C# ? Примеры литералов.

Литералы – это постоянные значения, которые представляются в удобной для восприятия форме.

2. Какого типа могут быть литералы?

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

В зависимости от значения литералы могут быть:

• целочисленных типов — int , uint , long , ulong ;
• типов с плавающей точкой — float , double , decimal ;
• символьного типа char ;
• строчного типа string.

3. Как представляются целочисленные литералы?

По умолчанию, все целочисленные литералы имеют тип int :

Примеры литералов типа int :

Для того чтобы литерал имел тип long к нему нужно добавить суффикс ‘ l ‘ или ‘ L ‘. Примеры литералов типа long :

Для того чтобы литерал имел беззнаковый целочисленный тип к нему нужно добавить суффикс ‘ u ‘ или ‘ U ‘. Примеры литералов типа uint :

Примеры литералов типа ulong :

4. Можно ли целочисленные литералы присваивать переменным типа byte , sbyte , short и ushort ?

Можно, но при условии, что присваиваемое значение может быть представлено целочисленным типом.

Пример:

5. Каким образом представляются литералы, принадлежащие к типам с плавающей запятой?

По умолчанию, литералы типа с плавающей запятой относятся к типу double . Кроме того, к литералам типа double можно прибавлять суффикс ‘ d ‘ или ‘ D ‘ (это ничего не меняет).

Примеры литералов типа double :

Если нужно, чтобы литерал имел тип float , к нему нужно добавить суффикс ‘ f ‘ или ‘ F ‘. Примеры литералов типа float :

Если нужно, чтобы литерал имел тип decimal , то к нему прибавляется суффикс ‘ m ‘ или ‘ M ‘. Примеры литералов типа decimal :

6. Как осуществляется присвоение значения литералов переменным типов float и decimal ?

Пример описания и присвоения значения литералов переменным, которые принадлежат к типам с плавающей запятой:

7. Как представляются значения целочисленных литералов в шестнадцатеричной системе исчисления?

Язык C# разрешает также представлять целочисленные литералы в шестнадцатеричной системе исчисления. Шестнадцатеричные литералы должны начинаться с символов « 0x «.

В этих литералах используются числа от 0 до 9 , а также буквы от ‘ А ‘ к ‘ F ‘.

Примеры представления литералов в шестнадцатеричной системе исчисления:

8. Как представляются символьные литералы ( char )?

Символьные литералы принадлежат к типу char . Символьные литералы берутся в одинарные кавычки.

Примеры символьных литералов:

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

Примеры управляющих последовательностей символов:

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

9. Как представляются строчные литералы?

В языке C# строчный литерал представляет собой набор символов, взятых в двойные кавычки. Примеры строчных литералов

Если нужно задать в виде литерала следующий путь:

то он будет иметь такой вид:

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

10. Какой вид имеет буквальный строчный литерал?

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

Например:

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

Урок №36. Литералы и магические числа

Обновл. 29 Дек 2019 |

В C++ есть два вида констант: литеральные и символьные. В этом уроке мы рассмотрим литеральные константы.

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

Литеральные константы (или просто «литералы») — это значения, которые вставляются непосредственно в код. Поскольку они являются константами, то их значения изменить нельзя. Например:

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

Во втором способе объявления, число после экспонента может быть и отрицательным:

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

Суффиксы есть даже для целочисленных типов (но они почти не используются):

По умолчанию литеральные константы типа с плавающей точкой являются типа double. Для конвертации литеральных констант в тип float, можно использовать суффикс f или F :

C++ также поддерживает литералы типов string и char:

Почему 10 вместо 12? Потому что std::cout выводит числа в десятичной системе счисления, а 12 в восьмеричной системе = 10 в десятичной.

Восьмеричная система счисления используется крайне редко.

Шестнадцатеричная система счисления состоит из 16 символов: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, А, В, С, D, Е, F.

Для использования литерала из шестнадцатеричной системы счисления, используйте префикс 0x :

Поскольку в этой системе 16 символов, то одна шестнадцатеричная цифра занимает 4 бита. Следовательно, две шестнадцатеричные цифры занимают 1 байт.

Рассмотрим 32-битовое целое число из двоичной системы счисления: 0011 1010 0111 1111 1001 1000 0010 0110 . Из-за длины и повторения цифр его сложно прочесть. В шестнадцатеричной системе счисления это же значение будет выглядеть следующим образом: 3A7F 9826 . Такой удобный/сжатый формат является преимуществом шестнадцатеричной системы счисления. Поэтому шестнадцатеричные значения часто используются для представления адресов памяти или необработанных значений в памяти.

До C++14 использовать литерал из двоичной системы счисления было невозможно. Тем не менее, шестнадцатеричная система счисления может нам в этом помочь:

Бинарные литералы и разделитель цифр в C++14

В C++14 мы можем использовать бинарные (двоичные) литералы, добавляя префикс 0b :

Поскольку длинные литералы читать трудно, то в C++14 добавили возможность использовать одинарную кавычку ‘ в качестве разделителя цифр:

Если ваш компилятор не поддерживает C++14, то использовать бинарные литералы и разделитель цифр вы не сможете — компилятор выдаст ошибку.

Магические числа. Что с ними не так?

Рассмотрим следующий фрагмент кода:

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

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

Рассмотрим следующий фрагмент кода:

Чтобы обновить число учеников в кабинете, нам нужно изменить значение константы с 30 на 36. Но что делать с вызовом функции setMax(30)? Аргумент 30 и константа 30 в коде выше является одним и тем же, верно? Если да, то нам нужно будет обновить это значение. Если нет, то нам не следует вообще трогать этот вызов функции. Если же проводить автоматический глобальный поиск и замену числа 30, то можно ненароком изменить и аргумент функции setMax(), в то время, когда его вообще не следовало бы трогать. Поэтому вам придётся просмотреть весь код «вручную», в поисках числа 30, а затем, в каждом конкретном случае, определить: изменить ли 30 на 36 или нет. Это может занять очень много времени + вероятность возникновения новых ошибок повышается в разы.

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

Правило: Старайтесь сократить к минимуму использование магических чисел в ваших программах.

Литералы

В C# литералами называются постоянные значения, представленные в удобной для восприятия форме.
Например, число 100 является литералом. Сами литералы и их назначение настолько понятны, что они применялись во всех предыдущих примерах программ без всяких пояснений. Но теперь дадим им формальное объяснение.
В C# литералы могут быть любого простого типа.
Представление каждого литерала зависит от конкретного типа.

Символьные литералы заключаются в одинарные кавычки.
Например, ‘а’ и ‘%’ являются символьными литералами.

Целочисленные литералы указываются в виде чисел без дробной части. Например, 10 и -100 — это целочисленные литералы.
Для обозначения литералов с плавающей точкой требуется указывать десятичную точку и дробную часть числа. Например, 11.123 — это литерал с плавающей точкой.
Для вещественных чисел с плавающей точкой в C# допускается также использовать экспоненциальное представление, например:
1.2E-06 = 1.2·10 -6 .
У литералов должен быть также конкретный тип, поскольку C# является строго типизированным языком. В этой связи возникает естественный вопрос: к какому типу следует отнести числовой литерал, например 2, 12, 3987 или 0.23?
Для ответа на этот вопрос в C# установлен ряд простых для соблюдения правил:
1) У целочисленных литералов должен быть самый мелкий целочисленный тип, которым они могут быть представлены, начиная с типа int. Таким образом, у целочисленных литералов может быть один из следующих типов: int, uint, long или ulong в зависимости от значения литерала.
2) Литералы с плавающей точкой относятся к типу double.
Если вас не устраивает используемый по умолчанию тип литерала, вы можете явно указать другой его тип с помощью суффикса. Так, для указания типа long к литералу присоединяется суффикс l или L. Например, 12 — это литерал типа int, a 12L — литерал типа long.
3) Для указания целочисленного типа без знака к литералу присоединяется суффикс u или U. Следовательно, 100 — это литерал типа int, a 100U — литерал типа uint. А для указания длинного целочисленного типа без знака к литералу присоединяется суффикс ul или UL. Например, 984375UL — это литерал типа ulong.
4) Кроме того, для указания типа float к литералу присоединяется суффикс F или f. Например, 10.19F — это литерал типа float. Можете даже указать тип double, присоединив к литералу суффикс d или D, хотя это излишне. Ведь, как упоминалось выше, по умолчанию литералы с плавающей точкой относятся к типу double.
5) И наконец, для указания типа decimal к литералу присоединяется суффикс m или М. Например, 9.95М — это десятичный литерал типа decimal.
6) Несмотря на то что целочисленные литералы образуют по умолчанию значения типа int, uint, long или ulong, их можно присваивать переменным типа byte, sbyte, short или ushort, при условии, что присваиваемое значение может быть представлено целевым типом.

Шестнадцатеричные литералы. Вам, вероятно, известно, что в программировании иногда оказывается проще пользоваться системой счисления по основанию 16, чем по основанию 10. Система счисления по основанию 16 называется шестнадцатеричной. В ней используются числа от 0 до 9, а также буквы от А до F, которыми обозначаются десятичные числа 10,11,12,13, 14 и 15. Например, десятичному числу 16 соответствует шестнадцатеричное число 10. Вследствие того что шестнадцатеричные числа применяются в программировании довольно часто, в C# разрешается указывать целочисленные литералы в шестнадцатеричном формате. Шестнадцатеричные литералы должны начинаться с символов 0x, т.е. нуля и последующей латинской буквы «икс». Ниже приведены некоторые примеры шестнадцатеричных литералов:
count = 0xFF; // равно 255 в десятичной системе
incr = 0x1a; // равно 26 в десятичной системе

Управляющие последовательности символов. Большинство печатаемых символов достаточно заключить в одинарные кавычки, но набор в текстовом редакторе некоторых символов, например, возврата каретки, вызывает особые трудности. Кроме того, ряд других символов, в том числе одинарные и двойные кавычки, имеют специальное назначение в C#, поэтому их нельзя использовать непосредственно. По этим причинам в C# предусмотрены специальные управляющие последовательности символов:

Литералы

Целочисленные литералы

Целочисленные литералы — самый используемый тип в программах. Любое целочисленное значение является числовым литералом, т.е. значения 1, 5, 9, 42 и т.п. являются числовыми литералами с основанием 10. Также можно использовать восьмеричные и шестнадцатиричные значения.

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

Шестнадцатиричные значения обозначают ведущим нулём и символом x (икс). Можно использовать маленький (0x) и большой (0X) символ в числах. Диапазон допустимых цифр — от 0 до 15, где цифры от 10 до 15 заменяются буквами от A до F (можно также использовать символы от a до f в нижнем регистре).

Целочисленные литералы создают значения типа int. Если вы создали переменную типа byte или long, а значение литерала находится в диапазоне допустимых значений этих типов, то ошибки не возникает. Не возникает проблем и с типом long, у которого диапазон значений всегда больше, чем у int. Но при этом нужно явно указать, что значение литерала имеет тип long при помощи строчной или прописной буквы L. Например, 899888777666555444333L.

Целочисленное значение можно также присвоить типу char, если оно лежит в допустимых пределах.

Литералы с плавающей точкой

Числа с плавающей точкой представляют десятичные значения с дробной частью. Число можно записать в двух вариантах — в стандартной и научной форме записи. Стандартная форма — целое число, за которым следуют десятичная точка и дробная часть (например, 3.14). Научная форма записи использует стандартную форму записи числа с плавающей точкой, к которой добавлен суффикс, указывающий степенную функцию числа 10, на которую нужно умножить данное число. Для указания экспоненциальной функции используют символ E или e, за которыми следует десятичное число (положительное или отрицательное). Например, 5.07E12.

По умолчанию литералам с плавающей точкой присвоен тип double. Если вам нужен тип float, то нужно дописать символ F или f. Кстати, для double можно использовать суффиксы D или d, но в этом нет необходимости.

Также возможна запись шестнадцатиричных литерал с плавающей точкой, но на практике я не встречал подобную запись. В этом случае вместо E используется P (или p) — 0x14.3p2.

Символьные литералы

В Java символы представляют собой 16-битовые значения в наборе символов Unicode. Эти значения можно преобразовать в целые значения и применить операции сложения и вычитания. Символьные литералы обрамляются одинарными кавычками. Обычные символы можно ввести стандартным способом, например, ‘c’, ‘a’, ‘@’. Существуют также символы, которые следует экранировать обратным слешем, например, чтобы вывести сам символ одинарной кавычки, нужно использовать вариант ‘n». Для символа новой строки используется ‘n’.

Можно вывести нужный символ, используя его восьмеричное или шестнадцатиричное значение. При восьмеричной форме используют обратный слеш, за которым следует трёхзначный номер — ‘143’.

Для ввода шестнадцатиричного значения используют обратный слеш, символ u, за которыми следуют четыре шестнадцатиричные цифры, например, ‘u0061’.

Строковые литералы

Строковые литералы — это набор символов в двойных кавычках, например, «Кот — это муж кошки». Внутри строковых литералов также можно использовать управляющие символы, например, для перевода на новую строку — «КотnКошкаnКотёнок».

Булевы литералы

Есть только два булевых литерала — true и false. В отличие от некоторых языков программирования, эти значения не преобразуются в числовые значения. При этом литерал true не равен 1, а литерал false не равен 0.

JDK 7

Раньше Android не поддерживал JDK 7. Сейчас поддержка имеется и стали доступны новые возможности.

В JDK 7 можно использовать целочисленные литералы в двоичной системе. Для этого нужно использовать префикс 0b или 0B:

Кроме того, в JDK 7 можно вставлять символы подчёркивания для облегчения чтения больших числовых литералов:

Символы подчёркивания будут проигнорированы компилятором. Учтите, что можно использовать несколько подряд символов подчёркивания, но нельзя использовать символы подчёркивания в начале или в конце литерала.

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

Лексика языка

Литералы

Литералы позволяют задать в программе значения для числовых, символьных и строковых выражений, а также null- литералов . Всего в Java определено 6 видов литералов :

• целочисленный (integer);
• дробный (floating-point);
• булевский (boolean);
• символьный (character);
• строковый (string);
• null- литерал (null-literal).

Рассмотрим их по отдельности.

Целочисленные литералы

Целочисленные литералы позволяют задавать целочисленные значения в десятичном, восьмеричном и шестнадцатеричном виде. Десятичный формат традиционен и ничем не отличается от правил, принятых в других языках. Значения в восьмеричном виде начинаются с нуля, и, конечно, использование цифр 8 и 9 запрещено. Запись шестнадцатеричных чисел начинается с 0x или 0X (цифра 0 и латинская ASCII -буква X в произвольном регистре). Таким образом, ноль можно записать тремя различными способами:

Как обычно, для записи цифр 10 — 15 в шестнадцатеричном формате используются буквы A , B , C , D , E , F , прописные или строчные. Примеры таких литералов :

Типы данных рассматриваются ниже, однако здесь необходимо упомянуть два целочисленных типа int и long длиной 4 и 8 байт, соответственно (или 32 и 64 бита, соответственно). Оба эти типа знаковые, т.е. тип int хранит значения от -2 31 до 2 31 -1 , или от -2.147.483.648 до 2.147.483.647 . По умолчанию целочисленный литерал имеет тип int , а значит, в программе допустимо использовать литералы только от 0 до 2147483648 , иначе возникнет ошибка компиляции. При этом литерал 2147483648 можно использовать только как аргумент унарного оператора — :

Соответственно, допустимые литералы в восьмеричной записи должны быть от 00 до 017777777777 ( =2 31 -1 ), с унарным оператором — допустимо также -020000000000 ( = -2 31 ). Аналогично для шестнадцатеричного формата – от 0x0 до 0x7fffffff ( =2 31 -1 ), а также -0x80000000 ( = -2 31 ).

Тип long имеет длину 64 бита, а значит, позволяет хранить значения от -2 63 до 2 63 -1 . Чтобы ввести такой литерал , необходимо в конце поставить латинскую букву L или l , тогда все значение будет трактоваться как long . Аналогично можно выписать максимальные допустимые значения для них:

Другие примеры целочисленных литералов типа long :

Дробные литералы

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

Таким образом, дробный литерал состоит из следующих составных частей:

• целая часть;
• десятичная точка (используется ASCII -символ точка);
• дробная часть;
• порядок (состоит из латинской ASCII -буквы E в произвольном регистре и целого числа с опциональным знаком + или — );
• окончание-указатель типа.

Целая и дробная части записываются десятичными цифрами, а указатель типа (аналог указателя L или l для целочисленных литералов типа long ) имеет два возможных значения – латинская ASCII -буква D (для типа double ) или F (для типа float ) в произвольном регистре. Они будут подробно рассмотрены ниже.

Необходимыми частями являются:

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

Все остальные части необязательные. Таким образом, «минимальные» дробные литералы могут быть записаны, например, так:

В Java есть два дробных типа, упомянутые выше, – float и double . Их длина – 4 и 8 байт или 32 и 64 бита, соответственно. Дробный литерал имеет тип float , если он заканчивается на латинскую букву F в произвольном регистре. В противном случае он рассматривается как значение типа double и может включать в себя окончание D или d , как признак типа double (используется только для наглядности).

В Java дробные числа 32-битного типа float и 64-битного типа double хранятся в памяти в бинарном виде в формате, стандартизированном спецификацией IEEE 754 (полное название – IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Standard 754-1985 (IEEE, New York)). В этой спецификации описаны не только конечные дробные величины, но и еще несколько особых значений, а именно:

• положительная и отрицательная бесконечности (positive/negative infinity);
• значение «не число», Not-a-Number, сокращенно NaN;
• положительный и отрицательный нули.

Для этих значений нет специальных обозначений. Чтобы получить такие величины, необходимо либо произвести арифметическую операцию (например, результатом деления ноль на ноль 0.0/0.0 является NaN ), либо обратиться к константам в классах Float и Double , а именно POSITIVE_INFINITY , NEGATIVE_INFINITY и NaN . Более подробно работа с этими особенными значениями рассматривается в следующей лекции.

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

• для float : 3.40282347e+38f
• для double : 1.79769313486231570e+308

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

• для float : 1.40239846e-45f
• для double : 4.94065645841246544e-324

Попытка указать литерал со слишком большим абсолютным значением (например, 1e40F ) приведет к ошибке компиляции. Такая величина должна представляться бесконечностью. Аналогично, указание литерала со слишком малым ненулевым значением (например, 1e-350 ) также приводит к ошибке. Это значение должно быть округлено до нуля. Однако если округление приводит не к нулю, то компилятор произведет его сам:

Стандартных возможностей вводить дробные значения не в десятичной системе в Java нет, однако классы Float и Double предоставляют много вспомогательных методов, в том числе и для такой задачи.

Логические литералы

Логические литералы имеют два возможных значения – true и false . Эти два зарезервированных слова не являются ключевыми, но также не могут использоваться в качестве идентификатора.

Символьные литералы

Символьные литералы описывают один символ из набора Unicode , заключенный в одиночные кавычки, или апострофы ( ASCII -символ single quote , u0027 ). Например:

Также допускается специальная запись для описания символа через его код (см. тему «Кодировка»). Примеры:

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

Первая колонка описывает стандартные обозначения специальных символов, используемые в Java-программах. Вторая колонка представляет их в стандартном виде Unicode -символов. Третья колонка содержит английские и русские описания. Использование в комбинации с другими символами приведет к ошибке компиляции.

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

Однако таким образом можно задать лишь символы от u0000 до u00ff (т.е. с кодом от 0 до 255), поэтому Unicode -последовательности предпочтительней.

Поскольку обработка Unicode -последовательностей ( uhhhh ) производится раньше лексического анализа, то следующий пример является ошибкой:

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

Аналогично и для символа u000d (возврат каретки) необходимо использовать обозначение r .

Специальные символы можно использовать в составе как символьных, так и строковых литералов .