Переменные
Синтаксис объявления переменных в 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# достаточно просто определить области видимости переменных, поскольку они отделены фигурными скобками “<” и “>”, которые указывают на начало и конец блока кода.
Выходит переменная может войти во вложенные фигурные скобки с высшего уровня, но не может за пределы скобок в которых она объявлена.