Пример описания локальных переменных
Встроенные типы
Встроенные типы приведены в таблице 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 – Встроенные типы языка С#
Название
| Ключевое слово
| Тип .NET
| Диапазон
| Описание
| Размер, битов
| Логический тип
| bool
| Boolean
| true, false
|
|
| Целые типы
| sbyte
| SByte
| -128..127
| Со знаком
|
| byte
| Byte
| 0..255
| Без знака
|
| short
| Int16
| -32768..32767
| Со знаком
|
| ushort
| UInt16
| 0..65535
| Без знака
|
| int
| Int32
| -2*10^9..2*10^9
| Со знаком
|
| uint
| UInt32
| 0..4*10^9
| Без знака
|
| long
| Int64
| -9*10^18..9*10^18
| Со знаком
|
| ulong
| UInt64
| 0..18*10^18
| Без знака
|
| Символьный тип
| char
| Char
| U+0000..U+ffff
| Unicode-символ
|
| Вещественные типы
| float
| Single
| 1.5*10^-45..3.4*10^38
| 7 цифр
|
| double
| Double
| 5.0*10^-324..1.7*10^308
| 15-16 цифр
|
| Финансовый тип
| decimal
| Decimal
| 1.0*10^-28..7.9*10^28
| 28-29 цифр
|
| Строковый тип
| string
| String
| Длина ограничена объемом доступной памяти
| Строка из Unicode-символов
|
| Тип object
| object
| Object
| Можно хранить все что угодно
| Всеобщий порядок
|
|
Типы-значения и ссылочные типы
Типы С# разделяют по способу хранения элементов на типы значения и ссылочные типы. Элементы типов значений представляют собой просто последовательность битов в памяти, необходимый объем которой определяет компилятор. То есть, величины таких типов хранят сови значения непосредственно. Величина ссылочного типа хранит не данные, а ссылку на них (адрес, про которому расположены данные). Сами данные хранятся в динамической памяти.
Однако, все типы являются потомками базового класса 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 - Операции С#
Категория
| Знак операции
| Название
| Первичные
| .
| Доступ к элементу
| X()
| Вызов метода или делегата
| X[ ]
| Доступ к элементу
| X++
| Постфиксный инкремент
| new
| Выделение памяти
| X--
| Постфиксный декремент
| typeof
| Получение типа
| checked
| Проверяемый код
| unchecked
| Непроверяемый код
| Унарные
| +
| Унарный плюс
| -
| Унарный минус (арифметическое отрицание)
| !
| Логическое отрицание
| ~
| Поразрядное отрицание
| ++X
| Префиксный инкремент
| --X
| Префиксный декремент
| (тип)x
| Преобразование типа
| Мультипликативные
(типа умножения)
| *
| Умножение
| /
| Деление
| %
| Остаток отделения
| Аддитивные
(типа сложения)
| +
| Сложение
| -
| Вычитание
| Сдвига
| <<
| Сдвиг влево
| >>
| Сдвиг вправо
| Отношения и проверки типа
| <
| Меньше
| >
| Больше
| <=
| Меньше или равно
| >=
| Больше или равно
| is
| Проверка на принадлежность типу
| as
| Приведение типа
| Проверка на равенство
| = =
| Равно
| !=
| Не равно
| Поразрядные логические
| &
| Поразрядное И (конъюнкция)
| ^
| Поразрядное исключающее ИЛИ
| |
| Поразрядное ИЛИ (дизъюнкция)
| Условные логические
| &&
| Логическое И
| ||
| Логическое ИЛИ
| Тернарная операция
| ?:
| Условная операция
|
Продолжение таблицы 3.1
Категория
| Знак операции
| Название
| Присваивания
| =
| Присваивание
| *=
| Умножение с присваиванием
| /=
| Деление с присваиванием
| %=
| Остаток от деления с присваиванием
| +=
| Сложение с присваиванием
| -=
| Вычитание с присваиванием
| <<=
| Сдвиг влево с присваиванием
| >>=
| Сдвиг вправо с присваиванием
| &=
| Поразрядное И с присваиванием
| ^=
| Поразрядное исключающее ИЛИ с присваиванием
| |=
| Поразрядное ИЛИ с присваиванием
| Операции в выражении выполняются в определенном порядке в соответствии с приоритетами, как и в математике. В приведенной выше таблице 3.1 операции расположены по убыванию приоритетов.
Результат вычисления выражения характеризуется значением и типом. Например, пусть а и b — переменные целого типа и описаны так:
int а=2, b = 5;
Тогда выражение а + b имеет значение 7 и тип int, а выражение а = b имеет значение, равное помещенному в переменную а (в данному случае — 5), и тип, совпадающий с типом этой переменной.
Если в одном выражении соседствуют несколько операций одинакового приоритета, операции присваивания и условная операция выполняются справа налево, остальные — слева направо. Для изменения порядка выполнения операций используются круглые скобки, уровень их вложенности практически не ограничен.
Например, а + b + с означает (а + b) + с, а = b = с означает а = (b = с). То есть сначала вычисляется выражение b = с, а затем его результат становится правым операндом для операции присваивания переменной а.
Не нашли, что искали? Воспользуйтесь поиском по сайту:
©2015 - 2024 stydopedia.ru Все материалы защищены законодательством РФ.
|