Remkomplekty.ru

IT Новости из мира ПК
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Константа в си шарп

Область видимости переменных, константы

C# — Руководство по C# — Область видимости переменных, константы

Область видимости переменных

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

Поле, также известное как переменная-член класса, находится в области видимости до тех пор, пока в этой области находится содержащий поле класс.

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

Локальная переменная, объявленная в операторах цикла for, while или подобных им, видима в пределах тела цикла.

Конфликты областей видимости локальных переменных

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

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

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

Вот другой пример:

Если вы попытаетесь скомпилировать это, то получите следующее сообщение об ошибке:

ScopeTest.cs (12,15) : error CS0136: A local variable named ‘3’ cannot be declared in this scope because it would give a different meaning to ‘j’, which is already used in a ‘parent or current’ scope to denote something else

Дело в том, что переменная j, которая определена перед началом цикла for, внутри цикла все еще находится в области видимости и не может из нее выйти до завершения метода Main(). Хотя вторая переменная j (недопустимая) объявлена в контексте цикла, этот контекст вложен в контекст метода Main(). Компилятор не может различить эти две переменных, поэтому не допустит объявления второй из них.

Конфликты областей видимости полей и локальных переменных

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

Этот код компилируется, несмотря на то, что здесь в контексте метода Main() присутствуют две переменных с именем j: переменная j, определенная на уровне класса и существующая до тех пор, пока не будет уничтожен класс (когда завершится метод Main(), а вместе с ним и программа), и переменная j, определенная внутри Main(). В данном случае новая переменная с именем j, объявленная в методе Main(), скрывает переменную уровня класса с тем же именем. Поэтому когда вы запустите этот код, на дисплее будет отображено число 30.

Константы

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

Ниже перечислены основные характеристики констант:

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

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

Константы всегда неявно статические. Однако вы не должны (и фактически не можете) включать модификатор static в объявление константы.

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

Константы облегчают чтение программ, заменяя «магические» числа и строки читаемыми именами, назначение которых легко понять.

Константы облегчают модификацию программ. Например, предположим, что в программе C# имеется константа SalesTax (налог с продаж), которой присвоено значение 6 процентов. Если налог с продаж когда-нибудь изменится, вы можете модифицировать все вычисления налога, просто присвоив новое значение этой константе, и не понадобится просматривать код в поисках значений и изменять каждое из них, надеясь, что оно нигде не будет пропущено.

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

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

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

Рассмотрим эти понятия на примерах.

Идентификатор — это имя сущности в коде. Существует стандарт именования идентификаторов, который следует использовать в коде.
Идентификатор может :
— начинаться с символа «_»;
— содержать заглавные и строчные буквы в формате Unicode;
— регистр имеет значение.
Идентификатор не может :
— начинаться с цифры;
— начинаться с символа, если это ключевое слово;
— содержать более 511 символов.
По соглашению (не обязательно, но желательно):
1. Параметры, локальные переменные и частные (private) свойства и методы пишутся в camel case (слова пишутся слитно, без пробелов и нижних подчеркиваний, каждое новое слово кроме первого с заглавной буквы, например, myVariavle).
2. Все остальные идентификаторы — в стиле Pascal case (тоже самое, что и camel case, только первое слово с заглавной буквы, например, MyClass).
Мое примечание к подсказке. Вы можете использовать кроме латинских (английских) букв и буквы русского алфавита (как, впрочем и других национальных алфавитов), однако не увлекайтесь этим. Более привычно, когда в идентификаторе используются буквы английского алфавита, цифры и символ подчеркивания (прежний стандарт).

Читать еще:  Код хемминга паскаль
Объявления переменных

Шаблон объявления переменной в C# выглядит следующим образом:
ТипДанных Идентификатор;
Например:
int k1;
System.Int32 _counter;
Int32 счетчик;

Все три переменных: k1, _counter, счетчик являются переменными одного типа, занимают в памяти 4 байта.

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

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

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

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

Инициализация переменной

Задать значение переменной можно, в частности, с помощью оператора присваивания. Кроме того, задать начальное значение переменной можно при ее объявлении. Для этого после имени переменной указывается знак равенства (=) и присваиваемое значение. Если две или более переменные одного и того же типа объявляются списком, разделяемым запятыми, то этим переменным можно задать, например, начальное значение.
Ниже приведена общая форма инициализации переменной:
int k1 = 10;
char символ = ‘Z’;
float f = 15.7F;
int x = 5, y = 10, z = 12;

// — инициализируем несколько переменных одного типа.
Инициализация переменных демонстрирует пример обеспечения безопасности C#. Коротко говоря, компилятор C# требует, чтобы любая переменная была инициализирована некоторым начальным значением, прежде чем можно было обратиться к ней в какой-то операции.
В большинстве современных компиляторов нарушение этого правила определяется и выдается соответствующее предупреждение, но «всевидящий» компилятор C# трактует такие нарушения как ошибки. Это предохраняет от нечаянного получения значений «мусора» из памяти, оставшегося там от других программ.

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

Например, в C# поступить следующим образом нельзя:
public static int принт()
<
int d;
Console.WriteLine(d); return 0;
>

Получим при компиляции сообщение об ошибке: Использование локальной переменной “d”, которой не присвоено значение.

Динамическая инициализация

В приведенных выше примерах в качестве инициализаторов переменных использовались только константы, но в C# допускается также динамическая инициализация переменных с помощью любого выражения, действительного на момент объявления переменной:
int a = 3, b = 4;
// Инициализируем динамически переменную c:
double c = Math.Sqrt(a * a + b * b);
Console.WriteLine(«<0>», c);

В данном примере объявляются три локальные переменные a,b,c, первые две из которых инициализируются константами, а переменная c инициализируется динамически с использованием метода Math.Sqrt(), возвращающего квадратный корень выражения.

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

Неявно типизированные переменные

Теперь некоторое отступление от строгих правил, привыкайте и к исключениям (по англ. — Exception). Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется.
Такая переменная называется неявно типизированной. Неявно типизированная переменная объявляется с помощью ключевого слова var и должна быть непременно инициализирована.
Для определения типа этой переменной компилятору служит тип ее инициализатора, то есть значения, которым она инициализируется:
var n = 12; // переменная i инициализируется целочисленным литералом
var d = 12.3; // переменная d инициализируется литералом
// с плавающей точкой, имеющему тип double
var f = 0.34F; // переменная f теперь имеет тип float

Единственное отличие неявно типизированной переменной от обычной, явно типизированной переменной, — в способе определения ее типа. Как только этот тип будет определен, он закрепляется за переменной до конца ее существования.
Неявно типизированные переменные внедрены в C# не для того, чтобы заменить собой обычные объявления переменных. Напротив, неявно типизированные переменные предназначены для особых случаев, и самый примечательный из них имеет отношение к языку интегрированных запросов (LINQ).

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

Константы

Как следует из названия, константа — это переменная, значение которой не меняется за время ее существования. Предваряя переменную ключевым словом const при ее объявлении и инициализации, вы объявляете ее как константу:
const int N_max =100;
Идентификатор константы записывается по общим правилам написания идентификаторов (см. подсказку выше).
Ниже перечислены основные характеристики констант:
1. Они должны инициализироваться при объявлении, и однажды присвоенные им значения никогда не могут быть изменены.
2. Константа не может быть объявлена непосредственно в пространстве имен, но может быть объявлена либо в классе, либо в функции.
3. Значение константы должно быть вычислено во время компиляции.

Таким образом, инициализировать константу значением, взятым из другой переменной, нельзя. Если все-таки нужно это сделать, используйте поля только для чтения.
Константы всегда неявно статические. Нет необходимости включать модификатор static в объявление константы.
Использование констант в программах обеспечивает, по крайней мере, три преимущества:
1. Константы облегчают чтение программ, заменяя «магические» числа и строки читаемыми именами, назначение которых легко понять. Например, через константу N_max может задать максимальное количество элементов в массиве объектов, при необходимости это число может быть изменено всего лишь в одном операторе объявления константы.
2. Константы облегчают модификацию программ. Например, предположим, что в программе C# имеется константа IncomeTax (подоходный налог), которой присвоено значение 13 процентов. Если налог когда-нибудь изменится, вы можете модифицировать все вычисления налога, просто присвоив новое значение этой константе, и не понадобится просматривать код в поисках значений и изменять каждое из них, надеясь, что оно нигде не будет пропущено.
3. Константы позволяют избежать ошибок в программах. Если попытаться присвоить новое значение константе где-то в другом месте программы, а не там, где она объявлена, компилятор выдаст сообщение об ошибке.

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

Следующая небольшая тема раздела: Область видимости переменных

BestProg

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

Содержание

1. Для чего в программе используются константы и переменные?

Константы и переменные есть основными объектами, которые используются в программе. Константы и переменные – это именованные объекты, для которых выделяется память.

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

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

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

2. Каким образом в C# объявляется константа? Примеры объявление констант.

Константа объявляется с помощью оператора следующей формы:

const ключевое слово, которое определяет что именно это есть константа; тип – тип данных, которые сохраняются в константе; имя_константы – имя константы; значение – значение константы, которое есть неизменяемым в программе.

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

3. Как в программе объявляется переменная? Примеры объявления переменных.

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

где тип – это тип данных, которые сохраняются в переменной; а имя_переменной – это ее имя.

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

Пример объявления переменной, которая имеет значимый тип.

4. Пример объявления переменной, которая есть структурой.

В языке C# структура относится к типу-значению а не к типу-классу.

Пример описания переменной, которая есть структурой типа MyPoint . Структура MyPoint определяет координаты точки на плоскости.

5. Пример объявления переменной которая есть перечислением.

В следующем примере объявляется переменная типа Months , которая есть перечислением.

6. Как осуществляется инициализация переменной? Примеры инициализации переменных.

Инициализация позволяет задать начальное значение переменной при ее объявлении.

Общая форма инициализации переменной имеет следующий вид:

где тип – это тип данных, которые сохраняются в переменной; имя_переменной – это ее имя; значение – это конкретное значение, которое задается при создании переменной.

Примеры инициализации переменных:

Можно осуществлять инициализацию переменных выборочно. Например:

7. Как в C# реализуется динамическая инициализация переменных?

При динамической инициализации переменной в качестве инициализаторов используются не константы (литералы) а выражения. Эти выражения на момент объявления переменной должны быть действительными.

8. Как в C# описываются неявно типизированные переменные?

Начиная с версии C# 3.0 компилятор имеет возможность самостоятельно определять тип локальной переменной. Этот тип определяется на основе значения, которым переменная инициализируется. Значению соответствует некоторый литерал , что описывается согласно синтаксису языка C# .

Такая переменная называется неявно типизированной.

Для объявления неявно типизированной переменной используется ключевое слово var . В этом случае инициализация переменной есть обязательной.

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

var – ключевое слово; имя_переменной – это имя переменной; значение – это конкретное значение, которое задается при создании переменной.

Примеры описания неявно типизированных переменных:

9. Сколько неявно типизированных переменных можно описывать одновременно?

Одновременно можно описывать только одну типизированную переменную.

При следующем описании будет ошибка, так как описаны две переменные:

10. Пример описания неявно типизированной переменной, которая есть перечислением.

Пример описания неявно типизированной переменной, которая есть перечислением типа DaysOfWeek .

11. Что определяет область действия локальной переменной?

Область действия локальной переменной определяется блоком кода. Блок кода начинается с фигурной открытой скобки ‘ < ‘и заканчивается фигурной закрытой скобкой ‘ > ‘.

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

В C# область действия определяется классом или методом.

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

Константа в си шарп

Как с помощью констант так и с помощью полей только для чтения (readonly fields) можно добиться одной и той же цели — инициализировать поле обьекта при его создании неким значением, которое гарантированно не будет изменено при дальнейшей жизни этого обьекта. Но эти два способа сильно отличаются друг от друга. В этой статье я попытаюсь доступно рассказать про эти отличия.

Статичность

Константы являются не явно статическими и вы не можете обьявить их с ключевым словом static — вы получите ошибку компилятора.
В отличие от констант, поля для чтения не являются неявно статическими, и если вы хотите сделать их таковыми, то ключевое слово static нужно добавлять вручную.
Это позволяет сделать вывод, что константы являются неизменяемыми только на уровне типа, в то время как поля только для чтения могут быть неизменными как на уровне типа так и на уровне конкретного объекта. Пример кода ниже демонстрирует сказанное:

Момент задания значения

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

Интересным фактом является то, что при inline инициализации поля только для чтения компилятор подставит эту инициализацию в начало тела конструктора (экземплярного или статического в зависимости от типа самого поля). Следует помнить про этот ньюанс, так как иногда можно получить непредвиденный результат. Следующий код демонстрирует сказанное выше:

Проблема версий

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

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

Типы полей

Константы могут иметь только такие типы, которые ваш компилятор воспринимает как примитивные. В C# следующие типы являются примитивными и могут быть использованы для определения констант: Boolean, Char, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64,UInt64, Single, Double, Decimal, и String. Тем не менее, C# также позволяет определить константу не примитивного типа, но при условии, что ей будет присвоено значение null.

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

Обучение C#

Формула программиста

Работая с этим сайтом, Вы даете согласие на использование файлов Cookie.

Типы данных

Если переменная объявлена без инициализации, ей присваивается значение по умолчанию, равное 0.

Целочисленные данные

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

Логические данные

Логические данные представлены логическим типом bool . Несмотря на то, что данные логического типа могут принимать только одно из двух значений True или False , объем памяти, отводимый для хранения логических переменных составляет 1 байт.

Вещественные данные

Представление вещественного числа со знаком включает в себя целую часть, дробную часть и порядок числа.
По умолчанию все вещественные константы имеют тип double . Если последним символом константы указан суффикс f или F, константа имеет тип float . Если последним символом константы указан суффикс m или M, константа имеет тип decimal .
В силу особенностей представления вещественных чисел в разрядной сетке вычислительной машины, при работе с вещественными числами могут возникнуть проблемы, связанные с точностью их представления. Наименьшее целое вещественное число, которое может быть представлено в разрядной сетке float или double определяется константным полем Epsilon этих типов.
Тип decimal обладает более точным и узким диапазоном по сравнению с типами float и double , и поэтому больше подходит для использования в финансовых расчетах.

Символьные данные

Все символьные представления констант заключаются в апострофы » .

Строковые данные

Несмотря на то, что строковый тип данных не является простым, он является встроенным типом языка C#. Строковый тип данных string позволяет создавать строки любой длины, для инициализации которых используется последовательность символов, заключенная в кавычки «. » . Тип данных string также содержит ряд методов для обработки строковых данных.

Закрепить использование базовых типов данных Вы можете в разделе Типы данных курса Алгоритмика

Автор: Вставская Елена Владимировна

Начинаем практику по языку C#

Чтобы стать хорошим программистом — нужно писать программы. На нашем сайте очень много практических упражнений.

После заполнения формы ты будешь подписан на рассылку «C# Вебинары и Видеоуроки», у тебя появится доступ к видеоурокам и консольным задачам.

Несколько раз в неделю тебе будут приходить письма — приглашения на вебинары, информация об акциях и скидках, полезная информация по C#.

Ты в любой момент сможешь отписаться от рассылки.

Основатель проекта

Вебинары C#

+ Бесплатно, каждую субботу
+ Создание программ с нуля
+ Решение консольных задач

Видео-уроки

+ 300 практических видеоуроков
+ 400 интерактивных задач
+ Видео-решения и разбор

Миссия

Погружение в язык C#
Мотивация к изучению языка
Прокачка навыков программирования

Ссылка на основную публикацию
Adblock
detector