Пример описания локальных переменных

Встроенные типы

Встроенные типы приведены в таблице 3.1. Они однозначно соответствуют стандартным классам библиотеки .NET определенным в пространстве имен System.

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

Внутреннее представление величины целого типа– целое число в двоичном коде. В знаковых типах старший бит числа интерпретируется как знаковый (0-положительное число, 1-отрицательное). Отрицательные числа чаще всего представляются в дополнительном коде – все разряды числа, кроме знакового разряда, инвертируются, затем к числу прибавляется единица, и знаковому биту присваивается единица. Беззнаковые типы позволяют представлять только положительные числа, поскольку старший разряд рассматривается как часть кода числа.

Вещественные типы хранятся в памяти иначе, чем целочисленные. Внутреннее представление величины вещественного типа состоит из двух частей – мантиссы и порядка, каждая часть имеет знак. Длина мантиссы определяет точность числа, а длина порядка – его диапазон. Например, число 0,381*10^4 хранятся цифры мантиссы 381 и порядок 4, для числа 560,3*10^2 – мантисса 5603 и порядок 5.

Тип decimal предназначен для денежных вычислений, в которых критичны ошибки округления. Данные тип не относится к вещественным типам, у них разное внутреннее представление. Величины денежного типа нельзя использовать в одном выражении с вещественными буз явного преобразования типа.

Любой встроенный тип языка С# соответствует стандартному классу библиотеки .NET. Везде, где используется имя встроенного типа его можно заменить именем класса библиотеки System. Это значит, что у встроенных типов есть методы и поля. Например:

double.MaxValue (System.Double.MaxValue) – максимальное значение числа типа double.

uint.MinValue (System.UInt32.MinValue) – минимальное значение числа типа uint.

Таблица 3.1 – Встроенные типы языка С#

Типы-значения и ссылочные типы

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

Однако, все типы являются потомками базового класса 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 не конфликтуют между собой, по­скольку блоки, в которых они описаны, не вложены один в другой.

Пример описания локальных переменных

using System;

namespace ConsoleApplicationl

{class Classl

{ static void Main()

{

int i = 3;

double у = 4.12;

decimal d = 600m;

string s = "Вася";

Console.Write( "i = " ); Console.WriteLine( i );

Console.Write( "y = " ); Console.WriteLine(у );

Console.Write( "d = " ); Console.WriteLine( d );

Console.Write( "s = " ); Console.WriteLine( s ); } } }

Переменные создаются при входе в их область действия (блок) и уничтожаются при выходе. Это означает, что после выхода из блока значение переменной не сохра­няется. При повторном входе в этот же блок переменная создается заново.

Именованные константы

Можно запретить изменять значение переменной, задав при ее описании ключе­вое слово const, например:

const int b = 1;

const float x = 0.1, у = 0.1f; // const распространяется на обе переменные

Такие величины называют именованными константами, или просто константами.Они применяются для того, чтобы вместо значений констант можно было использовать в программе их имена. Это делает программу более понятной и об­легчает внесение в нее изменений, поскольку изменить значение достаточно только в одном месте программы.

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

const int b = 1, а = 100; const int x = b * а + 25;

Операции и выражения

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

Например, а + 2 — это выражение, в котором + является знаком операции, а и 2 — операндами. Пробелы внутри знака операции, состоящей из нескольких сим­волов, не допускаются. По количеству участвующих в одной операции опе­рандов операции делятся на унарные, бинарные и тернарную. Операции С# приведены в таблице 3.1.

Таблица 3.1 - Операции С#

Продолжение таблицы 3.1

Операции в выражении выполняются в определенном порядке в соответствии с приоритетами, как и в математике. В приведенной выше таблице 3.1 операции расположены по убыванию приоритетов.

Результат вычисления выражения характеризуется значением и типом. Например, пусть а и b — переменные целого типа и описаны так:

int а=2, b = 5;

Тогда выражение а + b имеет значение 7 и тип int, а выражение а = b имеет значение, равное помещенному в переменную а (в данному случае — 5), и тип, совпадающий с типом этой переменной.

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

Например, а + b + с означает (а + b) + с, а = b = с означает а = (b = с). То есть сначала вычисляется выражение b = с, а затем его результат становится правым операндом для операции присваивания переменной а.

Не нашли, что искали? Воспользуйтесь поиском по сайту: