Константы — это постоянные значения, которые известны во время компиляции и не изменяются во время выполнения программы. Константы должны объявляться с модификатором const. Только встроенные типы C# (за исключением System.Object) могут быть объявлены как const . Пользовательские типы, включая классы, структуры и массивы, не могут объявляться как const . Модификатор readonly позволяет создать класс, структуру или массив, которые инициализируются один раз (например, в конструкторе), и впоследствии изменить их нельзя.
C# не поддерживает методы, свойства или события const .
Тип перечисления позволяет определять именованные константы для целочисленных встроенных типов (например int , uint , long и т. д.). Дополнительные сведения см. в разделе Перечисление.
Константы должны инициализироваться сразу после объявления. Пример:
class Calendar1
В этом примере константа Months всегда имеет значение 12, и его не может изменить даже сам класс. На самом деле в случае, если компилятор встречает идентификатор константы в исходном коде C# (например, Months ), он подставляет значение литерала непосредственно в создаваемый им промежуточный язык (IL). Поскольку с константой в среде выполнения не связан адрес ни одной переменной, поля const не могут передаваться по ссылке и отображаться в выражении как левостороннее значение.
Константы. Ключевое слово const. C++ для начинающих. Урок #6.
Будьте внимательны, ссылаясь на постоянные значения, определенные в другом коде, например, в DLL. Если в новой версии DLL для константы определяется новое значение, старое значение литерала хранится в вашей программе вплоть до повторной компиляции для новой версии.
Несколько констант одного типа можно объявить одновременно, например:
class Calendar2
Выражение, которое используется для инициализации константы, может ссылаться на другую константу, если не создает циклическую ссылку. Пример:
class Calendar3 < public const int Months = 12; public const int Weeks = 52; public const int Days = 365; public const double DaysPerWeek = (double) Days / (double) Weeks; public const double DaysPerMonth = (double) Days / (double) Months; >
Константы могут иметь пометку public, private, protected, internal, protected internal или private protected. Эти модификаторы доступа определяют, каким образом пользователи класса смогут получать доступ к константе. Дополнительные сведения см. в разделе Модификаторы доступа.
Доступ к константам осуществляется так, как если бы они были статическими полями, поскольку значение константы одинаково для всех экземпляров типа. Для их объявления используйте ключевое слово static . Выражения, которые не относятся к классу, определяющему константу, должны включать имя класса, период и имя константы для доступа к этой константе. Пример:
int birthstones = Calendar.Months;
Спецификация языка C#
Дополнительные сведения см. в спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.
Константы и переменные
См. также
- Руководство по программированию на C#
- Свойства
- Типы
- readonly
- Immutability in C# Part One: Kinds of Immutability (Неизменность в C#, часть 1. Виды неизменности)
Источник: learn.microsoft.com
Где в программе назначаются константы
Для хранения данных в программе применяются переменные . Переменная представляет именнованную область памяти, в которой хранится значение определенного типа. Переменная имеет тип, имя и значение. Тип определяет, какого рода информацию может хранить переменная.
Перед использованием любую переменную надо определить. Синтаксис определения переменной выглядит следующим образом:
тип имя_переменной;
Вначале идет тип переменной, потом ее имя. В качестве имени переменной может выступать любое произвольное название, которое удовлетворяет следующим требованиям:
- имя может содержать любые цифры, буквы и символ подчеркивания, при этом первый символ в имени должен быть буквой или символом подчеркивания
- в имени не должно быть знаков пунктуации и пробелов
- имя не может быть ключевым словом языка C#. Таких слов не так много, и при работе в Visual Studio среда разработки подсвечивает ключевые слова синим цветом.
Хотя имя переменой может быть любым, но следует давать переменным описательные имена, которые будут говорить об их предназначении.
Например, определим простейшую переменную:
string name;
В данном случае определена переменная name, которая имеет тип string . то есть переменная представляет строку. Поскольку определение переменной представляет собой инструкцию, то после него ставится точка с запятой.
При этом следует учитывать, что C# является регистрозависимым языком, поэтому следующие два определения переменных будут представлять две разные переменные:
string name; string Name;
После определения переменной можно присвоить некоторое значение:
string name; name = «Tom»;
Так как переменная name представляет тип string, то есть строку, то мы можем присвоить ей строку в двойных кавычках. Причем переменной можно присвоить только то значение, которое соответствует ее типу.
В дальнейшем с помощью имени переменной мы сможем обращаться к той области памяти, в которой хранится ее значение.
Также мы можем сразу при определении присвоить переменной значение. Данный прием называется инициализацией:
string name = «Tom»;
Отличительной чертой переменных является то, что в программе можно многократно менять их значение. Например, создадим небольшую программу, в которой определим переменную, поменяем ее значение и выведем его на консоль:
string name = «Tom»; // определяем переменную и инициализируем ее Console.WriteLine(name); // Tom name = «Bob»; // меняем значение переменной Console.WriteLine(name); // Bob
Консольный вывод программы:
Tom Bob
Константы
Отличительной особенностью переменных является то, что мы можем изменить их значение в процессе работы программы. Но, кроме того, в C# есть константы. Константа должна быть обязательно инициализирована при определении, и после определения значение константы не может быть изменено
Константы предназначены для описания таких значений, которые не должны изменяться в программе. Для определения констант используется ключевое слово const , которое указывается перед типом константы:
const string NAME = «Tom»; // определяем константу
Так, в данном случае определена константа NAME , которая хранит строку «Tom». Нередко для название констант используется верхний регистр, но это не более чем условность.
При использовании констант надо помнить, что объявить мы их можем только один раз и что к моменту компиляции они должны быть определены. Так, в следующем случае мы получим ошибку, так как константе не присвоено начальное значение:
const string NAME; // ! Ошибка — константа NAME не инициализирована
Кроме того, мы ее не сможем изменить в процессе работы программы:
const string NAME = «Tom»; // определяем константу NAME = «Bob»; // !Ошибка — у констаты нельзя изменить значение
Таким образом, если нам надо хранить в программе некоторые данные, но их не следует изменить, они определяются в виде констант. Если же их можно изменять, то они определяются в виде переменных.
Источник: metanit.com
6. Переменные и константы
Переменные и константы позволяют нам сохранить какие-либо данные в памяти, чтобы, при необходимости, быстро их получить для совершения каких-либо операции над ними.
Как это работает
Сначала мы придумываем какое-нибудь имя для переменной (или константы), например,
x-color. Затем связываем её со значением, например, «orange» (или #FF6633 в шестнадцатеричной системе или (255, 102, 51) в RGB). При этом язык программирования записывает «orange» в оперативную память, а в переменную записывается адрес этого участка памяти. В итоге, если мы требуем распечатать значение переменной x-color, компьютер отыскивает эту переменную, смотрит по какому адресу нужно идти в память и забирает оттуда значение «orange» и выводит его.
Константы
Иногда возникает необходимость где-то записать некое неизменяемое значение, чтобы не запоминать его, а затем использовать по необходимости. Например, число π ≈ 3.141592653589793. Запишем его в программе и выведем в консоль.
fn main() < const PI: f64 = 3.141592653589793; println!(«Число Пи <>», PI); >
Результат: Число Пи 3.141592653589793
В данном примере константа PI имеет тип f64 и ей присваивается значение 3.141592653589793.
Знак = это специальный оператор присваивания. Не называйте его словом “равно”, иначе потом будете путаться. Для проверки равенства используется двойной знак равно ==.
Общий синтаксис объявления констант:
const NAME_CONST: type = value;
Имя константы пишется заглавными буквами с разделением слов символом подчеркивания (SCREAMING_SNAKE_CASE).
Особенности констант
- Константы неизменяемы.
- Значение константы должно быть известно перед запуском программы.
Следующие 2 пункта просто запомните, суть поймете в следующих лекциях:
- Константы существуют в локальной и в глобальной области видимости.
- Константы незатеняемы.
Переменные
Основное отличие переменной от константы в том, что переменная может быть вычислена во время выполнения программы. Например, у нас есть потребность часто использовать в расчетах куб числа π. Для этого мы один раз его вычислим и начнем использовать в расчетах, экономя процессорное время.
fn main() < const PI: f64 = 3.141592653589793; let pi_cube: f64 = PI * PI * PI; println!(«Число Пи в кубе<>», pi_cube); >
Результат: Число Пи в кубе 31.006276680299816
В данном примере переменная pi_cube, как и константа PI, имеет тип 64-битное число с плавающей запятой.
Общий синтаксис объявления переменных:
а) Объявляем переменную и присваиваем ей значение
let name_variable: type = value;
б) Только объявляем переменную, а значение присваиваем позже:
let name_variable: type; name_variable = value;
в) Можно одновременно объявить сразу несколько переменных и присвоить им значения:
let (name_variable1, name_variable2): (type1, type2) = (value1, value2);
В некоторых случаях это может быть удобным. Также можно и не указывать типы данных, тогда компилятор определит их самостоятельно.
Имя переменной пишется строчными буквами с разделением символом подчеркивания (snake_case).
Итак, мы посмотрели на переменные, но чем же они отличаются от констант?
Особенности переменных
Переменные отличаются от констант:
- Значение переменной может быть установлено после начала исполнения программы.
- Переменные можно изменять.
Следующие 2 пункта просто запомните, суть поймете в следующих лекциях:
- Переменные существуют только в локальной области видимости.
- Переменные можно затенять.
Пример использования констант и переменных
Давайте напишем программу, которая будет вычислять и выводить в консоль длину окружности. Радиус зададим в переменной в самой программе. Результат округлим до сотых.
fn main() < const PI: f64 = 3.141592653589793; let radius: f64 = 90.0; let circumference: f64 = PI * 2.0 * radius; println!( «Длина окружности с радиусом <>равна «, radius, circumference ); >
Результат: Длина окружности с радиусом 90 равна 565.49
Это очень простая задача. У нас есть константа числа π , есть радиус окружности и нам остается только вычислить и вывести длину окружности
Полагаю, вы уже обратили внимание на то, что для типа данных float64 необходимо и в самих числах указывать точку. Ноль после точки ставить не обязательно, так просто привычнее.
Для округления в данном случае использовалось форматирование при выводе (ранее давалась ссылка на документацию https://doc.rust-lang.org/std/fmt/).
Изменяемые переменные (Variable Mutable)
По умолчанию переменные неизменяемые. Это необходимо для того, чтобы компилятор, имея гарантии неизменяемости, мог создать более оптимальный машинный код.
В учебных материалах встречаются термины: иммутабельные (immutable – неизменяемые) и мутабельные (mutable – изменяемые) переменные.
Давайте усложним код предыдущей задачи, вычисляя длину окружности повторно, для окружности с другим радиусом. Для красоты отделим объявление переменных от присваивания им значений.
fn main() < const PI: f64 = 3.141592653589793; let mut radius: f64; let mut circumference: f64; radius = 90.0; circumference = PI * 2.0 * radius; println!(«Длина окружности с радиусом <>равна «, radius, circumference); radius = 120.0; circumference = PI * 2.0 * radius; println!(«Длина окружности с радиусом <> равна «, radius, circumference); >
Результат: Длина окружности с радиусом 90 равна 565.49 Длина окружности с радиусом 120 равна 753.98
В данном случае мы изменяли значения переменных потому, что сделали их изменяемыми. Попробуйте убрать слово mut и прочитайте сообщение об ошибке.
Затенение переменных
Давайте возьмем ту же задачу. Переменные сделаем неизменяемыми, но объявим их второй раз.
fn main() < const PI: f64 = 3.141592653589793; let radius: f64 = 90.0; let circumference: f64 = PI * 2.0 * radius; println!(«Длина окружности с радиусом <>равна «, radius, circumference); let radius: f64 = 120.0; let circumference: f64 = PI * 2.0 * radius; println!(«Длина окружности с радиусом <> равна «, radius, circumference); >
Результат: Длина окружности с радиусом 90 равна 565.49 Длина окружности с радиусом 120 равна 753.98
В данном случае мы вновь объявили переменные с тем же именем. При этом, были созданы новые переменные с такими же именами. Так как сделано в этом примере поступать не следует, но нам следует изучить все возможности языка Rust.
Возможность затенения необходима для написания независимого локального кода в котором мы случайно можем использовать ранее использованные наименования переменных. Дальнейшая глава прольет немного света на то, для чего создан такой механизм.
Область видимости переменных
Область видимости, это область действия переменных или, другими словами, область доступности переменных.
Локальная переменная – переменная, находящаяся внутри блока кода ограниченного фигурными скобками <>. Вне этого блока доступ к переменной невозможен, т.к. после закрывающей фигурной скобки > переменная освобождается, и память, в которой хранилось значение, тоже освобождается.
Глобальная переменная – это относительное понятие, переменная глобальна по отношению к рассматриваемой части кода, если она был объявлена ранее вне этого блока кода.
Лучше посмотреть на примере:
fn main() < let x = 5; println!(«Изначально x равен «); < let x = x * 2; println!(«Внутри скобок другой x равен «); let y = 9; println!(«Внутри скобок y равен «); > println!(«За скобками x снова равен: «); println!(«За скобками y недоступен»); // println!(«За скобками y равен «); >
Изначально x равен 5 Внутри скобок другой x равен 10 Внутри скобок y равен 9 За скобками x снова равен: 5 За скобками y недоступен
Сначала мы создали переменную
и связали её со значением в
в оперативной памяти компьютера. Далее, внутри вложенных скобок мы создали вторую переменную
, которую связали с вычисленным значением
Источник: rusteon.ru