Объявление переменных в с: Руководство C# | Переменные

Простые объявления переменных | Microsoft Learn

Twitter LinkedIn Facebook Адрес электронной почты

• Статья
• 09/26/2022
• Чтение занимает 2 мин

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

Классы хранения или типы (или и то, и другое) требуются в объявлениях переменных. Нетипизированные переменные (например, var;) создают предупреждения.

Синтаксис

declarator:
    pointer_optdirect-declarator

direct-declarator:
    identifier

identifier:
    nondigit
    identifiernondigit
    identifierdigit

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

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

int x, y;        /* Declares two simple variables of type int */
int const z = 1; /* Declares a constant value of type int */

Переменные x и y могут содержать любое значение в наборе, определенном типом int для конкретной реализации. Простой объект z инициализируется значением 1 и не может быть изменен.

Если бы объявление z было выполнено для неинициализированной статической переменной или в области видимости файла, было бы получено начальное значение 0, которое было бы неизменяемым.

unsigned long reply, flag; /* Declares two variables
                              named reply and flag     */

В этом примере обе переменные reply и flag имеют тип unsigned long и содержат целочисленные значения без знака.

См. также

Деклараторы и объявления переменных

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

В этом уроке вы узнаете о переменных и о том, как как их объявлять в 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 не могут быть именем переменной.

Имена переменных	Замечания
name	Допустимо.
subject101	Допустимо.
_age	Допустимо. Лучший способ называния переменных для членов с модификатором private.
@break	Допустимо. Используется, если имя —  зарезервированное ключевое слово.
your_name	Допустимо.
101subject	Недопустимо. Начинается с цифры.
your name	Недопустимо. Содержит пробел.

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

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

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

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

Переменные

В программировании переменная представляет собой контейнер (область хранения) для хранения данных.

Для обозначения области хранения каждой переменной необходимо присвоить уникальное имя (идентификатор). Имена переменных — это просто символическое представление ячейки памяти. Например:

 int playerScore = 95; 

Здесь playerScore является переменной типа int . Здесь переменной присваивается целочисленное значение 95 .

Значение переменной может быть изменено, отсюда и название переменной.

 char ch = 'a';
// какой-то код
ч = 'л'; 

---

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

1. Имя переменной может состоять только из букв (как прописных, так и строчных), цифр и подчеркивания.
2. Первая буква переменной должна быть либо буквой, либо знаком подчеркивания.
3. Нет правила относительно длины имени переменной (идентификатора). Однако вы можете столкнуться с проблемами в некоторых компиляторах, если имя переменной длиннее 31 символа.

Примечание: Вы всегда должны пытаться давать осмысленные имена переменным. Например: firstName является лучшим именем переменной, чем fn .

C — строго типизированный язык. Это означает, что тип переменной не может быть изменен после ее объявления. Например:

 целое число = 5; // целочисленная переменная
число = 5,5; // ошибка
двойной номер; // ошибка 

Здесь тип переменной number — int . Вы не можете присвоить этой переменной значение с плавающей запятой (десятичное число) 5.5 . Также нельзя переопределить тип данных переменной на double . Кстати, чтобы хранить десятичные значения в C, вам нужно объявить его тип либо

double , либо float .

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

---

Литералы

Литералы – это данные, используемые для представления фиксированных значений. Их можно использовать прямо в коде. Например: 1 , 2.5 , ‘c’ и т. д.

Здесь 1 , 2.5 и ‘c’ являются литералами. Почему? Этим терминам нельзя присваивать разные значения.

---

1. Целые числа

Целое число представляет собой числовой литерал (связанный с числами) без какой-либо дробной или экспоненциальной части. В программировании на C существует три типа целочисленных литералов:

• десятичный (основание 10)
• восьмеричное (основание 8)
• шестнадцатеричный (основание 16)

Например:

Десятичные: 0, -9, 22 и т. д.
Восьмеричный: 021, 077, 033 и т. д.
Шестнадцатеричный: 0x7f, 0x2a, 0x521 и т. д. 

В программировании на C восьмеричный начинается с 0 , а шестнадцатеричный начинается с 0x .

---

2. Литералы с плавающей запятой

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

-2,0
0,0000234
-0.22E-5 

Примечание: E-5 = 10 -5

---

3. Символы

Символьный литерал создается путем заключения одинарного символа в кавычки. Например: ‘a’ , ‘m’ , ‘F’ , ‘2’ , ‘}’ и т.д.

---

символы, которые нельзя напечатать или которые имеют особое значение в программировании на C. Например: новая строка (ввод), табуляция, вопросительный знак и т. д.

Для использования этих символов используются управляющие последовательности.

Escape-последовательности

Escape-последовательности	Символ
\б	Возврат
\ф	Подача бумаги
\n	Новая строка
\r	Возврат
\т	Горизонтальная вкладка
\v	Вертикальная вкладка
\	Обратная косая черта
\'	Одинарная кавычка
\"	Двойная кавычка
\?	Вопросительный знак
\0	Нулевой символ

---

Например: \n используется для новой строки. Обратная косая черта \ вызывает переход от обычного способа обработки символов компилятором.

---

5. Строковые литералы

Строковый литерал — это последовательность символов, заключенная в двойные кавычки. Например:

"хорошо" // строковая константа
"" //пустая строковая константа
" " // строковая константа из шести пробелов
"x" // строковая константа, состоящая из одного символа.
"Земля круглая\n" //выводит строку с новой строкой 

---

Константы

Если вы хотите определить переменную, значение которой нельзя изменить, вы можете использовать ключевое слово const . Это создаст константу. Например,

 const double PI = 3,14; 

Обратите внимание, мы добавили ключевое слово const .

Здесь PI — символическая константа; его значение не может быть изменено.

 const double PI = 3,14;
ПИ = 2,9; //Ошибка 

---

Вы также можете определить константу с помощью #define директива препроцессора. Мы узнаем об этом в учебнике по макросам C.

Размещение объявления переменной в C

Как уже отмечалось, есть две точки зрения на этот счет.

1) Объявить все в верхней части функций, потому что год 1987.

2) Объявить ближайший к первому использованию и в наименьшем возможном объеме.

Мой ответ: СДЕЛАЙТЕ ОБЕ! Поясню:

Для длинных функций 1) очень усложняет рефакторинг. Если вы работаете в кодовой базе, где разработчики против идеи подпрограмм, тогда у вас будет 50 объявлений переменных в начале функции, и некоторые из них могут быть просто «i» для цикла for, который находится в самом начале. нижней части функции.

Поэтому я разработал декларацию-на-верху-ПТСР из этого и попытался сделать вариант 2) неукоснительно.

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

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

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

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

Мой рецепт таков. Для всех локальных переменных возьмите переменную и переместите ее объявление вниз, скомпилируйте, а затем переместите объявление непосредственно перед ошибкой компиляции. Это первое использование. Сделайте это для всех локальных переменных.

 инт foo = 0;
<код, который использует foo>
инт бар = 1;
<код, который использует панель>
<код, который использует foo>
 

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

 {
    интервал foo = 0;
    <код, который использует foo>
}
инт бар = 1;
<код, который использует панель>
>>> Здесь первая ошибка компиляции
<код, который использует foo>
 

Это не компилируется, потому что есть еще код, использующий foo. Мы можем заметить, что компилятор смог пройти через код, который использует bar, потому что он не использует foo. На данный момент есть два варианта. Механический — просто перемещать «}» вниз до тех пор, пока он не скомпилируется, а другой вариант — проверить код и определить, можно ли изменить порядок на:

 {
    интервал foo = 0;
    <код, который использует foo>
}
<код, который использует foo>
инт бар = 1;
<код, который использует панель>
 

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

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

 int i;
для (я = 0; я < 8; ++ я) {
    ...
}
<кое-что>
для (я = 3; я < 32; ++ я) {
    ...
}
 

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