Лабораторная работа 1

Лабораторная работа N1 Основные понятия языка С# Алфавит и лексемы

В С# используется кодировка символов Unicode.

Кодировка Unicode позволяет представить символы всех существующих алфавитов одновременно, что коренным образом улучшает переносимость текстов. Каждому символу соответствует свой уникальный код. Естественно, что при этом для хранения каждого символа требуется больше памяти. Первые 128 Unicode-символов соответствуют первой части кодовой таблицы ANSI.

Алфавит С# включает:

буквы (латинские и национальных алфавитов) и символ подчеркивания (_) который употребляется наряду с буквами;

цифры;

специальные символы, например +, *, { и &;

пробельные символы (пробел и символы табуляции);

символы перевода строки.

Из символов составляются более крупные строительные блоки: лексемы, директивы препроцессора и комментарии.

Лексема (token) - это минимальная единица языка, имеющая самостоятельный смысл. Существуют следующие виды лексем:

имена (идентификаторы);

ключевые слова;

знаки операций;

разделители;

литералы (константы).

Лексемы языка программирования аналогичны словам естественного языка.

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

Комментарии предназначены для записи пояснений к программе и формирования документации. Из лексем составляются выражения и операторы.

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

ПРИМЕЧАНИЕ———————————————————————————————

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

Оператор задаѐт законченное описание некоторого действия, данных или элемента программы. Например: int a; // это – оператор описания целочисленной переменной а.

Идентификаторы

Имена в программах служат той же цели, что и имена в мире людей, - чтобы обращаться к программным объектам и различать их, то есть идентифицировать. Поэтому имена также называют идентификаторами. В идентификаторе могут использоваться буквы, цифры и символ подчѐркивания. Прописные и строчные буквы различаются, например, sysop, SySoP, SYSOP – три разных имени.

Первым символом идентификатора может быть буква или знак подчѐркивания, но не цифра. Длина идентификатора не ограничена. Пробелы внутри имѐн не допускаются. В идентификаторах C# разрешается использовать помимо латинских букв буквы национальных алфавитов. Например, Вася является правильным идентификатором. Более того, в идентификаторах можно применять даже так называемые escape-последовательности Unicode, то есть представлять символ с помощью его кода в шестнадцатеричном виде с префиксом \u, например, \u00F2.

ПРИМЕЧАНИЕ———————————————————————————————

Примеры неправильных имѐн: 2late, Big gig, Б#г; первое начинается с цифры, второе и третье содержат недопустимые символы (пробел и #).

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

идентификатор не должен совпадать с ключевыми словами;

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

Ключевые слова

Ключевые слова - это зарезервированные идентификаторы, которые имеют специальное значение для компилятора. Их можно использовать только в том смысле, в котором они определены. Список ключевых слов С# приведен в таблице 2.1.

Знаки операций и разделители

Знак операции — это один или более символов, определяющих действие над операндами. Внутри знака операции пробелы не допускаются. Например, в выражении а+=b знак += является знаком операции, а а и b — операндами. Символы, составляющие знак операций, могут быть как специальными, например, &&, | и <, так и буквенными, такими как as или new.

Операции делятся на унарные, бинарные и тернарную по количеству участвующих в них операндов. Один и тот же знак может интерпретироваться по-разному в зависимости от контекста. Все знаки операций, за исключением [ ], ( ) и ? :, представляют собой отдельные лексемы.

Таблица 2.1 - Ключевые слова С#

ПРИМЕЧАНИЕ ————————————————————————————————

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

Если требуется сформировать отрицательную целую или вещественную константу, то перед ней ставится знак унарной операции изменения знака (-), например:

-218, -022, -0хЗС, -4.8, -0.1е4.

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

2.3.

Таблица 2.3 - Суффиксы целых и вещественных констант

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

«обычный» символ, имеющий графическое представление (кроме апострофа и символа перевода строки) - ' А', ' ю', ' *';

управляющая последовательность – '\0', ' \n';

- символ в виде шестнадцатеричного кода — '\xF', '\х74';

- символ в виде escape-последовательности Unicode — ' \uA81B'.

Управляющей последовательностью, или простой escape-последовательностью,

называют определенный символ, предваряемый обратной косой чертой. Управляющая последовательность интерпретируется как одиночный символ и используется для представления:

кодов, не имеющих графического изображения (например, \n — переход в начало следующей строки);

символов, имеющих специальное значение в строковых и символьных литералах, например, апострофа '.

Втаблице 2.4 приведены допустимые значения последовательностей. Если непосредственно за обратной косой чертой следует символ, не предусмотренный таблицей, возникает ошибка компиляции.

Таблица 2.4 Управляющие последовательности С#

\t-горизонтальная табуляция

Символ, представленный в виде шестнадцатеричного кода начинается с префикса \0x, за которым следует код символа.

Escape-последовательности Unicode служат для представления символа с помощью его кода в шестнадцатеричном виде с префиксом \u или \U (например \u00F2, \U00010011).

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

“Никто не доволен своей \n внешностью, но каждый доволен \n своим умом”

Если же внутри строки требуется использовать кавычку, ее предваряют косой чертой:

“Издательский дом \”Питер\” ”

Дословные литералы. Эти литералы начинаются с символа @, который отключает обработку управляющих последовательностей и позволяет получать строки в том виде, в котором они записаны:

@ ‖Никто не доволен своей внешностью, но каждый доволен своим умом‖ @‖Издательский дом ―Питер‖ ―

Комментарии. В С# существует 3 вида комментариев – однострочные, многострочные и XML комментарии. Однострочный комментарий начинается с // и заканчивается символом перехода на новую строку. Многострочный комментарий заключается в /* */ и может занимать часть строки, целую строку или несколько строк. Формирование документации в формате XML используют комментарии, начинающиеся с ///. Компилятор извлекает эти комментарии из программы, проверяет на соответствие правилам и записывает в отдельный файл.

Типы данных С#. Переменные, операции, выражения

Тип данных однозначно определяет:

o Внутреннее представление данных – множество их значений o Допустимые действия над данными (операции и функции)

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

Классификация типов данных в С# представлена на рисунке 3.1

Рисунок 3.1 – Классификация типов данных в С# по различным признакам

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

Встроенные типы приведены в таблице 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:

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

Так называемая область действия переменной, то есть область программы, где можно использовать переменную, начинается в точке ее описания и длится до конца блока, внутри которого она описана. Блок — это код, заключенный в фигурные скобки. Основное назначение блока — группировка операторов. В С# любая переменная описана внутри какого-либо блока: класса, метода или блока внутри метода.

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

В приведенном выше примере описан класс X, содержащий три элемента: поле А, поле В и метод Y. Непосредственно внутри метода Y заданы две локальные переменные — С и А. Внутри метода класса можно описывать переменную с именем, совпадающим с полем класса, потому что существует способ доступа к полю класса с помощью ключевого слова this.

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

Две переменные с именем D не конфликтуют между собой, поскольку блоки, в которых они описаны, не вложены один в другой.

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

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

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

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

int а=2, b = 5;

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

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

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

Преобразования встроенных арифметических типов-значений

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

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