Что такое переменная в си шарпе

Переменные

Синтаксис объявления переменных в C# выглядит следующим образом:

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

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

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

Задать значение переменной можно, в частности, с помощью оператора присваивания. Кроме того, задать начальное значение переменной можно при ее объявлении. Для этого после имени переменной указывается знак равенства (=) и присваиваемое значение. Если две или более переменные одного и того же типа объявляются списком, разделяемым запятыми, то этим переменным можно задать, например, начальное значение. Ниже приведена общая форма инициализации переменной:

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

В C# используются два метода для обеспечения инициализации переменных перед пользованием:

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

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

Например, в C# поступить следующим образом нельзя:

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

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

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

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

Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется. Такая переменная называется .

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

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

Неявно типизированные переменные внедрены в C# не для того, чтобы заменить собой обычные объявления переменных. Напротив, неявно типизированные переменные предназначены для особых случаев, и самый примечательный из них имеет отношение к языку интегрированных запросов (LINQ). Таким образом, большинство объявлений переменных должно и впредь оставаться явно типизированными, поскольку они облегчают чтение и понимание исходного текста программы.

Давайте рассмотрим пример, где в консоль будем выводить типы неявно типизированных переменных:

C # — Переменные

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

Основные типы значений, представленные в C #, можно классифицировать как —

Тип Пример
Интегральные типы sbyte, byte, short, ushort, int, uint, long, ulong и char
Типы с плавающей точкой поплавок и двойной
Десятичные типы десятичная дробь
Булевы типы true или false, как указано
Неверные типы Ненужные типы данных

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

Определение переменных

Синтаксис для определения переменной в C # —

Здесь data_type должен быть допустимым типом данных C #, включая char, int, float, double или любой пользовательский тип данных, а переменная_list может состоять из одного или нескольких имен идентификаторов, разделенных запятыми.

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

Вы можете инициализировать переменную во время определения как —

Инициализация переменных

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

Переменные могут быть инициализированы в их объявлении. Инициализатор состоит из знака равенства, за которым следует постоянное выражение as —

Хорошая практика программирования — правильно инициализировать переменные, иначе программа может вызвать неожиданный результат.

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

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

Принятие значений от пользователя

Класс Console в пространстве имен System предоставляет функцию ReadLine () для принятия ввода от пользователя и сохранения ее в переменной.

Функция Convert.ToInt32 () преобразует данные, введенные пользователем в тип данных int, потому что Console.ReadLine ()принимает данные в строчном формате.

Выражения Lvalue и Rvalue в C #

В C # есть два вида выражений —

  • lvalue — выражение, которое является lvalue, может отображаться как в левой, так и в правой части задания.
  • rvalue — выражение, которое является rvalue, может отображаться справа, но не в левой части задания.

Переменные являются значениями lvalues ​​и, следовательно, они могут отображаться в левой части задания. Числовые литералы — это значения и, следовательно, они не могут быть назначены и не могут появляться с левой стороны. Ниже приведен действительный оператор C #

Но следующее не является допустимым оператором и генерирует ошибку времени компиляции —

Переменные

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

Правила именования переменных

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

В языке C# это можно сделать следующим образом: "тип данных" "имя переменной"; , сперва указан тип данных, который храниться в переменной, а за ним имя.

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

  • начинаться со знака подчеркивания “_“, или Unicode символа(да, в своих приложениях вы можете называть переменные именами, которые состоят из символов национального алфавита);
  • может содержать Unicode символы, цифры и знак подчеркивания;
  • в именах запрещено использовать специальные символы, пробелы, знаки пунктуации;
  • имена не должны совпадать с зарезервированными словами языка программирования C#.
abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
event explicit extern false
finally fixed float for
foreach goto if implicit
in int interface internal
is lock long namespace
new null object operator
out override params private
protected public readonly ref
return sbyte sealed short
sizeof stackalloc static string
struct switch this throw
true try typeof uint
ulong unchecked unsafe ushort
using using static virtual void
volatile while

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

Пример объявления переменных:

Здесь мы определили две переменные, первая типа строка с именем text, вторая – целое число с именем number.

Если возникает необходимость использовать одно из зарезервированных слов в названии переменной, вы можете это сделать, написав перед именем символ “@”. Например int @while; .

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

После того, как вы объявили переменную, можно присвоить ей значение. Для этого используется оператор присваивания – “=”

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

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

Не смотря на то, что C# позволяет использовать в названиях переменных Unicode символы, в частности русские, правила хорошего тона рекомендуют использовать в именах исключительно английские буквы. Потому, что национальные символы усложняют работу с кодом программы, а иногда могут вызвать дисонанс, когда символы визуально идентичны, а их коды разные(к примеру русская буква “с” и английская “c”).

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

Область видимости или контекст переменной (scope) – это часть программы, в пределах которой, идентификатор остается связанным с данными в памяти, то есть позволяет через себя обращаться к данным.

В C# достаточно просто определить области видимости переменных, поскольку они отделены фигурными скобками “<” и “>”, которые указывают на начало и конец блока кода.

Выходит переменная может войти во вложенные фигурные скобки с высшего уровня, но не может за пределы скобок в которых она объявлена.

Добавить комментарий

Ваш адрес email не будет опубликован.