Лекция № 6. Знакомство с языком программирования С#

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

специальные ключевые слова, и язык С# не является исключением. В отличие от других языков программирования все переменные в С# рассматриваются как объекты тех или иных классов.

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

Чтобы использовать переменные в программе С#, их необходимо объявить, указав

имя и тип переменной, например:

byte myByte;

ushort myShort;

uint mylnt;

ulong myLong;

Здесь объявлены 4 переменные с именами myByte, myShort, mylnt и myLong.

Объявление каждой переменной на отдельной строке завершается символом «точка с запятой». Можно было бы расположить все объявления на двух или даже на одной строке, однако такая запись выглядит менее наглядно:

byte myByte; ushort myShort; uint mylnt; ulong myLong;

Комментарии позволяют вставлять в исходный текст программы произвольные поясняющие текстовые строки Компилятор игнорирует символы / / и все символы, следующие за ними до конца текущей строки:

byte myByte; // Это правильное определение переменной типа byte

Примеры объявления переменных для типов данных со знаком:

sbyte distanceX;

short distanceY;

int height;

long width;

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

Например, по имени distanceFromHome сразу можно догадаться, что в соответст-

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

Примеры объявления переменных, предназначенных для хранения чисел с пла-

вающей точкой, в программе С#:

float piNumber;

double eNumber;

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

Многократное возникновение ошибки округления может привести к бесследному

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

ных сумм. В языке С# предусмотрен один тип данных специально для работы с деньгами — decimal. Он обеспечивает точность представления денежных сумм — до 29 десятичных цифр.

decimal totalAccountValue;

Для хранения отдельных символов текста (таких, как буквы, знаки пунктуации

и управляющие символы) в языке С# предусмотрен специальный тип данных

char.

char tokenDelemiter;

Язык С# содержит мощные и удобные объектно-ориентированные средства, позволяющие выполнять со строками все необходимые операции. Текстовые строки определяются с помощью ключевого слова string.

string firsLName;

Логические переменные в С# объявляются с помощью ключевого слова bool и могут

принимать одно из двух значений — true (истина) или false (ложь).

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

Типов так много, что в целях упорядочивания они логически подразделяются на пространства имен. Пространство имен в С# представляет собой совокупность связанных типов. Некоторые пространства имен, например, System, очень велики и могут включать более 100 разного рода типов; другие пространства имен, например, System.Timers, содержат всего по несколько типов.

Использование пространств имен (также называемых пакетами, библиотеками или интерфейсами прикладного программирования, API от Application Programming Interface) — это практическая реализация концепции повторного использования, принципа, чрезвычайно поощряемого в современной программной инженерии. Если язык предоставляет некоторый набор типов, имеет прямой смысл использовать их в своих

программах.

Литералы применяются в исходном тексте программы для обозначения числовых или

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

Целочисленные литералы без дополнительных суффиксов могут представлять значения типов со знаком или без знака: byte, sbyte, int, uint, long, ulong. С помощью символьных литералов представляют одиночные символы, заключая их в одинарные кавычки.

Литералы с плавающей точкой бывают типа float, double и decimal. Если в литерале используется суффикс f или F, то это литерал типа float, а если суффикс d или D — типа double. В том случае, когда суффикс не указан, литерал принимает тип double.

Для обозначения литерала типа decimal используется суффикс m или М.

Экспоненциальная часть литерала отделяется символом е или Е. Для обозначения

знака числа используются символы + и -.

Вот примеры литералов с плавающей точкой типа float:

3F 6.52f 2el0F 1356.4560f -3.7E-10F

Ниже мы привели примеры литералов типа double:

.25 3.3 6.52d 2el0 1356.4560D -3.7E-10D

Вот несколько примеров литералов типа decimal, применяемых обычно для обо-

значения денежных сумм:

.25m З.ЗМ 6.52m 2е10М 13573847420983746.45М

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

"Hello, C# world!"

В языке С# с помощью специального литерала null программист может указать, что переменная вообще не содержит никакого значения. Литерал пи 11 не эквивалентен нулевому значению. Он предназначен для использования в тех ситуациях, когда в переменной не хранится ни нулевое, ни какое-либо другое значение.

Операторы представляют собой символы, с помощью которых программа может

выполнять те или иные действия над переменными, литералами и другими объектами.

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

Объекты программы, над которыми выполняются действия, называются операнда-

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

Операторы и операнды формируют выражения.

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

В языке С# имеется специальный набор операторов, управляющих ходом выполнения

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

Для выполнения каких-либо повторяющихся действий применяются специальные

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

Все эти команды позволяют управлять ходом исполнения строк программы, поэто-

му они и называются управляющими.

Вот внешний вид простого условного оператора i f в наиболее общем виде:

if(<Выражение>)

<Оператор 1>

[else

<Оператор 2>]

Оператор if может дополнительно содержать необязательную конструкцию else.

Так как эта конструкция необязательная, она заключена в квадратные скобки.

Действует этот оператор следующим образом.

Если логическое <Выражение> равно true, выполняется <Оператор 1>. В противном случае управление передается оператору <Оператор 2>. Если же конструкция else не определена, программа продолжает свою работу со строки, расположенной после оператора if.

Приведем простой пример:

int i = 2;

int j = 3;

if(i>j)

System.Console.WriteLine("{0} > {1}", i, j);

else

System.Console.WriteLine(“{0} < {1}", i, j);

В этом примере для выражения <Выражение> использован оператор отношения >.

Если содержимое переменной i больше содержимого переменной j, то в действие

вступит строка, расположенная сразу после оператора if, а если меньше, то строка,

расположенная сразу после оператора else.

В результате работы этого фрагмента программы на консоли будет отображено

правильное неравенство 2 < 3.

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

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

Для решения этой задачи можно использовать вложенные условные операторы i f

следующего вида:

if(<Выражение1>)

<Оператор 1>

else if(<Выражение2>)

<Оператор 2>

else if(<ВыражениеЗ>)

<Оператор 3>

else

<Оператор N>

Задача выбора одного действия из нескольких по результатам вычисления какого-либо выражения возникает очень часто, и в языке С# предусмотрен специальный оператор выбора switch, предназначенный для ее решения. Этот оператор используется для исполнения того или иного фрагмента программы в зависимости от значения переменной или выражения.

Ниже показан оператор switch в общем виде (квадратными скобками отмечены необязательные конструкции оператора):

switch(<Переключающее выражение>)

{

case <Выражение-константа1>:

<Оператор 1>

[<Оператор перехода>]

[case <Выражение-константа2>:

<Оператор 2>

[<Оператор перехода>]]

[default:]

<Оператор N>]

}

Оператор switch выполняется следующим образом.

Вначале вычисляется значение выражения <Переключающее выражение>, сле-

дующего за ключевым словом switch. Это выражение должно быть целочисленным

(со знаком или без знака), символьным char либо строковым string.

Результат вычислений сравнивается с выражениями-константами блоков case (на-

зываемых также метками case). В случае совпадения значения управление передает-

ся оператору соответствующего блока case. Если совпадений не обнаружено, управ-

ление передается оператору <Оператор N> блока default. Оператор перехода break, расположенный в конце каждого блока case, а также в конце блока default, завершает выполнение строк программы текущего блока и передает управление вниз, за пределы оператора switch.

По сравнению с вложенным оператором if оператор выбора позволяет создавать

более эффективные программы, так как компилятор соответствующим образом опти-

мизирует создаваемый код.

Итерационные операторы применяются в программах С# для выполнения каких-либо

повторяющихся действий, т. е. для организации циклов. Иногда эти операторы назы-

ваются циклическими.

Оператор for предназначен для повторного выполнения оператора или группы опера-

торов заданное количество раз. Вот как выглядит этот оператор в общем виде:

for ([Инициализация]; [Условие];[Приращение])

<Оператор>

Оператор [Инициализация] выполняется один раз перед началом цикла. Перед каждой итерацией (т.е. перед каждым выполнением тела цикла <Оператор>) проверяется [Условие]. И наконец, после каждой итерации выполняется оператор [Прирашение].

Как правило, в цикле имеется переменная, играющая роль так называемой переменной цикла. При каждой итерации переменная цикла изменяет свое значение в заданных пределах. Начальное значение переменной цикла задается в программе до оператора for или в операторе [Инициализация]. Предельное значение переменной цикла определяется

оператором приращения, а проверка ее текущего значения — в блоке [ Условие ].

Поясним сказанное на простом примере.

int i;

for (i = 0; i < 10; i++)

{

System.Console.Write("{0} ",i);

}

Здесь переменная i используется в качестве переменной цикла. Перед началом

цикла ей присваивается нулевое значение. Перед каждой итерацией содержимое пере-

менной i сравнивается с числом 10. Если i меньше 10, тело цикла выполняется один

раз. В тело цикла мы поместили вызов метода Write, отображающий текущее значе-

ние переменной цикла на консоли.

После выполнения тела цикла значение i увеличивается на единицу в блоке при-

ращения. Далее переменная цикла вновь сравнивается с числом 10. Когда значение i

превысит 10, цикл завершится.

Таким образом, параметр цикла анализируется перед выполнением тела цикла,

а модифицируется после его выполнения.

Вот что выведет на консоль приведенный выше фрагмент программы:

Для обработки таких типов данных, как массивы и контейнеры, язык С# предлагает

очень удобный оператор foreach.

Будем считать массив набором упорядоченных объектов, каждый из которых имеет свой номер, или индекс. Первый элемент массива имеет индекс 0, второй — 1 и т. д.

Массив целых чисел со знаком объявляется следующим образом:

int[] nums;

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

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

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

массив переменных типа int:

int[] nums;

nums = new int[10];

Созданный массив инициализируется значениями по умолчанию. Для числовых

массивов в качестве такого значения используется 0.

Чтобы записать в элемент массива с заданным номером какое-либо значение, необ-

ходимо указать индекс этого элемента в квадратных скобках.

Ниже мы в цикле инициализируем массив, записывая в его элементы числа от 0

до 9, причем в нулевой элемент массива записывается значение 0, в первый — значе-

ние 1 и т. д.:

for(i =0; i < 10; i++)

nums[i] = i;

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

цикл for:

for(i = 0; i < 10;

System.Console.Write("{0} ", nums(i]);

Здесь мы последовательно выводим на консоль все значения, хранящиеся в массиве.

Хотя на первый взгляд этот способ обработки всех элементов массива достаточно

прост, ему присущи некоторые недостатки. Например, нам нужно объявлять и ини-

циализировать переменную цикла (применяемую в роли индекса массива), а затем

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

ние переменной цикла не превысило размер массива, иначе возникнет исключение.

Оператором f oreach пользоваться намного проще:

foreach(int current in nums)

System.Console.Write("{0} ", current);

В скобках после ключевого слова f oreach мы объявляем переменную current

типа int, которой при каждой итерации будут последовательно присваиваться все

значения массива nums. Имя этого массива указывается после ключевого слова in.

Таким образом, нам не нужна переменная цикла и, следовательно, не нужно ее

инициализировать, инкрементировать и проверять, не вышло ли значение индекса

массива за допустимые пределы.

Оператор foreach сделает все за нас. Он последовательно присвоит значение

всех элементов массива переменной current, а нам останется только выводить при

каждой итерации значение этой переменной на консоль.

Дата добавления: 2014-01-20