Типы С# разделяют по способу хранения элементов на типы значения и ссылочные типы. Элементы типов значений представляют собой просто последовательность битов в памяти, необходимый объем которой определяет компилятор. То есть, величины таких типов хранят сови значения непосредственно. Величина ссылочного типа хранит не данные, а ссылку на них (адрес, про которому расположены данные). Сами данные хранятся в динамической памяти.
Однако, все типы являются потомками базового класса Object. На рисунке 3.2 представлена классификация типов данных С# по способу хранения данных.
Рисунок 3.2
Для того, чтобы величины ссылочного и значимого типов могли использоваться совместно, необходимо иметь возможность преобразования из одного типа в другой. Преобразование из типа-значения в ссылочный тип называется упаковкой, обратное преобразование – распаковкой.
Если величина значимого типа используется в том месте, где требуется ссылочный тип, автоматически выполняется создание промежуточной величины ссылочного типа – создается ссылка, в heap выделяется соответствующий объем памяти и туда копируется значение величины, то есть значение как бы упаковывается в объект. При необходимости обратного преобразования с величины ссылочного типа “снимается упаковка”, и в дальнейших действиях участвует только ее значение.
Переменная — это именованная область памяти, предназначенная для хранения данных определенного типа. Во время выполнения программы значение переменной можно изменять. Все переменные, используемые в программе, должны быть описаны явным образом. При описании для каждой переменной задаются ее имя и тип.
Пример описания целой переменной с именем а и вещественной переменной х:
int a; float x;
Идентификатор (имяпеременной) служит для обращения к области памяти, в которой хранится значение переменной. Имя дает программист. Оно должно соответствовать правилам именования идентификаторов С#, отражать смысл хранимой величины и быть легко распознаваемым.
Тип переменной выбирается, исходя из диапазона и требуемой точности представления данных.
При объявлении можно присвоить переменной некоторое начальное значение, то есть инициализировать ее, например:
int a, b = 1;
float x = 0.1, у = 0.lf;
Здесь описаны:
o переменная а типа int, начальное значение которой не присваивается;
o переменная b типа int, ее начальное значение равно 1;
o переменные х и у типа float, которым присвоены одинаковые начальные значения 0.1. Разница между ними состоит в том, что для инициализации переменной х сначала формируется константа типа double (это тип, присваиваемый по умолчанию литералам с дробной частью), а затем она преобразуется к типу float; переменной у значение 0.1 присваивается без промежуточного преобразования.
При инициализации можно использовать не только константу, но и выражение — главное, чтобы на момент описания оно было вычисляемым, например:
int b = 1, а = 100;
int x = b * а + 25:
Инициализировать переменную прямо при объявлении не обязательно, но перед тем, как ее использовать в вычислениях, это сделать все равно придется, иначе компилятор сообщит об ошибке.
Так называемая область действия переменной, то есть область программы, где можно использовать переменную, начинается в точке ее описания и длится до конца блока, внутри которого она описана. Блок — это код, заключенный в фигурные скобки. Основное назначение блока — группировка операторов. В С# любая переменная описана внутри какого-либо блока: класса, метода или блока внутри метода.
Имя переменной должно быть уникальным в области ее действия. Область действия распространяется на вложенные в метод блоки, из этого следует, что во вложенном блоке нельзя объявить переменную с таким же именем, что и в охватывающем его, например:
class X // начало описания класса X
{
int А; // поле А класса X
int В; //поле В класса X
void Y() // --------------------------------------- метод Y класса X
{
int С; // локальная переменная С, область действия - метод Y
int A; // локальная переменная А (НЕ конфликтует с полем А)
{ // ============ вложенный блок 1 ============
int D; // локальная переменная D, область действия - этот блок
int А; // недопустимо! Ошибка компиляции, конфликт с локальной //переменной А
С = В; // присваивание переменной С поля В класса X
С = this.А; // присваивание переменной С поля А класса X
} // ============ конец блока 1 ===============
{ // ============ вложенный блок 2 ============
int D; // локальная переменная D, область действия - этот блок
} // ============ конец блока 2 ===============
} //--------------------------------- конец описания метода Y класса X
} // конец описания класса X
В приведенном выше примере описан класс X, содержащий три элемента: поле А, поле В и метод Y. Непосредственно внутри метода Y заданы две локальные переменные — С и А. Внутри метода класса можно описывать переменную с именем, совпадающим с полем класса, потому что существует способ доступа к полю класса с помощью ключевого слова this.
Таким образом, локальная переменная А не «закрывает» поле А класса X, а вот попытка описать во вложенном блоке другую локальную переменную с тем же именем окончится неудачей. Если внутри метода нет локальных переменных, совпадающих с полями класса, к этим полям можно обратиться в методе непосредственно.
Две переменные с именем D не конфликтуют между собой, поскольку блоки, в которых они описаны, не вложены один в другой.
