Система типов

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

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

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

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

Категории типов

Система типов включает несколько категорий типов:

Схема типов представлена ниже.

Простые (элементарные) типы – это типы, имя и основные свойства которых известны компилятору. Относительно элементарных типов компилятору не требуется никакой дополнительной информации. Свойства и функциональность этих типов известны.

Среди простых типов различаются:

Некоторые характеристики простых (элементарных) типов отражены в следующей таблице. Используемые в .NET языки программирования основываются на общей системе типов. Между именами простых типов в C# и именами типов, объявленных в Framework Class Library, существует взаимно однозначное соответствие. Смысл точечной нотации в графе "Соответствует FCL-типу" состоит в явном указании пространства имен, содержащего объявление соответствующего типа:

Ниже представлены основные отличия ссылочных типов и типов-значений.

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

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

В разных CLS-языках типам, удовлетворяющим CLS-спецификации, будут соответствовать одни и те же элементарные типы.

Система встроенных типов C# основывается на системе типов .NET Framework Class Library. При создании IL-кода компилятор осуществляет их отображение в типы из .NET FCL.

Параметризованные типы занимают особое место в системе типов и обсуждаются позже.

object и string: предопределенные ссылочные типы

Итак, к ссылочным типам относятся:

Для каждой категории ссылочных типов существуют собственные правила объявления. Объявления классов вводятся ключевым словом class. Правила объявления классов (как и правила объявления других ссылочных типов, а также типов-значений, объявляемых с помощью ключевого слова struct ) позволяют объявлять неограниченное множество разнообразных ссылочных типов и структур.

Среди множества классов выделяют предопределенные ссылочные типы object и string, которым соответствуют FCL-типы System.Object и System.String. Свойства, функциональность и особенности применения этих типов рассматриваются ниже.

Литералы. Представление значений

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

Различаются литералы арифметические (разных типов), логические, символьные (включая Escape-последовательности), строковые.

Арифметические литералы

Арифметические литералы кодируют значения различных (арифметических) типов. Тип арифметического литерала определяется следующими интуитивно понятными внешними признаками:

Логические литералы

К логическим литералам относятся следующие последовательности символов: true и false. Больше логических литералов в C# нет.

Символьные литералы

Это заключенные в одинарные кавычки вводимые с клавиатуры одиночные символы: ' ,', (char)7541 – какой символ будет здесь – не ясно.

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

Следующие заключенные в одинарные кавычки последовательности символов являются Escape-последовательностями. Эта категория литералов используется для создания дополнительных эффектов (звонок), простого форматирования выводимой информации и кодирования символов при выводе и сравнении (в выражениях сравнения).

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

Это последовательность символов и символьных Escape-последовательностей, заключенных в двойные кавычки.

Verbatim string – строковый литерал, интерпретируемый компилятором так, как он записан. Escape-последовательности воспринимаются строго как последовательности символов.

Verbatim string представляется при помощи символа @, который располагается непосредственно перед строковым литералом, заключенным в парные двойные кавычки. Представление двойных кавычек в Verbatim string обеспечивается их дублированием. Пара литералов (второй – Verbatim string )

..."c:\\My Documents\\sample.txt"...
...@"c:\My Documents\sample.txt"...

имеют одно и то же значение:

c:\My Documents\sample.txt

Представление двойных кавычек внутри Verbatim string достигается за счет их дублирования:

...@"""Focus"""

имеет значение

"Focus"

Строковые литералы являются литералами типа string.

Переменные элементарных типов. Объявление и инициализация

Объявление – это предложение языка C#, которое используется непосредственно в теле класса для объявления членов класса (в этом случае объявлению может предшествовать спецификатор доступа) или для объявления переменных в конструкторах и методах класса.

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

Предложение объявления предполагает (возможное) наличие различных спецификаторов, указание имени типа, имени объекта и (возможно) выражения инициализации. При этом имя типа может быть задано как Действительное Имя Типа (Имя FCL-типа) или как псевдоним типа (имя типа, как оно объявляется в C#). Соответствующее выражение инициализации может быть представлено литералом или выражением более сложной структуры.

Эквивалентные формы записи операторов определения переменных элементарных типов-значений:

int a;
System.Int32 a;

Эквивалентные формы записи операторов определения и инициализации переменных типа значения:

int a = 0;
int a = new int();
System.Int32 a = 0;
System.Int32 a = new System.Int32();

Здесь следует учитывать важное обстоятельство: CLR не допускает использования в выражениях неинициализированных локальных переменных. В C# к таковым относятся переменные, объявленные в теле метода. Так что при разработке алгоритма следует обращать на это особое внимание.

int a; // Объявление a.
int b; // Объявление b.
b = 10; // Инициализация b.
a=b+b; // Инициализация a.

Константы

Объявляются с дополнительным спецификатором const. Требуют непосредственной инициализации. В данном примере инициализируется литералом 3.14.

const float Pi = 3.14;

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

Для каждого определенного в C# типа существует собственный набор операций, определенных на множестве значений этого типа.

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

Общие характеристики используемых в C# операций представлены ниже.

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

Приоритет операций

Приведение типов

Приведение типов – один из аспектов безопасности языка.

Используемые в программе типы характеризуются собственными диапазонами значений, которые определяются свойствами типов – в том числе и размером области памяти, предназначенной для кодирования значений соответствующего типа. При этом области значений различных типов пересекаются. Многие значения можно выразить более чем одним типом. Например, значение 4 можно представить как значение типа sbyte, byte, short, ushort, int, uint, long, ulong. При этом в программе все должно быть устроено таким образом, чтобы логика преобразования значений одного типа к другому типу была бы понятной, а результаты этих преобразований – предсказуемы. В одном выражении могут быть сгруппированы операнды различных типов. Однако возможность подобного "смешения" при определении значения выражения приводит к необходимости применения дополнительных усилий по приведению значений операндов к "общему типу".

Иногда приведение значения к другому типу происходит автоматически. Такие преобразования называются неявными.

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

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

Различаются:

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

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

Сужающее преобразование – значение одного типа преобразуется к значению другого типа, которое имеет меньший размер (из 64-разрядного в 32-разрядное). Такое преобразование потенциально опасно потерей значения.

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

При этом значение PositiveInfinity интерпретируется как результат деления положительного числа на ноль, а значение NegativeInfinity — как результат деления отрицательного числа на ноль.

Если сужающее преобразование обеспечивается методами класса System.Convert, то потеря информации сопровождается генерацией исключения (об исключениях позже).

object. Характеристики типа

Всеобщий базовый тип. Обязательная составляющая любого типа в .NET. Функциональные характеристики типа System.Object приводятся в таблице.

Конструктор

Общедоступные (public) методы

Защищенные (protected) методы

Особенности выполнения арифметических операций

Особенности выполнения операций над целочисленными операндами и операндами с плавающей точкой связаны с особенностями выполнения арифметических операций и с ограниченной точностью переменных типа float и double.

Представление величин:

float – 7 значащих цифр
double – 16 значащих цифр

1000000*1000000==1000000000000, но максимально допустимое положительное значение для типа System.Int32 составляет 2147483647. В результате переполнения получается неверный результат –727379968.

Ограниченная точность значений типа System.Single проявляется при присвоении значений переменной типа System.Double. Приводимый ниже простой программный код иллюстрирует некоторые особенности арифметики .NET:

using System;

class Class1
{
const double epsilon = 0.00001D; 
static void Main(string[] args)
{
int valI = 1000000, resI;
resI = (valI*valI)/valI;

// –727379968/1000000 == –727
Console.WriteLine
("The result of action (1000000*1000000/1000000) is {0}", resI);

float valF00 = 0.2F, resF;
double valD00 = 0.2D, resD;

// Тест на количество значащих цифр для значений типа double и float.
resD = 12345678901234567890; Console.WriteLine(">>>>> {0:F10}",resD);
resF = (float)resD; Console.WriteLine(">>>>> {0:F10}",resF); 
resD = (double)(valF00 + valF00); // 0.400000005960464
if (resD == 0.4D) Console.WriteLine("Yes! {0}",resD);
else Console.WriteLine("No! {0}",resD);

resF = valF00*5.0F;
resD = valD00*5.0D;
resF = (float)valD00*5.0F;
resD = valF00*5.0D; //1.0000000149011612
if (resD == 1.0D) 	Console.WriteLine("Yes! {0}",resD);
else             	Console.WriteLine("No! {0}",resD);

resF = valF00*5.0F;
resD = valF00*5.0F; //1.0000000149011612

if (resD.Equals(1.0D))	Console.WriteLine("Yes! {0}",resD);
else                	Console.WriteLine("No! {0}",resD);

if (Math.Abs(resD – 1.0D) < epsilon)
	Console.WriteLine("Yes! {0:F7}, {1:F7}",resD – 1.0D, epsilon);
else
	Console.WriteLine("No! {0:F7}, {1:F7}",resD – 1.0D, epsilon);
}
}

В результате выполнения программы выводится такой результат:

The result of action (1000000*1000000/1000000) is -727
>>>>> 12345678901234600000,0000000000
>>>>> 12345680000000000000,0000000000
No! 0,400000005960464
No! 1,00000001490116
No! 1,00000001490116
Yes! 0,0000000, 0,0000100

Особенности арифметики с плавающей точкой

checked и unchecked. Контроль за переполнением

Причиной некорректных результатов выполнения арифметических операций является особенность представления значений арифметических типов.

Арифметические типы имеют ограниченные размеры. Поэтому любая арифметическая операция может привести к переполнению. По умолчанию в C# переполнение, возникающее при выполнении операций, никак не контролируется. Возможный неверный результат вычисления остается всего лишь результатом выполнения операции, и никого не касается, КАК эта операция выполнялась.

Механизм контроля за переполнением, возникающим при выполнении арифметических операций, обеспечивается ключевыми словами checked (включить контроль за переполнением) и unchecked (отключить контроль за переполнением), которые используются в составе выражений. Конструкции управления контролем за переполнением имеют две формы:

:::::
short x = 32767;
short y = 32767;
short z = 0;

try
{
 z = checked(x + unchecked(x+y));
}
catch (System.OverflowException e)
{
Console.Writeline("Переполнение при выполнении сложения");
}
return z; 
:::::

:::::
short x = 32767;
short y = 32767;
short z = 0, w = 0;

try
{
unchecked
{
 w = x+y;
}

checked
{
 z = x+w;
}

}
catch (System.OverflowException e)
{
 Console.Writeline("Переполнение при выполнении сложения");
}

return z; 
:::::

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

Константное выражение

Константное выражение – это либо элементарное константное выражение, к которым относятся:

Отличительные черты константного выражения:

Перечисления

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

enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

Обращение к элементу перечисления осуществляется посредством сложного выражения, состоящего из имени класса перечисления, операции доступа к элементу перечисления ' .', имени элемента перечисления:

int xVal = (int)Colors.Red; //Переменная xVal инициализируется значением перечисления.

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

Далее приводится список членов класса перечисления.

Открытые методы

Защищенные конструкторы

Защищенные методы

Объявление переменных. Область видимости и время жизни

Любая используемая в программе сущность вводится объявлением.

Объявлению подлежат:

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

Конфликта имен (проблемы с обращением к одноименным объектам) позволяет избежать принятая в языке дисциплина именования. В каждом языке программирования она своя.

Избежать конфликта имен в C# позволяет такая синтаксическая конструкция, как блок операторов. Блок – это множество предложений (возможно пустое), заключенное в фигурные скобки.

Различается несколько категорий блоков:

Переменные можно объявлять в любом месте блока. Точка объявления переменной в буквальном смысле соответствует месту ее создания. Обращение к объявляемой сущности (переменной или константе) "выше" точки ее объявления лишено смысла.

Новый блок – новая область видимости. Объекты, объявляемые во внутренних блоках, не видны во внешних блоках. Объекты, объявленные в методе и во внешних блоках, видны и во внутренних блоках. Одноименные объекты во вложенных областях конфликтуют.

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

В теле класса не допускается объявления одноименных данных-членов. Нарушение этого правила приводит к неоднозначности.

В теле класса не допускается объявления одноименных функций — членов (методов класса) с пустыми списками параметров. Также не допускаются объявления одноименных функций — членов (методов класса) со списками параметров, у которых совпадают типы параметров.

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

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

Ниже приводится простой программный код, отражающий особенности принятой в C# концепции областей видимости.

using System;
class Class1
{
static int s;

static void Main(string[] args)
 {
{int s;}
{int s;}
 
 {
Class1.s = 100; // Классифицированное имя!
int s;
 {
//int s; 
 }
 }

System.Int32 z = new int();
char a = (char)41;
char b = 'X';
Console.WriteLine("{0} {1}",a,b);
 }

//void QQQ(int q0)
//{ 
//Class1.s = 10;
//int s;
//} 

//void QQQ(int q1)
//{ 
//Class1.s = 10;
//int s;
//} 

int QQQ(int q2)
{ 
Class1.s = 10;
int s;
return 0;
} 

int QQQ(int q2, int q3)
{ 
//s = 100;	
Class1.s = 10;
int s;
return 0;
}
}