Как объявить переменную в си шарп
Перейти к содержимому

Как объявить переменную в си шарп

  • автор:

Как объявить глобальную переменную в c#?

Основная ошибка — если начали использовать объекты, то откажитесь от идеи использовать статичность и глобальность. Когда разберётесь с объектами, то поймёте где иногда нужна статичность. Так, что убирайте static из ваших классов (как оно вообще скомпилировалось?)

public class car < public int carmode; public int fueltype; public int rashod; public int bak; public string ftype,cmode; >public class car95:car < public car95(int CRM, int b) < bak = b; carmode = CRM; fueltype = 95; rashod = 10 + carmode; >> 

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

if (fuel == 95)

У переменной auto область видимости < car95 auto = new car95(mode, 50); >и всё! Не ранее, не позднее к ней не обратиться. Можно 1 , т.к. форма на которой у вас кнопка button1 это тоже объект, завести поле в форме.

public class Form1 : Form < private car auto; . . private void button1_Click(object sender, EventArgs e) < if (fuel == 95) < auto = new car95(mode, 50); >if (fuel == 100) < auto = new cardt(mode, 50); >if (fuel == 200) < auto = new cargas(mode, 50); >> > 

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

Ну и нельзя не упомянуть:

  1. Реализация на форме логики, несвязанной с UI (интерфейс пользователя), не рекомендуется. Лучше отделять логику приложения от работы с UI. Хабрахабр. Паттерны для новичков: MVC vs MVP vs MVVM
  2. Хоть это и спорный момент, но всё-таки есть Соглашения о написании кода на C# , которые Ваш код и мои поправки нарушают.
  3. Странно, что у Вас столько int используется. Попробуйте enum Краткий обзор языка C#. Перечисления
  4. Публичные поля тоже не рекомендуется использовать, когда разберётесь используйте публичные свойства вместо них. Для чего нужны свойства?
  5. А здесь (Как объявить глобальную переменную уровня проекта) есть ответ про глобальные переменные.

Урок #3 – Переменные и типы данных в языке C#

Урок #3 – Переменные и типы данных в языке C#

Одним из главных нюансов любого языка программирования являются переменные. В ходе урока мы изучим работу с переменными в языке C# и научимся использовать их на практике. Дополнительно мы познакомимся с типами данных для переменных.

Видеоурок

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

Переменные

Типы переменных в языке C# указываются перед названием переменной. От конкретного типа данных будет зависеть содержимое переменной. Если мы укажем что переменная с типом данных int (целые числа), то в неё мы не сможем записать строку или число с точкой.

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

float some_value = 2.95f; some_value = 6.9f; // Записали новое значение

Рассмотрим все типы данных для создания переменных.

Целые числа

  • byte — предназначен для хранения целых чисел. Диапазон чисел от 0 до 255, если число будет большим 255 или меньшим 0 – выдастся ошибка;
  • short — предназначен для хранения целых чисел. Диапазон чисел от -32 768 до 32 767;
  • ushort — предназначен для хранения целых положительных чисел. Диапазон чисел от 0 до 65 535;
  • int — предназначен для хранения целых чисел. Диапазон чисел от -2147483648 до 2147483647;
  • long — предназначен для хранения целых чисел. Диапазон чисел от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807.

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

Числа с точкой

  • float — для создания чисел с плавающей точкой. Диапазон чисел от от -3.4*10 38 до 3.4*10 38 ;
  • double — для создания чисел с плавающей точкой. Диапазон чисел от от ±4.9*10 -324 до ±1.8*10 308 .

Прочие типы данных

  • bool — логический тип данных. Предназначен для записи истинного (true) или ложного (false) значения;
  • char — тип данных для работы с символами. Позволяет поместить в одинарных кавычках какой-либо символ;
  • string — тип данных для текста. В двойных кавычках можно сохранить одно или множество слов.

Типы данных в языке С# в формате таблицы:

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

int a = 0; // Добавление значения сразу byte c; // Создание переменной без значения short b, y = 342; // Создание нескольких переменных

Для вызова переменной вы можете обратиться к ней по имени. Чтобы записать данные в переменную с типом float или double необходимо после числа дописать букву f или d соответсвенно.

Весь код будет доступен после подписки на проект!

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

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

Как объявляются переменные

int age;

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

Мы можем присвоить переменной значение позже следующим образом:

int age; . . . age = 24; 

Но переменную можно инициализировать и сразу при объявлении:

int age;

В этом примере мы объявляем переменную age типа int и в это же время инициализируем ее значением 24.

Мы также можем менять значения переменных. Например:

int age = 24; age = 35; 

Мы поменяли значение переменной age с 24 на 35.

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

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

Так — не получится

int age; age = 24; . . . float age; 

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

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

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

var value = 5;

Компилятор выводит тип данных из значения, которое присваивается переменной. В примере выше value типа int . То же самое можно написать и так:

int value; value = 5;

Здесь можно узнать больше о неявно типизированных локальных переменных.

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

Есть некоторые правила, которых мы должны придерживаться при именовании переменных:

  1. Имя переменной может содержать только буквы (строчные и прописные), нижнее подчеркивание _ и цифры.
  2. Имя переменной должно начинаться с буквы, нижнего подчеркивания или символа @ .
  3. C# чувствителен к регистру: age и Age — две разные переменные.
  4. Имя переменной не должно совпадать с ключевыми словами. for , if или using не могут быть именем переменной.

Имена переменных

Замечания

Допустимо. Лучший способ называния переменных для членов с модификатором private .

Допустимо. Используется, если имя — зарезервированное ключевое слово.

Недопустимо. Начинается с цифры.

Недопустимо. Содержит пробел.

Как правильно называть переменные

  1. Имя переменной должно иметь смысл. name , age , subject понятнее, чем n , a и s .
  2. Используйте camelCase со строчной буквы для локальных переменных. Например, numberOfStudents , age и т. д.
  3. Используйте PascalCase или CamelCase с прописной буквы для членов с модификатором public. Например, FirstName , Price и т.д.
  4. Используйте нижнее подчеркивание и названия в camelCase для именования членов с модификатором private. Например, _bankBalance , _emailAddress и т.д.

СodeСhick.io — простой и эффективный способ изучения программирования.

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

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

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

Идентификатор — это имя сущности в коде. Существует стандарт именования идентификаторов, который следует использовать в коде.
Идентификатор может :
— начинаться с символа «_»;
— содержать заглавные и строчные буквы в формате Unicode;
— регистр имеет значение.
Идентификатор не может :
— начинаться с цифры;
— начинаться с символа, если это ключевое слово;
— содержать более 511 символов.
По соглашению (не обязательно, но желательно):
1. Параметры, локальные переменные и частные (private) свойства и методы пишутся в camel case (слова пишутся слитно, без пробелов и нижних подчеркиваний, каждое новое слово кроме первого с заглавной буквы, например, myVariable).
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(«», c);

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

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

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

Теперь некоторое отступление от строгих правил, привыкайте и к исключениям (по англ. — Exception). Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется.
Такая переменная называется неявно типизированной. Неявно типизированная переменная объявляется с помощью ключевого слова var и должна быть непременно инициализирована.
Для определения типа этой переменной компилятору служит тип ее инициализатора, то есть значения, которым она инициализируется:
var n = 12; // переменная n инициализируется целочисленным литералом
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. Константы позволяют избежать ошибок в программах. Если попытаться присвоить новое значение константе где-то в другом месте программы, а не там, где она объявлена, компилятор выдаст сообщение об ошибке.

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

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

NEW: Наш Чат, в котором вы можете обсудить любые вопросы, идеи, поделиться опытом или связаться с администраторами.

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

Ваш адрес email не будет опубликован. Обязательные поля помечены *