close

Вход

Забыли?

вход по аккаунту

Untitled

код для вставкиСкачать
1.Информация из ОС, относящаяся к дисциплине
1.1. Вид деятельности выпускника
Дисциплина охватывает круг вопросов относящихся к виду деятельности
выпускника: Проектно-технологическая
_____________________________________________________________
1.2. Задачи профессиональной деятельности выпускника
В дисциплине рассматриваются указанные в ОС задачи профессиональной
деятельности выпускника:
Разработка средств реализации информационных технологий (методические,
информационные, математические, алгоритмические, технические и программные);
1.3. Перечень компетенций, установленных ОС
Освоение программы настоящей дисциплины позволит сформировать у
обучающегося следующие компетенции:
- способность проводить моделирование объектов, процессов и систем (ПК-5);
- способность выбирать и разрабатывать средства обеспечения эффективной и
безопасной среды информационного обмена (ПК-13);
- способность разрабатывать средства реализации информационных технологий
(методические, информационные, математические, алгоритмические, технические
и программные) (ПК-18);
- способность разрабатывать средства автоматизированного проектирования
информационных технологий в сфере профессиональной деятельности (ПК-19);
- готовность участвовать в работах по доводке и освоению информационных
технологий в ходе внедрения и эксплуатации информационных систем в сфере
профессиональной деятельности (ПК-23);
- способность участвовать в разработке алгоритмического и программного
обеспечения информационных систем и технологий (ПК-47).
1.4. Перечень умений и знаний, установленных ОС
После освоения программы настоящей дисциплины студент должен:
знать:
1.
2.
3.
4.
5.
6.
7.
уметь:
Этапы решения задачи с помощью программы
Форматы представления данных в C#
Основные операторы языка C#
Средства разработки программ модульной структуры
Функции для работы с символьными данными
Основы разработки оконных приложений
Принципы работы с данными на внешних носителях
1. Разрабатывать алгоритм и программы и подготавливать тесты для проверки
работоспособности программ
2. Разрабатывать схему иерархии, алгоритмы и программные коды программы
модульной структуры
3. Владеть технологией написания Windows-приложения
4. Разрабатывать программы обработки файлов
5. Разрабатывать программу обработки символьной информации
владеть
1.
2.
3.
4.
Средствами алгоритмизации при решении различных задач
Средствами программирования на языке C#
Средствами отладки программ
Средствами тестирования программ
2. Цели и задачи освоения программы дисциплины
Целью освоения дисциплины является изучение основ проектирования и разработки
консольных и оконных программ на языке высокого уровня C#, видов
вычислительных процессов, описания алгоритмов решения различных задач, включая
обработку данных в оперативной памяти и на внешних носителях, тестирование и
отладку программ.
Основными задачами преподавания дисциплины являются:
изучение этапов разработки и решения задачи с помощью программы;
изучение основных видов вычислительных процессов и их описания;
изучение основных средств языка C# по описанию различных видов вычислительных
процессов;
изучение принципов разработки программ модульной структуры;
изучение особенностей консольных и оконных программ;
изучение особенностей разработки программ обработки данных на внешних
носителях.
3. Место дисциплины в структуре ООП
Для изучения дисциплины необходимо освоение содержания дисциплин:
Математика, Информатика
Знания и умения, приобретаемые студентами после освоения содержания
дисциплины, будут использоваться в дисциплинах:
Технологии программирования, Управление данными
4. Основная структура дисциплины
Вид учебной работы
Трудоемкость,
часов
Всего
Час/ЗЕТ
Общая трудоемкость дисциплины
лекции
-в том числе интерактив (разбор конкретных
ситуаций)
лабораторные работы
в том числе интерактив (семинар в диалоговом
режиме)
практические/семинарские занятия
Самостоятельная работа (в том числе курсовое
проектирование)
Вид промежуточной аттестации (итогового контроля
по дисциплине), в том числе курсовое проектирование
Семестр
144 /4
51
17
2
№3
144 /4
51
17
2
34
4
34
4
57
57
К, Э(36)
К, Э(36)
5. Содержание дисциплины
5.1. Перечень основных разделов и тем дисциплины
1. Технология разработки программ на языке высокого уровня.
1.1. Этапы разработки программ на языке высокого уровня (таблица спецификаций,
алгоритм, таблица тестов, написание программы, отладка, тестирование)
1.2 . Виды вычислительных процессов
2. Разветвляющийся вычислительный процесс
2.1 Алгоритмы разветвляющихся процессов
2.2. Программа на языке C# (операторы, комментарии). Элементы языка (константы,
идентификаторы, типы данных, операции, оператор присваивания, операторы
разветвления if и switch)
3. Циклический вычислительный процесс
3.1. Алгоритмы циклических процессов
3.2 .Виды циклов в языке C# (for, while, do while), их особенности
3.3 .Работа с векторами и матрицами
4. Модульное программирование
4.1. Функция. Схема иерархии функций задачи. Входные параметры и результат
выполнения функции
4.2. Проектирование функций (таблицы спецификаций, алгоритмы). Тестирование
задачи
4.3. Функции в языке C# (заголовок и тело функции, параметры функции и
возвращаемое значение, способы вызова функций)
5. Обработка строковых данных
5.1. Описание строк в С#
5.2. Функции для копирования и объединения строк
5.3. Функции для сравнения строк
5.4. Функции поиска в строке
5.5. Корректировка строк
(интерактив – разбор конкретных ситуаций)
6. Разработка Windows – приложения в C#
6.1.Отличия программирования, управляемого данными, от программирования,
управляемого событиями
6.2. Формы и программные модули C#. Элементы управления в C#, их свойства и
события 7. Обработка файлов
7.1.Структура как развитие понятия типа
7.2.Файлы - последовательный и прямой доступ
7.3.Функции языка C# для обработки файлов (открытие и закрытие, чтение и запись,
удаление и переименование)
5.2 Краткое описание содержания теоретической части разделов и тем
дисциплины
Лекция 1. Технология разработки программ на языке высокого уровня
Разработка программы на языке высокого уровня никогда не должна начинаться
собственно с программирования. При таком подходе неизбежны ошибки в программах,
сложность отладки и внесения изменений в программу, что часто и происходит, так как
заказчик, только увидев работающую программу, может оценить, что ему надо и чего не
хватает в программе.
Поэтому любую, даже самую простую программу разрабатывают на основе
структурного подхода, который предполагает использование наиболее простых структур
как при проектировании, так и при программировании и отладке программ.
Разработка программы состоит из следующих этапов:
Внешнее проектирование (определение общей структуры и взаимодействия
функций). На этом этапе рассматривается возможность разбиения задачи на подзадачи,
каждая из которых решает некоторую законченную часть всей задачи и определяется
иерархия этих подзадач (какая подзадача вызывает для выполнения другие подзадачи).
Одна из подзадач всегда является основной, главной.
Кроме того, на этом этапе выясняется, какие данные нужно передать вызываемой
подзадаче и какие данные получить от нее. Для каждой подзадачи описывается своя
таблица внешних спецификаций. Если задача простая, то этот этап можно опустить.
Составление внешних спецификаций – приведение условия задачи к некоторому
стандарту, что позволяет задачи из различных предметных областей описывать более или
менее унифицировано. Таким стандартом для простых программ или отдельных функций
являются внешние спецификации. Спецификации определяют входные и выходные данные
задачи и оформляются в виде таблицы:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Им
я
Назначени
Диапазон
е
Входные величины – это те, значения которых необходимо задать в начале решения
задачи.
Выходные величины – это те, которые являются результатом решения задачи.
Имя ставится в соответствие любой входной и выходной величине; имена сохраняются
на всех этапах решения задачи.
Назначение – словесное описание величины, для чего она нужна.
Диапазон определяет область изменения величины (целое число, действительное
число, текст, целое число от 0 до 5 и т.д.)
Внутреннее проектирование (разработка алгоритма решения задачи).
Алгоритм – это описание последовательности действий, необходимых для решения
задачи.
Алгоритм обладает тремя свойствами:
Массовость – алгоритм должен описывать не одну конкретную задачу, а группу
подобных задач (например, не решение одного конкретного квадратного уравнения
2
2 X 2  4 X  3  0 , а любого квадратного уравнения AX  BX  C  0 ;
Результативность - алгоритм должен давать какой-то результат для любого варианта
исходных данных. Например, если решается квадратное уравнение, то должны быть
предусмотрены случаи:
 Существует два различных действительных корня X 1, X 2 , если B 2  4 AC  0
 Существует два равных действительных корня X 1  X 2 , если B 2  4 AC  0
Нет действительных корней, если B 2  4 AC  0

 Уравнение вырождено, то есть A=0. При этом должно быть выдано
соответствующее сообщение.
Детерминированность - алгоритм должен всегда давать один и тот же результат при
одних исходных данных.
Будем описывать алгоритм двумя способами:
- словесным способом
- с помощью блок – схем.
Словесное описание алгоритма - это последовательность пронумерованных шагов,
описывающих решение задачи. Шаги могут иметь многоуровневую нумерацию, чтобы
показать, что одни шаги являются частью других шагов.
Блок-схема решения задачи – графическое изображение алгоритма в виде
взаимосвязанных блоков.
Будем использовать следующие блоки:
Линейный процесс
Ввод данных с
клавиатуры
Заголовок цикла
Развилка
Вывод данных на
дисплей
Начало и конец
Стрелка для
соединения
блоков
Программирование алгоритма.
На этом этапе (называемом также кодированием), происходит запись алгоритма на
каком-либо языке программирования.
Синтаксическая отладка программы, то есть исправление ошибок, связанных с
неверным использованием конструкций языка программирования. Эти ошибки
выявляются на этапе компиляции программы.
Тестирование программы, то есть проверка ее работоспособности на различных
вариантах исходных данных с просчитанными вручную результатами. Эти результаты
должны совпасть с результатами, полученными при расчете на компьютере. При их
несовпадении следует искать в программе логические ошибки, связанные с неверным
алгоритмом.
Тесты
для
проверки
работоспособности
программы
должны
подготавливаться в виде таблицы вида:
Номер теста
Назначение
Входные
Выходные
теста
данные
данные
Количество тестов должно быть таким, чтобы каждый тест проверял какую-то
специфическую ситуацию, и не было ситуаций, не проверенных ни одним из тестов.
В дальнейшем будут приведены примеры решения задачи для различных видов
вычислительных процессов.
Существуют следующие виды вычислительных процессов:
Линейный процесс - последовательное размещение шагов.
Разветвляющийся процесс - в зависимости от условия нужно выполнять либо одно,
либо другое действие. В алгоритме используются конструкции
ЕСЛИ условие ТО
Действия
ИНАЧЕ
Действия
ЕСЛИ ВСЕ
В качестве действий может стоять проверка другого условия . Чтобы избежать
вложенных условия, используется конструкция ВЫБОР. Она позволяет иметь несколько
ветвей для проверки равенства переменной одному из многих значений. Такая
конструкция имеет вид:
ВЫБОР ПО переменная
Значение_1: Действия
Значение_2: Действия
Значение_n: Действия
*: Действия
ВЫБОР ВСЕ
* означает, что переменная не равна ни одному значению.
Циклический процесс - это такой процесс, в котором некоторая последовательность
действий выполняется несколько раз до тех пор, пока выполняются некоторые условия. В
алгоритме используется конструкция
ПОКА условие ВЫПОЛНИТЬ
Действия
ПОКА ВСЕ
Все задачи являются комбинацией этих трех видов процессов.
Лекция 2. Разветвляющийся вычислительный процесс
Пример алгоритма разветвляющегося процесса
Студенты Иванов и Петров за время практики заработали определенную сумму.
Кто из них заработал большую сумму? Определить средний заработок.
Таблица спецификаций:
Входные величины
Имя
X
Выходные величины
Назначение
Диапазон
Имя
Назначение
Диапазон
Сумма,
заработанная
Ивановым
Действительное
число
M
Средний
заработок
Действительное
число
>0
Y
Сумма,
заработанная
Петровым
Действительное
число
>0
Словесное описание алгоритма:
1. Ввод Х и У.
2. M=(X+Y)/2
>0
S
Сообщение о
соотношении
заработка
Текст
3. ЕСЛИ Х>У ТО
3.1.S=―Иванов заработал больше―.
3.2. Переход к п. 5
ЕСЛИ ВСЕ
4. ЕСЛИ У>Х ТО
4.1. S=―Петров заработал больше―
4.2. Переход к п. 5
ИНАЧЕ
4.3. S=―Они заработали поровну―
ЕСЛИ ВСЕ
5.Вывод S и M
Язык C#
Язык С# является одним из тех, которые можно использовать для создания
приложений. Он эволюционировал из языков С и C++ и был создан Microsoft специально
для работы с платформой .NET. Благодаря тому, что язык С# разрабатывался недавно, в
его состав вошли многие из наилучших функциональных возможностей других языков, но
без присущих им проблем.
Продемонстрируем пример создания простого консольного приложения, то есть
такого, которое не предусматривает применение графических окон, благодаря чему в них
не нужно заботиться ни о кнопках, ни о меню, ни о взаимодействии с курсором мыши и
т.п. Вместо этого оно запускается в окне командной строки.
Создав новое консольное приложение, мы увидим в окне кода строки
namespace ConsoleApplicationl
{class Program
{static void Main(string[] args)
{} } }
и вставим строки, которые выделим жирным шрифтом
namespace ConsoleApplicationl
{class Program
{static void Main(string[] args)
{// Вывод текста на экран
Console.WriteLine(“The first app in Beginning C# Programming!”) ;
Console.ReadKey();
}}}
Здесь вставлено два комментария – неисполняемые тексты – и два оператора –
вывод текста и ожидание нажатия клавиши для того, чтобы результат не исчез, и можно
было его увидеть.
Структура программы
Программа представляет собой последовательность операций, манипулирующих
данными. Код на С# состоит из ряда операторов, каждый из которых оканчивается
символом точки с запятой. С# является языком с блочной структурой, то есть все
операторы относятся к какому-то блоку кода. В каждом блоке, который отделяется от
остальной части кода с помощью фигурных скобок ({ и }), может содержаться любое
количество операторов или вообще ни одного. Блоки кода также могут и вкладываться
один в другой, то есть одни блоки могут содержать в себе другие блоки,
Комментарии
Комментарий – неисполняемая часть программного кода; используется для
внесения пояснений и начинается с //
Переменные В переменные можно помещать данные и затем при необходимости
либо извлекать их оттуда, либо проверять их наличие. Переменные бывают разных типов.
Чтобы использовать переменные, их нужно объявлять. Это означает, что им необходимо
назначать имя и тип. После объявления их можно начинать использовать в качестве
единиц хранения для данных того типа, для хранения которого они предназначены
согласно объявлению.
В синтаксисе С# объявление переменных осуществляется указанием типа и имени
переменной: <тип> <имя>;
При попытке использовать переменную, которая не была объявлена, код не будет
компилироваться. При попытке использовать переменную без присваивания ей значения
тоже будет возникать ошибка. Имена переменных состоят из латинских букв и цифр,
начиная с буквы. Малые и большие буквы считаются различными символами.
Основные типы переменных:
int – целое число;
float – действительное число;
bool – булевское значение, принимающее значения true (истина) и false (ложь);
char – одиночный символ;
string – последовательность символов.
Пример программного кода с объявлением переменных, присваиванием им
значений и выводом на экран:
int mylnteger=17;
string myString = "mylnteger is";
Console.WriteLine("{0} {1}.", myString, mylnteger); Console.ReadKey(); Переменным
присваиваются два фиксированных значения констань с помощью операции
присваивания. При присваивании строковых значений строки обязательно должны
заключаться в двойные кавычки.
Оператор вывода строки кроме выводимого текста содержит указание
переменных. Внутри скобок содержатся две вещи:

строка, подлежащая выводу;

список разделенных запятыми переменных, значения которых должны
вставляться в выходную строку.
Строка представляет собой шаблон, в который вставляется содержимое
переменных. Каждый набор фигурных скобок в строке является меткой-заполнителем, на
месте которой во время выполнения будет находиться содержимое одной из указанных в
перечне переменных. Каждая метка-заполнитель (или строка форматирования)
представляется в виде заключенного в фигурные скобки целого числа. Отсчет этих целых
начинается с нуля и затем просто увеличивается на 1. Общее количество метокзаполнителей должно
соответствовать количеству переменных, указываемых в
разделенном запятыми списке следом за строкой.
Выражения.
Комбинация знаков операций и операндов, результатом которой является
определенное значение, называется выражением. Знаки операций определяют действия,
которые должны быть выполнены над операндами. Каждый операнд в выражении может
быть выражением. Значение выражения зависит от расположения знаков операций и
круглых скобок в выражении, а также от приоритета выполнения операций.
В языке С# присваивание также является выражением, и значением такого
выражения является величина, которая присваивается. Например, x=a+b;
Операнд - это константа, идентификатор или вызов функции.
Вызов функций состоит из имени функции, за которым следует необязательный
список выражений в круглых скобках:
идентификатор (список выражений)
Выражения со знаками операций могут участвовать в выражениях как операнды.
Выражения со знаками операций могут быть унарными (с одним операндом), бинарными
(с двумя операндами) и тернарными (с тремя операндами).
Унарное выражение состоит из операнда и предшествующего ему знака унарной
операции и имеет следующий формат: Знак унарной операции операнд
Бинарное выражение состоит из двух операндов, разделенных знаком бинарной
операции: операнд1 знак бинарной операции операнд2.
Тернарное выражение состоит из трех операндов, разделенных знаками тернарной
операции (?) и (:), и имеет формат:
операнд1 ? операнд2 : операнд3 .
Операции
В языке С# имеются следующие унарные операции:
- унарный минус;
++ увеличение (инкремент);
-- уменьшение (декремент);
Операции увеличения и уменьшения увеличивают или уменьшают значение
операнда на единицу.
int t=1, s=2, z, f;
z=(t++)*5;
Вначале происходит умножение t*5, а затем увеличение t. В результате получится
z=5, t=2.
Бинарные операции
Операция умножения (*) выполняет умножение операндов.
Тип произведения i и f преобразуется к типу float, затем результат присваивается
переменной g.
Операция деления (/) выполняет деление первого операнда на второй. Если две
целые величины не делятся нацело, то результат округляется в сторону нуля.
При попытке деления на ноль выдается сообщение во время выполнения.
Операция остаток от деления (%) дает остаток от деления первого операнда на
второй. Знак результата совпадает со знаком делимого. Если второй операнд равен нулю,
то выдается сообщение.
Операция вычитания (-) вычитает второй операнд из первого.
Операция простого присваивания используется для замены значения левого
операнда, значением правого операнда. Левый операнд операции присваивания должен
быть идентификатором целого и действительного типов.
Кроме простого присваивания, имеется целая группа операций присваивания,
которые объединяют простое присваивание с одной из бинарных операций. Такие
операции называются составными операциями присваивания и имеют вид:
операнд-1 бинарная операция = операнд-2
Составное присваивание по результату эквивалентно следующему простому
присваиванию:
операнд-1 = операнд-1 бинарная операция операнд-2
Бинарная операция + для строк означает сцепление двух строк и присвоение
результата третье1й строке.
Пример использования арифметических операций.
float firstNumber, secondNumber;
Console.WriteLine("Введите число:");
firstNumber = Convert.ToSingle(Console.ReadLine());
Console.WriteLine("Введите еще одно число:");
secondNumber = Convert.ToSingle(Console.ReadLine());
Console.WriteLine("Сумма {0} и {1} равна {2}.", firstNumber,
secondNumber, firstNumber + secondNumber);
Console.WriteLine("Результат вычитания {0} из {1} равен {2}.",
secondNumber, firstNumber, firstNumber - secondNumber);
Console.WriteLine("Произведение {0} и {1} равно {2}.", firstNumber,
secondNumber, firstNumber * secondNumber);
Console.WriteLine("Результат деления {0} на {1} равен {2}.",
firstNumber, secondNumber, firstNumber / secondNumber);
Console.WriteLine("Остаток от деления {0} на {1} равен {2}.",
firstNumber, secondNumber, firstNumber % secondNumber);
Console.ReadKey();
Сначала объявляются переменные, в которых должны сохраняться вводимые
числа:
Для ввода чисел к результату получаемой Console. ReadLine () строки применяется
команда Convert. ToSingle () для преобразования ее в число float. Это число затем
присваивается объявленной ранее переменной firstNumber:
Подобным образом вводится второе число и результат присваивается второй
переменной.
Все операторы языка С# могут быть условно разделены на следующие категории:
- условные операторы, к которым относятся оператор условия if и оператор выбора
switch;
- операторы цикла (for,while,do while, for each);
Операторы в программе могут объединяться в блоки с помощью фигурных скобок.
Все операторы языка С#, кроме блоков, заканчиваются точкой с запятой ";".
Выполнение составного оператора заключается в последовательном выполнении
составляющих его операторов.
Разветвлением называется процесс управления тем, какая строка кода должна
выполняться следующей. Для этого существуют условные операторы. Действие условного
оператора основано на сравнении проверяемого значения с одним или более возможными
значениями с применением булевской логики.
Далее описаны три доступные в С# методики разветвления:

тернарная операция;

оператор if;

оператор switch.
Тернарная операция
Самый простой способ выполнить сравнение — это воспользоваться тернарной
операцией. Синтаксис этой операции выглядит следующим образом:
<условие> ? <выражение_если_истина> : <выражение если ложно>
Пример тернарной операции:
string result = (mylnteger < 10) ? "Меньше 10" : "Больше или равно 10";
Результатом приведенной тернарной операции будет какая-то одна из двух строк,
присваиваемая переменной result. Выбор того, какая из них должна присваиваться, будет
делаться сравнением значения mylnteger с числом 10, при этом в случае, если это значение
меньше десяти, присваиваться будет первая строка, а если больше или равно 10 — то
вторая.
Такая операция вполне подходит для простых присваиваний, подобных
показанному, но не совсем удобна для выполнения на основании сравнения более
длинных фрагментов кода. Для них больше подходит оператор if.
Условия
В качестве условия ставится сравнение, то есть два операнда (константы или
идентификаторы), соединенные одним из знаков операции сравнения
Знак операции
<
<=
>=
==
Операция
Меньше
Меньше или равно
Больше или равно
Равно
!=
Не равно
Результатом сравнения будет булевское значение (true или false)
Простые условия могут объединяться в сложные с помощью булевских операций:
Логическое НЕ varl = !var2;
Логическое И
varl = var2 && var3;
Логическое ИЛИ varl = var2 | | var3;
Оператор if
Наиболее простой способ использования оператора if выглядит так, как показано
ниже, и подразумевает вычисление выражения <условие> и выполнение следующей за
ним строки кода в случае, если <условие> возвращает true:
if (<условие>)
<код, выполняемый, если <условие> равно true>;
После выполнения этого кода, или невыполнения из-за того, что в результате
вычисления выражения <условие> было получено false, выполнение программы
возобновляется со следующей строки кода.
Вместе с оператором if также может указываться и дополнительный код с
помощью оператора else. Этот оператор выполняется в случае, если при вычислении
выражения <условие> получается false:
if (<условие>)
<код, выполняемый, если <условие> равно true>;
else
<код, выполняемый, если <условие> равно false>;
Оба раздела кода могут занимать несколько строк и представлять собой
заключенные в фигурные скобки блоки.
Пример:
if (i < j) i++; else { j = i-3; i++; }
Этот пример иллюстрирует также и тот факт, что на месте оператор-1, так же как и
на месте оператор-2 могут находиться составные операторы.
Допускается использование вложенных операторов if. Оператор if может быть
включен в конструкцию if или в конструкцию else другого оператора if. Чтобы сделать
программу более читабельной, рекомендуется группировать операторы и конструкции во
вложенных операторах if, используя фигурные скобки. Если же фигурные скобки
опущены, то компилятор связывает каждое ключевое слово else с наиболее близким if, для
которого нет else.
Пример:
{ int t=2, b=7, r=3;
if (t>b)
{ if (b < r) r=b; }
else r=t;}
В результате выполнения этой программы r станет равным 2.
Если же в программе опустить фигурные скобки, стоящие после оператора if, то
программа будет иметь следующий вид:
{ int t=2,b=7,r=3;
if ( t>b)
if ( b < c ) t=b;
else r=t;}
В этом случае r получит значение равное 3, так как ключевое слово else относится
ко второму оператору if, который не выполняется, поскольку не выполняется условие,
проверяемое в первом операторе if.
Следующий фрагмент иллюстрирует вложенные операторы if:
char ZNAC;
int x,y,z;
:
if (ZNAC == '-') x = y - z;
else if (ZNAC == '+') x = y + z;
else if (ZNAC == '*') x = y * z;
else if (ZNAC == '/') x = y / z;
else ...
Из рассмотрения этого примера можно сделать вывод, что конструкции,
использующие вложенные операторы if, являются довольно громоздкими и не всегда
достаточно надежными. Другим способом организации выбора из множества различных
вариантов является использование специального оператора выбора switch.
Пример программы (алгоритм приведен ранее)
float X, Y,M;
string S;
X = Convert.ToSingle(Console.ReadLine());
Y = Convert.ToSingle(Console.ReadLine());
M = (X + Y) / 2;
if (X > Y) S = "Иванов заработал больше";
else
if (X < Y) S = "Петров заработал больше";
else S = "Они заработали поровну";
Console.WriteLine("Результат: {0} Среднее {1}", S, M);
Console.ReadKey();
Оператор switch
Этот оператор похож на if тем, что тоже умеет условно выполнять код на
основании проверяемого значения. Однако в отличие от него, switch позволяет проверять
переменную сразу на соответствие множеству различных значений, а не с помощью
множества отдельных условий. В таких проверках разрешено использовать только
дискретные значения, а не конструкции вроде "больше чем X", поэтому и способ
применения этого оператора немного отличается.
Структура оператор switch выглядит следующим образом:
switch (< проверяемая_переменная>)
{ case <значение_для_сравпения_ 1 >:
<код, подлежащий выполнению, если <проверяемая_переменная> равна
<значение_для_сравнения_1>
break;
case <значение_для_сравнения_2>:
<код,
подлежащий
выполнению,
если
<проверяемая_переменная>
равна<значение_для_сравнения_2»
break;
case <значение_для_сравнения_М>:
<код, подлежащий выполнению, если <проверяемая_переменная> =
break;
default:
<код, подлежащий выполнению, если <проверяемая_переменная> не равна ни
одному из значений
break;
}
Значение в <проверяемая_переменная> сравнивается с каждым из значений
<значение_для_сравнения_Х> (задаваемых с помощью операторов case) и если удается
обнаружить совпадение, тогда выполняется тот код, который содержится в разделе,
соответствующем обнаруженному совпадению. Если не удается обнаружить ни одного
совпадения, выполняется тот код, который содержится в разделе default, при условии, что
такой раздел существует.
В конце кода в каждом разделе обязательно добавляется дополнительная команда
break, исключающая вероятность перехода после обработки одного блока case к обработке
следующего оператора case, потому что это недопустимо.
Пример программы. Определение времени года по номеру месяца
int Month;
string Season, Error="Неверный номер месяца";
Month = Convert.ToInt32(Console.ReadLine());
switch (Month)
{case 1:case 2:case 12:Season="Зима";
Console.WriteLine("Время года: {0}",Season);break;
case 3:case 4:case 5: Season = "Весна";
Console.WriteLine("Время года: {0}",Season);break;
case 6:case 7:case 8: Season = "Лето";
Console.WriteLine("Время года: {0}", Season);break;
case 9:case 10:case 11: Season = "Осень";
Console.WriteLine("Время года: {0}", Season);break;
default: Console.WriteLine("{0}", Error);break; }
Console.ReadKey();
Лекция 3. Циклический вычислительный процесс
Циклический процесс - это такая форма организации действий, при которой одна
последовательность действий выполняется несколько раз до тех пор, пока выполняются
некоторые условия
Цикл включает несколько этапов:
1). Подготовка цикла (блок ‖начальные присвоения―).
2). Тело цикла - последовательность действий, выполняемая в цикле.
3). ‖Условие― - содержит условие, при выполнении которого цикл работает, то есть
выполняется тело цикла.
Пример. Группа студентов из N человек сдавала экзамен, и каждый получил
оценку. Найти средний балл из оценок группы.
Таблица спецификаций:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
N
Число
студентов,
сдававших
экзамен
Целое число
S
Средний балл
Действительное
число
Вектор оценок
из N элементов
Целые числа
на [2,5]
C
>2 и <25
группы
>0
M
Сообщение о
неверном N
Текст
M1
Сообщение о
неверной
оценке
Текст
Словесное описание алгоритма:
1.
N=1
2.
ПОКА N<=2 или N>25 ВЫПОЛНИТЬ
2.1. Ввод N
2.2. ЕСЛИ N<=2 или N>25 ТО
2.2.1. Вывод M.
ЕСЛИ ВСЕ
ПОКА ВСЕ
3.
I=1 S=0.
4.
ПОКА I<=N ВЫПОЛНИТЬ
4.1. C=1
4.2. ПОКА C<2 или C>5 ВЫПОЛНИТЬ
4.2.1. Ввод C
4.2.2. ЕСЛИ C<2 или C>5 ТО
4.2.2.1. Вывод M1
ЕСЛИ ВСЕ
ПОКА ВСЕ
4.3. S=S+C
4.4. I=I+1
ПОКА ВСЕ
5.
S=S/N
6.
Вывод S
Цикл do
Такой цикл функционируют следующим образом. Сначала выполняется код тела цикла,
затем производится булевская проверка, и если в ее результате возвращается true, данный
код выполняется снова, и так повторяется до тех пор, пока после проверки не будет
возвращено значение false, в этом случае цикл завершается.
Структура цикла do выглядит, как показано ниже, и подразумевает, что выражение
<условие> должно возвращать одно из булевских значений:
do
{ <код, подлежащий выполнению в цикле>
} while (<условие>);
Пример (алгоритм описан выше)
int N,C,i;
float S=0;
string M=”Неверное N”,M1=”Неверная оценка”;
do
{ Console.WriteLine("Введите число учеников");
N=Convert.ToInt32(Console.ReadLine());
if (N<0||N>25) Console.WriteLine ({0},M);
}while(N<0||N>25);
Console.WriteLine("Введите оценки");i=0;
do
{do
{C= Convert.ToInt32(Console.ReadLine());
if(C<2||Ci>5) Console.WriteLine ({0},M1);
}while (C<2||C>5); S+=C;i++;}while(i<N);
S/=N;
Console.WriteLine("Средний балл {0},S;
Console.ReadKey();
Здесь цикл do используется не только для обработки вектора оценок, но и для
организации ввода с контролем.



Цикл while
Этот цикл очень похож на цикл do, но имеет одно важное отличие: булевская проверка в
них выполняется в начале, а не в конце цикла. Если после выполнения этой проверки
возвращается false, код в теле цикла вообще не выполняется. Вместо этого сразу
выполняется код, следующий непосредственно за циклом.
Структура цикла while:
while (<условие>)
{ <код, подлежащий выполнению в цикле>
}
Перепишем тот же пример с циклом while для обработки вектора.
int N,C,i;
float S=0;
string M=”Неверное N”,M1=”Неверная оценка”;
do
{ Console.WriteLine("Введите число учеников");
N=Convert.ToInt32(Console.ReadLine());
if (N<0||N>25) Console.WriteLine ({0},M);
}while(N<0||N>25);
Console.WriteLine("Введите оценки");i=0;
while(i<N)
{do
{C= Convert.ToInt32(Console.ReadLine());
if(C<2||Ci>5) Console.WriteLine ({0},M1);
}while (C<2||C>5); S+=C;i++;};
S/=N;
Console.WriteLine("Средний балл {0},S;
Console.ReadKey();
Цикл for
Цикл этого типа выполняется определенное количество раз и обладает собственным
счетчиком. Для определения цикла for требуется описанная ниже информация:
начальное значение для инициализации переменной, играющей роль
счетчика;
условие для продолжения цикла, в котором участвует переменная
счетчик;
операция, которая должна выполняться над переменной-счетчиком в
конце каждого цикла.
Например, при желании создать цикл for и сделать так, чтобы значение его
счетчика увеличивалось на 1 с 1 до 10, в качестве начального значения потребуется
указать 1, в качестве условия — то, что значение счетчика должно быть меньше или
равно 10, а в качестве операции, которая должна выполняться в конце каждого такого
цикла — увеличение счетчика на 1.
Вся эта информация должна размещаться в структуре цикла следующим образом:
for {<инициализация>; <условие>; <операция>)
{<код, подлежащий выполнению в цикле> }
Работать этот цикл будет точно так же, как и показанный ниже цикл while:
< инмциализация>
while {<условие>)
{ <код, подлежащий выполнению в цикле>
<операция> }
Формат цикла for, однако, делает код более удобным для восприятия, поскольку его
синтаксис подразумевает задание всех деталей цикла в одном месте, а не разнесение его
по нескольким операторам и их размещение в разных частях кода.
Тот же пример с циклом for:
int N,C,i;
float S=0;
string M=”Неверное N”,M1=”Неверная оценка”;
do
{ Console.WriteLine("Введите число учеников");
N=Convert.ToInt32(Console.ReadLine());
if (N<0||N>25) Console.WriteLine ({0},M);
}while(N<0||N>25);
Console.WriteLine("Введите оценки");
for(i=0:i<N;i++){do
{C= Convert.ToInt32(Console.ReadLine());
if(C<2||Ci>5) Console.WriteLine ({0},M1);
}while (C<2||C>5); S+=C}
S/=N;
Console.WriteLine("Средний балл {0},S;
Console.ReadKey();
Итерационные циклы
Итерационными называются такие циклы, количество повторений которых зависит от
точности вычислений, а не определяется как некоторое известное число.
С помощью таких циклов вычисляются функции в виде разложения в ряд Тейлора.
В таких задачах задается значение x, при котором нужно вычислить функцию, и точность
вычислений .
Функция представляется в виде суммы ряда.
f ( x)  U 0  U1  ...  U n
. Количество членов ряда определяется тем, когда будет достигнута заданная точность, то
есть когда будет выполнено условие | U n |  . Для членов ряда рассчитывается
итерационная формула, определяющая зависимость очередного члена ряда
предыдущего.
В качестве примера рассмотрим ряд для разложения в ряд функции f ( x)  sin x
(1) i x 2i 1
(1) i x 2i 3
Ui 
U i 1 
(2i  1)!
(2i  3)!
Для нашего примера U 0  x
U i 1
1
1
 x 2
U i 1  U i x 2
Ui
(2i  2)(2i  3)
(2i  2)(2i  3) .
1.
2.
3.
4.
5.
Таким образом, алгоритм нахождения sin x по итерационной формуле имеет вид:
Ввод x,e
S=0
i=1
U1=x
ПОКА |U1|>e ВЫПОЛНИТЬ
x2
5.1.U2=-U1 (2i  2)(2i  3)
5.2.S=S+U2
5.3.i=i+1
от
5.4.U1=U2
ПОКА ВСЕ
6. Вывод S,i
Программа
float x, e, S, U1, U2;
int i;
Console.WriteLine("Введите x и точность");
x = Convert.ToSingle(Console.Read());
e = Convert.ToSingle(Console.ReadLine());
U1 = x;
S = U1;
i = 0;
do
{U2 = -U1 * x * x / ((2 * i + 2) * (2 * i + 3));
S += U2;
U1 = U2;
i++;}
while (Math.Abs(U2) >= e);
Console.WriteLine("Функция={0}, Число шагов={1}", U1, i);
Console.ReadKey();
Работа с векторами и матрицами
Массивы
У всех рассмотренных до этого типов была одна общая черта: каждый из них позволял
хранить одно единственное значение. Однако бывают ситуации, в которых требуется
сохранять много данных, и в таких ситуациях эти типы переменных являются не очень
удобными. Иногда бывает необходимо сохранять несколько значений одного и того же
типа одновременно без использования для каждого из них отдельной переменной.
Например, предположим, что требуется выполнить некоторую обработку имен трех
друзей. Можно объявить простые строковые переменные:
string friendNamel = "Robert Barwell";
string friendName2 = "Mike Parry";
string friendName3 = "Jeremy Beacock";
Но такой подход неэффективен, так как для обработки каждой переменной придется
писать отдельный код. Организовать проход по этому списку строк в цикле не получится.
Однако существует и альтернативный подход, который предусматривает применение
массива. Массивы — это проиндексированные списки переменных, хранящиеся в
единственной переменной типа массива. Например, для хранения трех показанных выше
имен можно создать массив под названием friendNames. Получать доступ к отдельным
членам этого массива можно будет указанием их индекса в квадратных скобках:
friendNames [<индекс>]
Этот индекс представляет собой просто целое число. Для первого элемента в массиве
этим числом будет 0, для второго — 1 и т.д. Это означает, что по элементам массива
можно проходить в цикле:
int i;
for (i = 0; i < 3; i++)
{ Console.WriteLine("Name with index of {0}: {1}", i, friendNames[i]);
// Вывод имени с определенным индексом
}
Элементы массива имеют один единственный тип. Например, типом приведенного в
качестве примера массива friendNames является string.
Объявляются массивы следующим образом:
< тип>[] <имя>;
Массивы должны обязательно инициализироваться перед тем, как к ним можно будет
получить доступ. Получать доступ или присваивать значения int[] mylntArray;
mylntArray[10] = 5;
Инициализировать массивы можно двумя способами: указанием всего содержимого
массива в виде констант, либо указанием размера массива и применением ключевого
слова new для инициализации всех его элементов.
Инициализация массива с использованием констант подразумевает запись
заключенного в фигурные скобки списка разделенных запятыми значений для элементов:
int[] mylntArray = {5, 9, 10, 2, 99};
Здесь задается массив mylntArray, состоящий из пяти элементов, каждому из которых
присваивается целочисленное значение.
Второй подход требует применения следующего синтаксиса:
int[] mylntArray = new int[5];
Здесь ключевое слово new используется для явной инициализации массива, а
константа — для определения его размера. Такой подход приводит к присваиванию все
членам массива значения по умолчанию, каковым для числовых типов является 0.
При желании оба подхода можно комбинировать:
int[] mylntArray = new int [5] {5, 9, 10, 2, 99};
В случае применения такой техники размеры должны обязательно совпадать. То есть
использовать следующую строку кода нельзя:
int[] mylntArray = new int [10] {5, 9, 10, 2, 99};
Здесь массив определен как состоящий из 10 членов, но инициализированы только 5
членов, поэтому компиляция даст ошибку.
Как и для других типов переменных, инициализировать массив в той же самой строке,
в которой он объявляется, не обязательно. Например, следующий подход является вполне
допустимым:
int [ ] mylntArray; mylntArray = new int[5];
Многомерные массивы
Многомерным называется такой массив, в котором для получения доступа к элементам
применяется несколько индексов.
Например, предположим, что требуется хранить в памяти оценки 20 студентов по 4
предметам. Позицию в матрице можно задать двумя координатами — строка – номер
экзамена, столбец – номер студента. Эти две координаты можно представить в виде
индексов.
Объявить и инициализировать двумерный массив ball типа int можно следующим
образом:
int [,] ball = new int[4,20];
Пример задачи с матрицей
Задана матрица A целых чисел размера MxN. Получить вектор B, каждый элемент
которого является минимальным элементом соответствующего столбца матрицы A.
Таблица спецификаций:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
M
Число строк матрицы A
Целое
B
Вектор размером
N
Целые
числа
N
Число столбцов матрицы
A
Целое число
A
Матрица размером MхN
Целые
числа
Словесное описание алгоритма:
1. Ввод M
2. Ввод N
3. I=1
4. ПОКА I<=M ВЫПОЛНИТЬ
4.1. J=1
4.2. ПОКА J<=N ВЫПОЛНИТЬ
4.2.1. Ввод AI,J
4.2.2. J=J+1
ПОКА ВСЕ
4.3. I=I+1
ПОКА ВСЕ
5. J=1
6. ПОКА J<=N ВЫПОЛНИТЬ
6.1. BJ=A1,J
6.2. I=1
6.3. ПОКА I<=M ВЫПОЛНИТЬ
6.3.1. ЕСЛИ AI,J< BJ ТО
6.3.1.1. BJ= AI,J
ЕСЛИ ВСЕ
6.3.2. I=I+1
ПОКА ВСЕ
6.4. J=J+1
ПОКА ВСЕ
7. I=1
8. ПОКА I<=N ВЫПОЛНИТЬ
8.1. Вывод BI
8.2. I=I+1
ПОКА ВСЕ
Программа:
int N,M,A[,]=new int[10,6],[]B=new int[8];]
Console.WriteLine("Введите число строк");
M=Convert.ToInt32(Console,ReadLine());
cout <<”Input count of column”; cin>>N;
Console.WriteLine("Введите число столбцов");
N=Convert.ToInt32(Console,ReadLine());
Console.WriteLine("Введите матрицу");
for (i=0;i<M;i++)
for (j=0;j<N;j++)
{A[i,j]= Convert.ToInt32(Console,Read());Console.Readline();}
for (j=0;j<N;j++)
{B[j]=A[0,j];
for(i=0;i<M;i++)
if (A[I,j]<B[j])
B[j]=A[I,j];}
Console.WriteLine("Выходной вектор");
for (i=0;i<N;i++)
Console.Write(" {0}",B[i]);
Console.ReadKey();
Лекция 4. Модульное программирование
Довольно часто необходимо, чтобы некоторые подзадачи, например, поиск
максимального значения в массиве, выполнялись в нескольких точках программы.
Конечно, можно добавлять в приложение идентичные (или почти идентичные) разделы
кода всякий раз, когда в этом возникает необходимость, но такой подход имеет свои
недостатки. Изменение даже одной небольшой детали алгоритма в таком случае означает,
что соответствующие изменения потребуется вносить во множество разделов кода,
которые могут быть разбросаны по всему приложению. Пропуск одного из этих разделов
может повлечь за собой серьезные последствия и сделать неработоспособным все
приложение. К тому же это еще и существенно удлиняет приложение.
Решить эту проблему позволяют функции. Функции в языке С# являются
средствами предоставления блоков кода, которые могут выполняться в любой точке
приложения.
Например, можно создать функцию, вычисляющую максимальное значение в массиве.
Далее ее можно выполнять из любой точки в коде и в каждом случае использовать для
этого одинаковые строки кода. Поскольку описывать этот код нужно только один раз,
любые вносимые в него изменения будут отражаться на данной операции вычисления
при всяком ее применении. Функции еще также могут применяться для создания
универсального кода, что позволяет им выполнять одни и те же операции над
варьирующимися данными. Предоставлять необходимую для работы информацию
функциям можно в виде параметров, а получать от них результаты — в виде
возвращаемых значений. В предыдущем примере в роли параметра мог бы выступать
подлежащий поиску массив, а в роли возвращаемого значения — максимальная величина
в этом массиве. Это означает, что одну и ту же функцию можно было бы использовать для
работы каждый раз с другим массивом.
При решении любой, достаточно сложной задачи, как уже говорилось ранее, первым
этапом является внешнее проектирование – разбиение задачи на подзадачи и составление
таблицы спецификаций для каждой подзадачи.
Разбиение задачи на подзадачи оформляется в виде схемы иерархии, причем подзадачи
выделяются по общности выполняемых ими действий. К одной и той же подзадаче,
реализуемой в виде функции, может происходить обращение несколько раз с различными
параметрами. Важно только, чтобы эти параметры всегда передавались в одном и том же
порядке, соответствующем их перечислению в заголовке функции.
Пример разбиения задачи на подзадачи:
Заданы две матрицы целых чисел A(m,m) и B(k,k) и два вектора из целых чисел X(m) и
Y(k), где 1<m10 1<k8. Вычисляются P – число нулевых элементов на главной
диагонали матрицы A и Q – число нулевых элементов на главной диагонали матрицы B.
Если P<Q, то необходимо получить вектор C(m), а в противном случае - вектор D(k), где
k
m
Ci   Ai , j X j  max Ai , j
j 1
i=1..m
Di   Bi , jY j  max Bi , j
i=1..k
j 1
Проведя анализ задачи, можно построить следующую схему иерархии
данной задачи:
подзадач
Здесь main - главная функция, выполняющая решение всей задачи;
inpmatr - функция ввода матрицы;
inpvect - функция ввода вектора;
chis0
- функция подсчета числа нулевых элементов на главной диагонали
матрицы;
sum
- функция вычисления суммы произведений строки матрицы на вектор;
outrez - функция вывода результирующего вектора;
max
- функция нахождения максимального элемента матрицы.
Для каждой функции составим таблицу спецификаций и словесный алгоритм:
Функция main:
Имя
m
Входные величины
Назначение
Число строк и столбцов матрицы A
k
и число элементов вектора X
Число строк и столбцов
матрицы B и число элементов вектора
Y
Алгоритм:
1.
Ввод m,k
2.
Вызов функции inpmatr(m,A)
3.
Вызов функции inpmatr(k,B)
4.
Вызов функции inpvect(m,X)
5.
Вызов функции inpvect(k,Y)
6.
P=chis0(m,A)
7.
Q=chis0(k,B)
8.
ЕСЛИ P<Q ТО
8.1. Z=max(m,A)
8.2. j=1
8.3. ПОКА jm ВЫПОЛНИТЬ
Диапазон
Целое
число
Целое
число
Выходные величины
Имя Назначение Диапазон
8.3.1.CH=sum(j,m,A,X)
8.3.2. Cj=CH+Z
8.3.3. j=j+1
ПОКА ВСЕ
8.4. Вызов функции outrez(m,C)
ИНАЧЕ
8.5. Z=max(k,B)
8.6. j=1
8.7. ПОКА jk ВЫПОЛНИТЬ
8.7.1.CH=sum(j,k,B,Y)
8.7.2.Dj=CH-Z
8.7.3. j=j+1
ПОКА ВСЕ
8.8. Вызов функции outrez(k,D)
ЕСЛИ ВСЕ
Функция inpmatr:
Входные величины
2.3.
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
a
Число строк и
столбцов
матрицы
Целое число
X
Матрица
Целые
числа
Алгоритм:
1. i=1
2. ПОКА ia ВЫПОЛНИТЬ
2.1. j=1
2.2. ПОКА ja ВЫПОЛНИТЬ
2.2.1. Ввод Xi,j
2.2.2. j=j+1
ПОКА ВСЕ
i=i+1
ПОКА ВСЕ
Функция inpvect:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
a
Число
Целое число
V
Вектор
Целые числа
элементов
вектора
Алгоритм:
1.
i=1
2.
ПОКА i<=a ВЫПОЛНИТЬ
2.1. Ввод Vi
2.2. i=i+1
ПОКА ВСЕ
Функция outrez:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
b
Число
Целое число
элементов
вектора
V
Вектор
Целые числа
Алгоритм:
1.
i=1
2.
ПОКА i<=b ВЫПОЛНИТЬ
2.1. Вывод Vi
2.2. i=i+1
ПОКА ВСЕ
Функция chis0:
Входные величины
Имя
Назначение
Диапазон
a
Число строк и
Целое число
число
столбцов
матрицы
T
Матрица
Целые числа
Алгоритм:
1. c=0
2. i=1
3. ПОКА i<=a ВЫПОЛНИТЬ
3.1. ЕСЛИ Ti,i=0 ТО
3.1.1. c=с+1
ЕСЛИ ВСЕ
3.2. i=i+1
ПОКА ВСЕ
4. Возврат c
Функция max:
Входные величины
Имя
Назначение
Диапазон
Имя
a
Число строк и
Целое число
mx
число
столбцов
матрицы
X
Матрица
Целые числа
Алгоритм:
1. mx=X1,1
2. ii=1
3. ПОКА ii<=a ВЫПОЛНИТЬ
3.1. jj=1
3.2. ПОКА jj<=a ВЫПОЛНИТЬ
3.2.1.ЕСЛИ Xii,jj>mx ТО
3.2.1.1.mx= Xii,jj
ЕСЛИ ВСЕ
3.2.2.jj=jj+1
ПОКА ВСЕ
Имя
c
Выходные величины
Назначение
Диапазон
Число
Целое
нулевых
элементов на
главной
диагонали
матрицы
Выходные величины
Назначение
Диапазон
МаксимальЦелое число
ный элемент
матрицы
3.3. ii=ii+1
ПОКА ВСЕ
4. Возврат mx
Функция sum:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
a
Номер строки
матрицы
Целое число
s
Сумма
произведений
строки матрицы
на вектор
Целое число
b
Число
столбцов
Целое число
матрицы



T
Матрица
Целые числа
V
Вектор
Целые числа
Алгоритм:
1. j=1
2. s=0
3. ПОКА jb ВЫПОЛНИТЬ
3.1. s=s+Ta,jVj
3.2. j=j+1
ПОКА ВСЕ
4. Возврат s
Определение функции
Если записать код
static void Write ()
{Console.WriteLine("Текст из функции") ; }
static void Main(string[] args)
{Write () ; Console.ReadKey(); }
то он представляет собой две функции Main и Write.
Определение функции состоит из следующих элементов.
Два ключевых слова: static и void.
Имя функции, за которым следуют круглые скобки
Заключенный в фигурные скобки блок кода, который подлежит
выполнению.
При выполнении любого приложения С# первой вызывается та содержащаяся в нем
функция, которая выступает в роли точки входа, а при завершении выполнения этой
функции завершается и работа всего приложения. Весь исполняемый код на С# должен
обязательно иметь такую точку входа. Это функция Main.
Ключевое слово void служит для обозначения того, что функция не возвращает никакого
значения.
Далее идет код, вызывающий функцию, который выглядит следующим образом:
Write ();
Здесь просто вводится имя функции, а за ним — круглые скобки без содержимого. При
достижении программой во время выполнения этой точки, будет запускаться код,
содержащийся внутри функции Write ().
Использование круглых скобок как в определении, так и в вызове функции, является
обязательным.
Возвращаемые значения
Наиболее простым способом для обмена данными с функцией является использование
возвращаемого значения. Функции, имеющие возвращаемое значение, при вызове выдают
именно это значение. Как и переменные, возвращаемые значения имеют тип.
Например, можно создать функцию GetString () с возвращаемым значением типа string.
Использовать такую функцию в коде можно следующим образом:
string myString;
myString = GetString ();
Можно также создать функцию GetVal () с возвращаемым значением типа float.
Такая функция может участвовать в математическом выражении:
float myVal,multiplier = 5.3;
myVal = GetVal() * multiplier;
Наличие у функции возвращаемого значения требует внесения двух следующих
изменений.
 Указание в объявлении функции типа возвращаемого значения вместо
ключевого слова void.
 Использование ключевого слова return для завершения выполнения
функции и передачи возвращаемого значения в вызывающий код.
При достижении оператора return управление выполнением программы сразу же
возвращается вызывающему коду. Никакие строки кода после этого оператора больше не
выполняются, хотя это вовсе не означает, что операторы return могут размещаться только
в последней строке тела функции. Оператор return можно использовать и ранее в коде,
например, после выполнения какой-то ветви алгоритма.
static float GetVal()
{ float checkVal;
if (checkVal < 5) return 4.7;
return 3.2; }
Здесь возвращаться может одно из двух значений, в зависимости от значения checkVal.
Единственным ограничением в данном случае является то, что оператор return должен
обрабатываться перед достижением закрывающей фигурной скобки в функции.
Следующий код недопустим: static float GetValO
{float checkVal;
if (checkVal < 5) return 4.7; }
Здесь получается, что в случае, если значение checkVal >= 5, не будет выполнено
никакого оператора return, что является недопустимым. Все пути обработки должны
обязательно приводить к оператору return.
Параметры
Когда функция должна принимать параметры, следует указать следующее:
 список принимаемых функцией параметров вместе с их типами в именами в определении
этой функции;
 соответствующий список параметров в каждом вызове этой функции.
Это подразумевает использование показанного ниже кода, в котором может
присутствовать любое количество параметров, при этом для каждого из них должен
указываться тип и имя:
static <возвращаемый_тип> <имя_функции> ( <тип_параметра> <имя_параметра>, ...)
{ return <возвращаемое_значение>; }
Параметры отделяются друг от друга запятыми, и каждый из них доступен в коде
функции через переменную. Например, простая функция может брать два параметра float
и возвращать результат их умножения:
static float Product(float paraml, float param2)
{ return paraml * param2; }
Соответствие параметров
При вызове функции параметры должны указываться в точности, как в определении
функции, то есть соответствующего типа, в соответствующем количестве и
соответствующем порядке. Например, функцию static void MyFunction(string myString,
float myFloat)
{}
нельзя вызывать так: MyFunction(8.6, "Hello");
Здесь в качестве первого параметра передается значение float, а в качестве
второго — значение string, что не соответствует порядку, в котором эти параметры были
указаны в определении функции.
Эту функцию также нельзя вызывать и следующим образом:
MyFunction("Hello");
Здесь передается только один параметр string, а согласно определению функции,
параметров должно быть два. При попытке использовать любой из двух приведенных
выше вызовов функции компилятор будет сообщать об ошибке, вынуждая соблюдать
соответствие заголовку вызываемой функции
Пример параметра-массива
static int MaxValue (int [ ] intArray)
{ int maxVal = intArray[0];
for (int i = 1; i < intArray.Length; i++)
{ if (intArray[i] > maxVal) maxVal = intArray[i]; }
return maxVal;}
static void Main(string [ ] args)
{ int[] myArray = {1, 8, 3, 6, 2, 5, 9, 3, 0, 2};
int maxVal = MaxValue(myArray) ;
Console.WriteLine("Максимальное значение массива равно {0}", maxVal);
Console.ReadKey ();
Во всех демонстрировавшихся до сих пор функциях использовались параметры значения. To есть при каждом применении параметров используемой внутри функции
переменной передавалось значение. Никакие изменения, вносимые в эту переменную в
функции, не оказывали влияние на параметр, передаваемый в вызове функции.
Выходные параметры
Для изменения значения параметра можно указывать, что параметр является выходным
параметром, используя ключевое слово out, которое применяется в виде модификатора
перед параметром как в определении, так и в вызове функции).
Две особенности выходных параметров:
В качестве параметра out можно применять неинициализированную переменную.
Параметр out должен трактоваться как неприсвоенное значение функцией, которая его
использует.
Это означает, что хотя использовать неинициализированную переменную в
качестве параметра out в вызывающем коде допускается, хранящееся в этой переменной
значение при выполнении функции будет утрачиваться.
Для примера рассмотрим функцию MaxValue (), которая возвращает максимальное
значение в массиве. Изменим ее так, чтобы она позволяла получать индекс того элемента,
в котором находится максимальное значение.
Чтобы не усложнять пример, пусть это будет индекс только первого вхождения этого
значения при наличии множества элементов с таким же максимальным значением.
Чтобы добиться такого поведения, достаточно добавить параметр out, изменив
функцию, как показано ниже:
static int MaxValue (int [] intArray, out int maxlndex)
{ int maxVal = intArray[0]; maxlndex = 0;
for (int i = 1; i < intArray.Length; i++)
{ if (intArray[i] > maxVal)
{ maxVal = intArray[i]; maxlndex = i; } }
return maxVal; }
Использовать эту функцию можно так:
int[] myArray = {1, 8, 3, 6, 2, 5, 9, 3, О, 2} ;
int maxIndex;
Console.WriteLine("Максимальное значение myArray равно {0}",
MaxValue(myArray, out maxlndex));
Console.WriteLine("Первое вхождение этого значения встречается в элементе {0}",
maxlndex + 1) ;
Область видимости переменных
У каждой переменной имеется так называемая область видимости, в пределах которой
к ней можно получать доступ.
Область видимости охватывает блок кода, в котором переменная определяется, а также
любые блоки, непосредственно вложенные в него. Блоки кода в функциях идут отдельно
от блоков кода, из которых они вызываются.
static void Write ()
{ string myString = " Строка, определенная в функции Write () " ;
Console.WriteLine("Теперь в функции Write() ") ;
Console.WriteLine("myString = {0}", myString); }
static void Main(string[] args)
{ string myString = "Строка, определенная в MainO";
Write () ;
Console.WriteLine(“Теперь в Main()");
Console.WriteLine("myString = {0}", myString);
Console.ReadKey();
Переменные, область видимости которых распространяется только на одну
единственную функцию, называются локальными переменными. Однако также
допускается использовать и глобальные переменные, область видимости которых
распространяется на несколько функций.
Пример с использованием глобальной переменной
class Program
{static string myString;
static void Write ()
{string myString = "String defined in Write()";
Console.WriteLine("Now in Write ()");
Console.WriteLine("Local myString = {0}", myString);
// Локальная переменная
Console.WriteLine ("Global myString = {0}", Program.myString) ;
// Глобальная переменная
}
static void Main(string[] args)
{ string myString = "String defined in MainO";
Program.myString = "Global string";
Write () ; Console. WriteLine ("\nNow in MainO") ;
Console.WriteLine ("Local myString = @)", myString) ;
Console.WriteLine ("Global myString = {0}", Program.myString) ;
Console.ReadKey() ; } }
Пример программы, алгоритм которой рассмотрен ранее
class Program
const int m=3;
static void inpvect(int a,out int []V)
{int i;
V = new int[a];
for(i=0;i<a;i++)
V[i] = Convert.ToInt32(Console.ReadLine());}
//-------------------static void outrez (int b,int [] V)
{int i;
for (i=0;i<b;i++)
Console.Write("Vector {0} ",V[i]);
Console.WriteLine();
Console.ReadKey();}
//------------------static void inpmatr(int a,out int [,]X)
{int i,j;X = new int[a, a];
for (i=0;i<a;i++)
{Console.WriteLine("Read {0} row of matr",i+1);
for (j = 0; j < a; j++)
X[i, j] = Convert.ToInt32(Console.ReadLine()); }}
//---------------static int max(int a,int [,] X)
{int mx,i,j;mx=X[0,0];
for (i=0;i<a;i++)
for (j=0;i<a;i++)
if (X[ i, j]>mx) mx=X [i,j];
return mx;}
//---------------static int sum(int a,int b,int [,] T,int [] V)
{int s=0,j;
for (j=0;j<b;j++)
s+=T[a,j]*V[j];
return s;}
//---------static int chis0(int a,int [,]T)
{int c=0,i;
for (i=0;i<a;i++)
if (T[i,i]==0)
c++;
return c;}
static void Main(string[] args)
{int [,] A=new int[m,m];
int [,] B=new int[m,m];
int [ ] X=new int[m];
int [] Y=new int[m];
int [ ] C=new int [m];
int []D=new int[m];
int k,P,Q,j,Z,CH,count;
Console.WriteLine("Matrica A");
inpmatr(m,out A);
Console.WriteLine("Vector X");
inpvect(m,out X);
Console.WriteLine("Matrica B");
inpmatr(m,out B);
Console.WriteLine("Vector Y");
inpvect(m,out Y);
P=chis0(m,A);
Q=chis0(m,B);
if (P<Q)
{Z=max(m,A);
for (j=0;j<m;j++)
{CH=sum(j,m,A,X);
C[j]=CH+Z;}
Console.WriteLine("Vector C");
outrez(m,C);}
else
{Z=max(m,B);
for (j=0;j<m;j++)
{CH=sum(j,m,B,Y);
D[j]=CH-Z;}
Console.WriteLine("Vector D");
outrez(m,D);}}
//----------------------}
Лекция 5. Обработка строковых данных
Основным типом при работе со строками является тип string, задающий строки
переменной длины.
Тип string представляет последовательность из нуля или более символов в кодировке
Юникод.
Пример.
string a = "hello";
string b = "h";
b += "ello";
Console.WriteLine(a == b);
Объекты string объявляются как все прочие объекты простых типов – с явной или
отложенной инициализацией. Чаще всего, при объявлении строковой переменной
инициализация задается строковой константой. Но у strng достаточно много
конструкторов. Они позволяют сконструировать строку из:

символа, повторенного заданное число раз;
массива символов char[];

части массива символов.
Примеры объявления строк с вызовом разных конструкторов:
public void TestDeclStrings()
{//конструкторы
string world = “Мир”;
string sssss = new string(’s’,5);
char[] yes = “Yes”.ToCharArray();
string stryes = new string(yes);
string strye = new string(yes,0,2);
Console.WriteLine(“world = {0}; sssss={1}; stryes={2}; strye= {3}”, world, sssss, stryes,
strye);}
Объект world создан без явного вызова конструктора, а объекты sssss, stryes, strye созданы
разными конструкторами sring.
Над строками – объектами этого класса – определен широкий набор операций.
Оператор + служит для объединения строк.
string a = "good " + "morning";
В данном примере создается строковый объект, содержащий текст "good morning".
Оператор [] служит для доступа только для чтения к отдельным знакам объекта string.
string str = "test";
char x = str[2]; // x = 's';
Строковая константа имеет тип string и может быть написана в двух формах: в кавычках и
в кавычках с @ (точная константа). Константа в кавычках:
"good morning"
Точная константа начинается со знака @ и заключена в двойные кавычки. Примеры.
@"good morning"
Преимущество точных сток заключается в том, что escape-последовательности не
обрабатывается, благодаря чему можно удобно написать, например, полное имя и путь
файла:
@"c:\Docs\Source\a.txt" // лучше чем "c:\\Docs\\Source\\a.txt"
Чтобы включить знак двойной кавычки в строку в кавычках с @, следует использовать
знак кавычек дважды:
@"""Ahoy!"" cried the captain."
Сравнение строк
Функция Compare (string, string) сравнивает два заданных объекта string и возвращает
целое число, равное 0, если строки равны, >0, если первая строка больше второй, <0, если
первая строка меньше второй/
Пример сортировка по убыванию:
public int Compare () {
string s1 = “ccc”;
string s2 = “dfgh”;
return - string.Compare (s1,s2); }
Работа с подстрокой
Подстрокой является последовательность символов, содержащихся в строке. Функция
Substring возвращает подстроку исходной строки, начиная с заданной позиции строки.
Она существует в двух формах:
1. Substring(int startIndex)
2. Substring(int startIndex, int length)
Первая форма принимает один параметр – начальная позиция (нумеруется с 0), вторая
форма дополнительно имеет второй параметр – длину подстроки
Пример 1:
string strText = "C# substring function";
string out= strText.Substring(3);
Результат: substring function
Пример 2:
string strText = "C# substring function";
string out= strText.Substring(3, 9);
Результат:substring
Функция Split делит строку по разделителям и размещает слова в массиве:
Split(char[] separator);
Пример:
string strData = "a,b,c,d,e,f,g,h,i,j";
separator = new char[] { ',' };
string[] strSplitArr = strData.Split(separator);
Результат:a b c d e f g h i j
Функция Remove удаляет часть строки, начиная с начального символа возможно с учетом
количества символов
1. Remove(int startIndex);
2. Remove(int startIndex, int count);
Пример 1:
string strText = "C# Remove String Function";
string out= (strText.Remove(2));
Результат:C#
Пример 2:
string strText = "C# Remove String Function";
string out= strText.Remove(10, 7);
Результат:C#
Функция Replace заменяет часть строки другой строкой Она существует в двух видах::
1. Replace(char oldChar, char newChar);
2. Replace(string oldValue, string newValue);
Пример 1:
string strText = "C# Replace $tring Function";
string out=strText.Replace('$', 'S');
Результат: C# Replace String Function
Пример 2:
string strText = "ab abc abcd abcde abcdef";
string out=strText.Replace("ab", "AB");
Результат:AB ABc ABcd ABcde ABcdef
Функция IndexOf используется для получения первой позиции строки или символа в
исходной строке. Поиск ведется или с начала строки или начиная с заданной позиции
строки лмбо до конца строки, либо в пределах заданного количества символов. Формы
функции:
1. IndexOf(char value);
2. IndexOf(string value);
3. IndexOf(char value, int startIndex);
4. IndexOf(string value, int startIndex);
5. IndexOf(char value, int startIndex, int count);
6. IndexOf(string value, int startIndex, int count);
Пример
string strText = "C# IndexOf String Function";
string out1=strText.IndexOf('#');
string out2=strText.IndexOf("Str", 15);
string out3=strText.IndexOf("Str", 3, 15);
Результат: 1 -1 11
Функция Length возвращает длину строки
Пример:
strText = "C# string length function-123";
string out=(strText.Remove(strText.Length);
Результат -1
Функция Join объединяет значения элементов текстового массива в строку, вставляя
между словами разделители. Процесс объединения может начаться с первого элемента
массива или с указанного с учетом указанного количества элементов
Функция существует в двух формах:
1. Join(string separator, string[] value);
2. Join(string separator, string[] value, int startIndex, int count);
Пример
int arrLength = 10;
string[] arr1 = new string[arrLength];
int i = 0;
for (i = 0; i < arr1.Length; i++)
arr1[i] = i.ToString();
string out,out1;
out=string.Join(",", arr1);
out1=string.Join(",", arr1, 7, arr1.Length - 7);
Результат:
0,1,2,3,4,5,6,7,8,9
7,8,9
Функция StartsWith проверяет, начинается ли заданная строка с указанной подстроки или
нет. Она возвращает булевское значение.Ее вид:
StartsWith(string value);
Пример.
string strText = "ASP.Net C# string.StartsWith function";
string out=strText.StartsWith("ASP.Net");
string out1=strText.StartsWith("S");
Результат:
True
False
Функция IndexOfAny() возвращает номер первой позиции строки, совпадающей с началом
массива символов. Функция LastIndexOfAny()возвращает номер последней позиции
строки, совпадающей с концом заданного массива символов.
Пример
string myString = "To.be.or.not.to.be."};
char[] myChars = {'b', 'e'};
int index1 = myString.IndexOfAny(myChars);
int index2 = myString.LastIndexOfAny(myChars);
Результат: 3 17
Интеракив (разбор конкретной ситуации)
Пример задачи, использующей строковые данные
Задан текст, состоящий из слов, записанных через запятые. Длина текста не больше
200 символов. Необходимо выдать на экран слова и их длины. Если слово состоит только
из цифр, то возвести его в куб. Кроме того, составить выходную строку, содержащую
нецифровые слова, в которых порядок символов изменен на обратный.
Иерархия функций:
X
main
n,mslov,mch,mm,rez
x,rsl
n,mslov
str_sl
chisl_cum
str_sl
mch,l
rezstr
N,mslov
n,mslov
str_sl – разбиение строки на слова
chisl_cub – формирование массива кубов чисел по массиву слов
obr_sl – получение из нецифровых слов строки слов в обратном порядке
Для каждой функции составим таблицу спецификаций и словесный алгоритм:
Функция main:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
x
строка
Текст
n
Число слов
Целое число
mslov
Массив слов
Текст
mch
Массив
Целые числа
числовых слов
mm
Число числовых
Целое число
слов
rez
Результирующая
Текст
строка из слов в
обратном
порядке
Словесный алгоритм:
1.
Ввод строки x
2.
n=str_sl(x,‖,‖,mslov)
3.
i=0
4.
ПОКА i<n ВЫПОЛНИТЬ
4.1. Вывод mslovi,длина mslovi
4.2. i=i+1
ПОКА ВСЕ
5.
mm=chisl_cub(n,mslov,mchis)
6.
ЕСЛИ mm=0 ТО
6.1. Вывод сообщения «Нет числовых слов»
ИНАЧЕ
6.2. i=0
6.3. ПОКА i<mm ВЫПОЛНИТЬ
6.3.1. Вывод mchisi
6.3.2. i=i+1
ПОКА ВСЕ
ЕСЛИ ВСЕ
7. rezstr=obr_sl(n,mslov)
8. ЕСЛИ rezstr=‖‖ ТО
8.1.Вывод сообщения «Нет нецифровых слов»
ИНАЧЕ
8.2. Вывод rezstr
ЕСЛИ ВСЕ
Функция str_sl
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
x
строка
Текст
n
Число слов
Целое число
rsl
Разделитель
слов
Текст
mslov
Массив слов
Текст
Словесный алгоритм:
1. Разбиение строки x на массив слов mslov
2. n=длине массива mslov
3. Возврат n
Функция chisl_cub
Входные величины
Имя
Назначение
Диапазон
n
Число слов
Целое число
mslov
Массив слов
Текст
Имя
mch
l
Выходные величины
Назначение
Диапазон
Массив
Целые числа
числовых слов
Число
Целое число
числовых слов
Словесный алгоритм:
1. i=0 l=0
2. ПОКА i<n ВЫПОЛНИТЬ
2.1. j1=номеру позиции первой цифры в mslovi
2.2. j2=номеру позиции последней цифры в mslovi
2.3. ЕСЛИ j1=0 И j2=длина mslovi - 1 ТО
2.3.1. b=результату преобразования mslovi в число
2.3.2. mchl=b*b*b
2.3.3.l=l+1
ЕСЛИ ВСЕ
2.3. i=i+1
ПОКА ВСЕ
3. Возврат l
Функция obr_sl:
Входные величины
Выходные величины
Имя
Назначение
Диапазон
Имя
Назначение
Диапазон
n
Число слов
Целое число
rezstr
Результирующая
Текст
строка из слов в
обратном
порядке
mslov
Массив слов
Текст
Словесный алгоритм:
1. i=0 rezstr=‖‖
2. ПОКА i<n ВЫПОЛНИТЬ
2.1. j=числу цифр в mslovi
2.2. ЕСЛИ jдлине mslov, ТО
2.2.1. a=обращение слова mslovi
2.2.2. Присоединение a к rezstr
2.2.3. Присоединение ―,‖ к rezstr
ЕСЛИ ВСЕ
2.3. i=i+1
ПОКА ВСЕ
3. Возврат rezstr
Программа:
static int str_sl(string x,char[] rsl,char[] kstr,out string[] mslov)
{int n=0,beg;
mslov = new string[20];
string y;
/*do {
beg=x.IndexOfAny(rsl);
if (beg==-1)
beg=x.IndexOfAny(kstr);
mslov[n]=x.Substring(0,beg);
y=x.Substring(beg+1,x.Length-beg-1);
x = y;
n++;
} while(x!="");*/
mslov = x.Split(rsl);
n = mslov.Length;
return n;
}
//--static int chisl_cub(int n,string[] mslov,out int[] mch)
{int l=0,i,j1,j2,b;
mch = new int[20];
char[] cif = {'1','2','3','4','5','6','7','8','9','0'};
for(i=0;i<n;i++)
{j1=mslov[i].IndexOfAny(cif);
j2=mslov[i].LastIndexOfAny(cif);
if(j1==0&&j2==mslov[i].Length-1)
{b=Convert.ToInt32(mslov[i]);
mch[l]=b*b*b;l++;
}
}
return l;
}
//-static string obr_sl(int n,string[] mslov)
{int i,j,j1,j2;
string rezstr,b;
string a;
char[] cif = {'1','2','3','4','5','6','7','8','9','0'};
rezstr=new string(' ',0) ;
for (i = 0; i < n; i++)
{ b = string.Copy(mslov[i]);
int l = b.Length;
j1 = b.IndexOfAny(cif);
j2 = b.LastIndexOfAny(cif);
{if (j1 != 0 && j2 != 0)
{a = new string(' ', 0);
for (j = 0; j<l; j++)
a = b[j]+a;
rezstr = rezstr + a;
rezstr = rezstr + ",";
}
}
}
return rezstr;
}
static void Main(string[] args)
{string x=new string(' ',200) ;
char[] rsl = { ',' };
char[] kstr = { '.' };
string[]mslov=new string[20];
string rez=new string(' ',100);
int i,mm,n;
int[]mch=new int[20];
Console.Write("Input x\n");
x=Console.ReadLine();;
n=str_sl(x,rsl,kstr,out mslov);
for (i=0;i<n;i++)
Console.WriteLine("Word number {0} {1} length {2}",i+1,mslov[i],mslov[i].Length);
mm=chisl_cub(n,mslov,out mch);
if (mm==0) Console.WriteLine("Not number words");
else
for (i=0;i<mm;i++) Console.WriteLine("{0} ",mch[i]);
rez=obr_sl(n,mslov);
if (rez=="") Console.WriteLine("Not non-number words");
else Console.WriteLine("{0}",rez);
Console.ReadKey();
Лекция 6. Разработка Windows-приложения
До сих пор рассматривались консольные приложения, которые управляются данными. В
отличие от них Windows–приложение управляется событиями. Иначе говоря, приложение,
управляемое событиями, работает не последовательно, а как совокупность обработчиков
событий. Событием является, например, выбор пункта меню, нажатие кнопки,
перемещение мыши и т.д.
При создании проекта типа Windows Forms Application появляется форма, на которой
можно размещать элементы управления. Элементы управления выбираются в окне
Toolbox в левой части экрана.
У всех элементов управления есть свойства и события. Значения свойств можно менять
как при проектировании приложения, так и при выполнении событий. Изменение
свойства – это присвоение ему какого-то значения в виде оператора
Имя компонента.имя свойства=значение.
Надо помнить, что всем компонентам при размещении на форму присваивается имя по
умолчанию (имя компоненты с порядковым номером; это имя можно изменить при
проектировании приложения).
Если значение свойства компоненты меняется в коде события этой же компоненты, то
вместо имени компоненты пишется this.
Все визуальные компоненты имеют свойства Left,Top, Height,Width, определяющие
положение компоненты на форме, Text – текст, расположенный на компоненте.
Расположение компоненты в окне можно менять как визуально, так и изменением свойств
в окне Properties. В этом же окне можно менять и другие свойства: цвет, текст,
расположенный на кнопке и т.д.
Элемент управления Label предназначен для отображения информации.
Элемент управления Button (кнопка) имеет событие «Нажатие кнопки». При щелчке по
кнопке появится заготовка фрагмента кода для обработки этого события. Вставка
собственного кода (выделенного жирным шрифтом) приведет при исполнении
приложения и нажатии на кнопку к выводу окна сообщения:
private void buttonl_Click(object sender, EventArgs e)
{MessageBox. Show ("Первое Windows приложение!") ; }
Элемент управления Text Box позволяет вводить текст.
Элемент управления MaskedTextBox дополнительно к TextBox содержит свойство Mask,
которое позволяет контролировать допустимость ввода символов (числа, даты и т.д.) .
Элементы управления RadioButton и CheckButton позволяют информировать о текущем
состоянии приложения и изменять это состояние.
Традиционно элементы управления RadioButton (переключатели) следует применять,
когда нужно предоставить возможность выбора между взаимоисключающими опциями
— например, пола пользователя.
Чтобы сгруппировать переключатели для образования единого логического блока,
следует использовать элемент управления GroupBox.
При первоначальном помещении элемента GroupBox на форму и последующем
размещении необходимых элементов управления RadioButton внутри его границ,
состояние элементов RadioButton будет автоматически изменено для отражения того, что
только одна опция внутри групповой рамки может быть выбрана.
Элемент управления CheckBox (флажок) следует использовать, когда нужно предоставить
возможность выбора одного или более режимов — например, для заполнения вопросника
об использовавшихся ранее операционных системах (Windows ХР, Windows Vista, Linux
и т.п.).
У того и другого элемента есть булевское свойство Checked, которое равно true, если
переключатель или флажок включен, и false в противном случае.
Элемент управления ListBox позволяет отображать информацию в виде списков.
Списки используются для отображения списков строк, из которых одновременно можно
выбирать одну или более строк. Подобно флажкам и переключателям, списки
предоставляют способ затребовать от пользователя выбор одного или более элементов.
Список следует использовать в тех случаях, когда во время разработки неизвестно точное
количество значений, из которых может осуществляться выбор (например, в списке
сотрудников).
Элемент имеет свойства:
SelectedIndex - начинающийся с 0 номер выбранного элемента списка;
Sorted - возможность упорядочения элементов списка по алфавиту;
Items – перечень строк, включенных в список. Его можно создавать как в момент
проектирования, так и в процессе выполнения программы.
Для добавления в процессе выполнения нужно выполнить метод Add. Для удаления
элемента нужно выполнить метод RemoveAt с параметром номер элемента в списке.
SelectedItems – список выбранных строк;
SelectionMode – режим выбора. Его возможные значения:
One — только один элемент может быть выбран в каждый конкретный момент времени;
MultiSimple — возможен выбор нескольких элементов. При использовании
этого стиля при щелчке на элементе он становится выбранным и остается таким даже в
случае щелчка на другом элементе до повторного щелчка на нем.
ToStringO Метод возвращает элемент, выбранный в текущий момент времени.
Еще один вид доступного списка — CheckedListBox. Он предоставляет список, но кроме
текстовых строк имеется также флажок для каждого элемента в списке.
Свойство только этого вида списка – Checkedltems. Это свойство — перечень всех
элементов в CheckedListBox, которые находятся в состоянии Checked.
У этого списка есть метод GetItemChecked с параметром номер элемента в списке,
который возвращает true, если элемент выбран.
Элемент управления TabControl, как и GroupBox, позволяет
группировать другие
элементы управления. Этот элемент предоставляет простой способ организации
диалоговых окон в логические части, доступные посредством вкладок в верхней части
элемента управления.
TabControl содержит элементы TabPages, которые по существу работают подобно
элементу управления GroupBox, поскольку они группируют элементы управления.
Элемент управления dataGridView предназначен для работы с таблицами. При
копировании этого элемента на форму создается таблица без столбцов, к которой можно
добавлять столбцы как в режиме проектирования, так и в режиме выполнения. При
проектировании создается столбец с именем и заголовком. Для добавления столбца в
режиме выполнения нужно вызвать свойство Columns и выполнить его метод Add с
параметрами имя столбца и имя заголовка столбца.
Для добавления строки таблицы нужно вызвать свойство Rows и выполнить его метод
Add. Таким образом создается двумерный массив, первый индекс которого - номер
столбца, а второй – номер строки. Заполнение элемента таблицы происходит с помощью
оператора присваивания вида this.dataGridView1[0,nr].Value=…
Элемент управления для создания меню это MenuStrip. Пункты меню создаются
интерактивно; каждый пункт является элементом управления toolStripMenuItem, событие
Click которого выполняется при выборе этого пункта.
Для вызова из одной формы другой нужно создать экземпляр вызываемой формы с
помощью оператора вида Form2 fr2 = new Form2(); и выполнить его метод ShowDialog.
Закрытие формы промсходит с помощью ее метода Close.
Если необходимо передать из вызывающей формы в вызываемую некоторую величину, то
в вызываемой форме нужно создать свойство вида
public string TextForm
{
get { return поле для приема передаваемой величины; }
set { приема передаваемой величины = value; }
},
а перед вызовом формы нужно присвоить этому свойству передаваемое значение:
fr2.TextForm=передавемое поле
Второй способ описания глобальных данных – это описание статического класса со
статическими элементами, например,
public static class Global
{
public static string name;
public static int age;
public static bool sex;
}
В этом случае все переменные с именами вида Global.имя доступны в любой форме.
Лекция 7. Обработка файлов
Структуры
Структура – это совокупность данных, возможно, даже разного типа с единым именем.
Они позволяют определять свои собственные типы переменных на основании данной
структуры.
Структуры определяются с помощью ключевого слова struct следующим образом:
struct <имя_типа>
{
<объявления_ членов>
}
В разделе <объявления_членов> содержатся объявления переменных (называемых
членами структуры) в том же самом формате, что и обычно.
Объявление каждого члена имеет следующий вид:
<уровень_доступа> <тип> <имя>;
Для предоставления вызывающему структуру коду возможности получать доступ к ее
данным-членам на месте <уровень_доступа> помещается ключевое слово public.
Например, предположим, что требуется сохранить информацию о студенте – его имя, пол
и возраст. Для этого объяаляется структура
struct dt
{public string name;
public int age;


public bool sex;
};
После определения типа структуры исльзовать ее можно, определив переменные нового
типа:
dt dat;
Можно обращаться к данным-членам этой сложной переменной с помощью символа
точки:
dat.name=”aaa”; dat.age=20;
Можно использовать массив структур, который нужно объявить и выделить ему память, а
затем обращаться к элементу массива по индексу:
dt[] dats=new dt[20];
dats[2].sex=true;
Потоки
Весь ввод и вывод в C# подразумевает использование потоков. Поток (stream) — это
абстрактное представление последовательного устройства.
Последовательное устройство (serial device) — это нечто такое, что хранит данные
последовательно. Существуют два типа потоков.
Выходные. Выходные потоки используются, когда данные пишутся в некоторое внешнее
устройство, которым может быть дисковым файлом,
Входные. Входные потоки используются для чтения данных в переменные, к которым
может обращаться программа. Наиболее часто используемой формой входного потока
является дисковый файл.
Классы ввода и вывода
Пространство имен System.IO содержит классы для чтения данных из файлов и записи их
в файлы.
Объект FileStream
Этот объект представляет поток, указывающий на дисковый файл. В то время как класс
предоставляет методы для чтения и записи байт в файл, чаще всего для выполнения этих
функций используется StreamReader или StreamWriter. Это происходит потому, что
класс FileStream оперирует байтами и байтовыми массивами, а классы Stream—
символьными данными. Работать с символьными данными проще, но некоторые
операции, например, произвольный доступ к файлу (доступ к данным в некоторой точке
посреди файла), могут выполняться только посредством объекта FileStream.
Есть несколько способов создания объекта FileStream. Конструктор имеет множество
различных вариантов, но простейший из них принимает два аргумента: имя файла и
значение перечисления FileMode:
FileStream aFile = new FileStream(имя файла, способы открытия);
Другой часто используемый конструктор выглядит так:
FileStream aFile = new FileStream (имя файла, способы открытияr, способы доступа) ;
Возможные значения второго параметра:
FileAccess.Append Файл открыт, позиция потока установлена в конец файла. Может
использоваться только в сочетании с третьим параметром, равным Write
FileAccess.Create Файл уничтожается и на его месте создается новый
FileAccess.Open Файл открывается, поток позиционируется в начало файла
Возможные значения третьего параметра:
FileMode.Read Открывает файл только для чтения
FileMode.Write Открывает файл только для записи
FileMode.ReadWrite Открывает файл для чтения или записи
В версии конструктора FileStream, не использующего третий параметр, применяется
значение по умолчанию, ReadWrite.
Объект StreamWriter
После открытия или создания объекта FileStream он помещается в
оболочку
StreamWriter или StreamReader и с помощью методов этих объектов происходит
манипулирование файлом.
Класс StreamWriter позволяет записывать символы и строки в файл. Если объект
FileStream уже имеется, можно использовать его для создания StreamWriter:
FileStream aFile = new FileStream("Log.txt", FileMode.Create);
StreamWriter sw = new StreamWriter(aFile) ;
Запись данных в файл:
sw.WriteLine("Hello to you.");
sw.WriteLine ("It is now {0} and things are looking good.",
DateTime.Now.ToLongDateStringO);
sw.Write("More than that,");
sw.Write(" it's {0} that C# is fun.", truth);
sw.Close ();//Закрытие файла
Объект StreamReader
Класс StreamReader применяется для чтения данных из файлов.
Объекты StreamReader создаются почти так же, как объекты StreamWriter.
Наиболее распространенный способ его создания — применение ранее созданного
объекта FileStream:
FileStream aFile = new FileStream("Log.txt", FileMode.Open);
StreamReader sr = new StreamReader(aFile);
При записи в строку файла нескольких элементов, они разделяются некоторым
разделителем, например запятой:
sw.WriteLine(“{0},{1},{2}”,dat.name,dat.age,dat.sex)
Так можно записать в файл любое число записей. При чтении из файла организуется цикл
до исчерпания записей в файле. Для этого используется булевское свойство EndOfStream,
которое становится равным false, когда достигается конец файла.
while(!file_in.EndOfStream)
{ Чтение строки из файла
Преобразование строки в массив по разделителям с помощью функции Split
Преобразование каждого элемента массива в переменную своего типа
Обработка полей }
Для редактирования (удаления или изменения) записи проще всего переписать все записи
файла в массив структур, выполнить нужные преобразования и вновь переписать записи в
файл.
5.3 Краткое описание лабораторных работ
5.3.1 Перечень рекомендуемых лабораторных работ
1. Разветвляющийся вычислительный процесс
2. Циклический вычислительный процесс
3. Модульное программирование
4. Разработка Windows-приложения с обработкой строковых данных
5.3.2 Методические указания по выполнению лабораторных работ
Лабораторная работа № 1. Разветвляющийся вычислительный процесс
Цель
работы:
научиться
разрабатывать
алгоритм
разветвляющегося
вычислительного процесса, писать консольную программу на языке C#, проводить
отладку и тестирование.
Задание: Словесное описание трех задач
Требования к отчетным материалам: Таблица спецификаций, работоспособная
программа и текст отчета с описанием подробного алгоритма ее работы.
Последовательность выполнения работы: Изучение материалов лекции,
методических указаний к лабораторной работе и типового примера, составление таблицы
спецификаций, описание алгоритма, тестов и программы, отладка и тестирование,
написание отчета.
Лабораторная работа № 2. Циклический вычислительный процесс
Цель работы: научиться разрабатывать алгоритм циклического вычислительного
процесса, писать консольную программу на языке C#, проводить отладку и тестирование.
Задание: Словесное описание двух задач
Требования к отчетным материалам: Таблица спецификаций, работоспособная
программа и текст отчета с описанием подробного алгоритма ее работы.
Последовательность выполнения работы: Изучение материалов лекции,
методических указаний и типового примера, составление таблицы спецификаций,
описание алгоритма, тестов и программы, отладка и тестирование, написание отчета.
Лабораторная работа № 3 Модульное программирование
Цель работы: научиться разрабатывать схему иерархии, алгоритмы функций, писать
консольную программу на языке C#, проводить отладку и тестирование.
Задание: Словесное описание задачи
Требования к отчетным материалам: Схема иерархии, таблица спецификаций каждой
функции, работоспособная программа и текст отчета с описанием подробного алгоритма
ее работы.
Последовательность выполнения работы: Изучение материалов лекции, пособия и
типового примера в диалоговом режиме, составление схемы иерархии, таблицы
спецификаций функций, описание алгоритмов функций, тестов и программы, отладка и
тестирование, написание отчета. Интерактив (семинар в диалоговом режиме)
Лабораторная работа № 4 Разработка Windows-приложения с обработкой
строковых данных
Цель работы: научиться разрабатывать Windows-приложение с использованием
различных элементов управления и стандартных функций обработки строк, писать
оконное приложение, проводить отладку и тестирование.
Задание: Словесное описание задачи
Требования к отчетным материалам: Работоспособная программа и текст отчета с
описанием подробного алгоритма ее работы.
Последовательность выполнения работы: Изучение материалов лекции,
методических указаний и типового примера в диалоговом режиме, разработка программы,
отладка и тестирование, написание отчета. Интерактив (семинар в диалоговом режиме)
Все лабораторные работы выполняются в среде Visual Studio 2010
5.4 Краткое описание практических занятий
Планом не предусмотрены.
5.5 Краткое описание видов самостоятельной работы
5.5.1 Общий перечень видов самостоятельной работы
1. Подготовка к лабораторным работам
2. Подготовка к экзамену
3. Разработка курсового проекта
5.5.2 Методические рекомендации по выполнению каждого вида
самостоятельной работы
1. Подготовка к выполнению лабораторных работ и написание отчета. Необходимо
выполнять в соответствии с методическими указаниями к каждой лабораторной
работой.
2. Подготовка к экзамену. Необходимо прорабатывать конспекты лекций, решать
задачи из заданий по лабораторным работам
5.5.3 Описание курсового проекта (курсовой работы)
Цель курсового проекта – освоить технологию проектирования и разработки приложения
по обработке файлов. Индивидуальное задание содержит список полей записей файла.
Выполняются действия:
 Создание файла;
 Добавление записей;
 Удаление записей;
 Редактирование записей;
 Просмотр файла;
 Выполнение двух запросов
Удаление и изменение записи происходит по ее номеру. При ошибочных ситуациях
(отсутствие записи, отсутствие файла и т.д.) необходимо выдавать сообщения.
Оформление курсового проекта
Курсовой проект содержит:
Титульный лист
Задание на курсовой проект
Содержание
Введение
Индивидуальный вариант
Алгоритмы основных событий
Формы
Код основных событий
Таблица тестов
Результаты тестирования
Заключение
Список использованной литературы
Последовательность выполнения курсового проекта:
1. Создание главной формы приложения и размещение на ней меню, позволяющего
выполнять основные операции. В файле Form1.cs кроме класса Form1 создается
глобальный класс Global для хранения переменных, используемых во всех формах, и
структуры для хранения всех полей записи файла.
2. Создание форм для пунктов меню «Добавить», «Изменить», «Удалить», «Просмотр»,
«Запрос1», «Запрос2».
3. На форму добавления следует поместить элементы управления для ввода или выбора
полей, необходимых для добавления, и кнопку, по нажатию которой происходит
добавление сформированной записи в файл.
4. На форме просмотра размещается таблица, организуется цикл перебора всех записей
файла и считывания их содержимого в память. Записи заполняют строки таблицы.
На форме удаления размещается поле, в которое нужно вводить номер удаляемой
записи. Программный код удаления вначале проверяет, существует ли в файле запись
с указанным номером; при отсутствии записи выдается сообщение. Если нужная
запись есть, то в массив переписываются все записи файла, кроме удаляемой, затем
вновь создается файл, и в него переписываются все элементы массива.
6. Форма изменения аналогична форме добавления, но дополнительно имеется поле
ввода номера редактируемой записи и кнопки для поиска редактируемой записи и
изменения нужной записи. При поиске изменяемой записи вначале проверяется, есть
ли запись с нужным номером. Если такой записи нет, выдается сообщение. Если
искомая запись есть, то она делается текущей и значения ее полей выводятся в
элементы контроля на форму. Для изменения записи в файле все записи, кроме
корректируемой, считываются и запоминаются в массиве, а поля корректируемой
записи выводятся на экран и корректируются. Файл создается вновь, в него
переписываются все записи из массива, а скорректированная запись размещается на
своем месте.
7. Запросы имеют индивидуальное содержание, но все сводится к вводу на форме
некоторых значений, циклу перебора записей файла и формированию некоторых
результатов согласно определенному критерию.
График выполнения и критерии оценки: проект выполняется в течение 3 семестра по
графику: 7 неделя – проектирование структуры приложения, разработка тестов совместно
со вторым членом команды, 8-9 неделя – изучение теоретических материалов,
необходимых для выполнения проекта, 10-12 неделя – написание программы, 13-15
недели – отладка программы, 16 неделя – тестирование программы с привлечением
второго члена команды и написание отчета, 17 неделя – защита проекта. За курсовой
проект ставится оценка «отлично» при условии выполнения в срок всех этапов и
успешной защиты, оценка «хорошо» при нарушении сроков выполнения и недостаточно
успешной защите, оценка «удовлетворительно» при невыполнении некоторых этапов и
неуспешной защите.
5.
6 Применяемые образовательные технологии
При реализации данной программы применяются инновационные технологии
обучения, активные и интерактивные формы проведения занятий, указанные в таблице 2.
Таблица 2 - Применяемые образовательные технологии
Технологии
Семинар в диалоговом режиме
Разбор конкретных ситуаций
Работа в команде
Виды занятий
Лекции
Лаб.
раб.
4
2
Практ./
Сем.зан.
СРС
Курсовой
проект
2
Разбор конкретных ситуаций:
Пример задачи, использующей строковые данные
Задан текст, состоящий из слов, записанных через запятые. Длина текста не больше
200 символов. Необходимо выдать на экран слова и их длины. Если слово состоит только
из цифр, то возвести его в куб. Кроме того, составить выходную строку, содержащую
нецифровые слова, в которых порядок символов изменен на обратный.
Необходимо составить схему иерархии функций, таблицы спецификаций и
алгоритмы отдельных функций, запрограммировать их
Семинар в диалоговом режиме. При выполнении лабораторной работы 3 .Модульное
программирование совместно преподавателем и студентами выполняются все этапы
решения задачи (разбиение на подзадачи, составление спецификаций всех подзадач,
составление алгоритмов всех подзадач, написание и отладка программы, ее тестирование)
Пример задачи: Заданы две матрицы целых чисел A(m,m) и B(k,k) и два вектора из целых
чисел X(m) и Y(k), где 1<m10 1<k8. Вычисляются P – число нулевых элементов на
главной диагонали матрицы A и Q – число нулевых элементов на главной диагонали
матрицы B. Если P<Q, то необходимо получить вектор C(m), а в противном случае вектор D(k), где
k
m
Ci   Ai , j X j  max Ai , j
j 1
i=1..m
Di   Bi , jY j  max Bi , j
i=1..k
j 1
При выполнении лабораторной работы 4 . Разработка Windows-приложения с обработкой
строковых данных совместно преподавателем и студентами выполняются все этапы
решения задачи (создание приложения из нескольких форм, размещение на формах
нужных компонент, написание функций обработки событий, таких как нажатие кнопки,
выбор пунктов меню, выполнение функции таймера и т.д., тестирование задачи).
Работа в команде. При разработке курсового проекта студенты объединяются в команды,
программу пишет один студент, а другой готовит тесты для проверки работоспособности
программы. Затем они меняются ролями
7 Методы и технологии контроля уровня подготовки по дисциплине
7.1.Виды контрольных мероприятий, применяемых контрольноизмерительных технологий и средств.
В процессе изучения дисциплины проводятся контрольные работы по изучаемым темам, в
процессе выполнения лабораторных работ и курсового проекта реализуется работа в
команде, когда программа, написанная одним студентом, тестируется другим. В конце
семестра сдается экзамен по всему курсу
7.2.Критерии оценки уровня освоения учебной программы (рейтинг).
Выполнение всех лабораторных работ и курсового проекта является обязательным. При
условии их выполнения в указанные сроки, успешной защиты курсового проекта,
написании всех контрольных на положительную оценку и посещения не менее 90% от
числа лекций экзамен может быть выставлен автоматически. В остальных случаях экзамен
сдается по билетам.
7.3
Контрольно-измерительные материалы и другие оценочные средства для
итоговой аттестации по дисциплине.
Список вопросов к экзамену:
1. Виды вычислительных процессов
2. Характеристика разветвляющегося процесса и его алгоритм
3.Характерика циклического процесса и его алгоритм
4. Назначение таблицы спецификаций
5. Назначение тестирования
6. Назначение отладки программы
7. Описание переменных в программе
8. Виды констант программы
9. Арифметические операции
10. Операции ввода-вывода и преобразования данных
11. Тернарная операция
12.Условный оператор
13.Оператор разветвления в нескольких направлениях
14. Операторы цикла, их особенности и различия
15. Описание массивов и их использование
16. Схема иерархии функций программы
17.Заголовок функции и ее тело
18.Способы вызова функции на выполнение
19. Параметр типа out, его использование
20. Операции сравнения строк
21. Операции выделения части строки
22. Операции разбиения строк на части
23. Операции поиска в строке
24. Отличие приложения, управляемое данными, от приложения, управляемого
событиями
25. Отличие элемента управления CheckBox от элемента управления RadioButton
26. Отличия элемента управления TextBox и MaskedTextBox
27.Функции рисования основных фигур
28. Анимация рисунка
29.Рисование в окне
30. Создание меню окна
31.Создание файла
32. Добавление записи к файлу
33. Структура как развитие понятия типа
34. Удаление записи файла
35. Корректировка записи файла
36. Просмотр записей файла
37. Таблица как элемент управления
38. Список как элемент управления
Билет содержит теоретический вопрос и условие задачи.
Пример билета:
1 Виды циклических процессов
2 Задача. Составить функцию нахождения максимального значения из трех чисел. С ее
помощью найти максимумы 5 групп из трех чисел.
8
Рекомендуемое информационное обеспечение дисциплины
8.1.Основная учебная литература
1. Сосинская С.С. Использование языка C# в различных информационных
технологиях. Старый Оскол. Издательство ТНТ. 2013. – 278 с.
8.2.Дополнительная учебная и справочная литература.
1. Трей Нэш C# 2010. Ускоренный курс для профессионалов - руководство по
созданию эффективного кода на C# 4.0. [Текст] Трей Нэш. — М.: Вильямс, 2010. —
592 с.
2. Уотсон, Карл и, Нейгел, Кристиан, Педерсен, Якоб Хаммер, Рид, Джон Д.,
Скиннер, Морган, Уайт, Эрик. Visual С# 2008: базовый курс. [Текст] - М.: ООО
"И.Д. Вильяме", 2009. -1216 с.
3. Нейгел, Кристиан, Ивьен, Билл, Глинн, Джей, Уотсон, Карл и, Скиннер, Морган.
С# 2008 и платформа .NET 3.5 для профессионалов. [Текст]/ — М. : ООО "И.Д.
Вильяме", 2009. - 1392 с.
4. Н.Б.Культин. Microsoft Visual C# в задачах и примерах [Текст]/ Н.Б.Культин/ Спб.:БХВ –Петербург.2009. - 320с.
8.3
Электронные образовательные ресурсы:
8.3.1 Ресурсы ИрГТУ, доступные в библиотеке университета или в локальной
сети университета.
1. Методические указания по лабораторным работам и по курсовому проекту в
локальной сети кафедры Технология машиностроения Д-105.
8.3.2 Ресурсы сети Интернет
1. В.М. Снетков Практикум прикладного программирования на C# в среде
VS.NET 2005. [Электронный ресурс] http://www.intuit.ru/department/se/prcsharp/
2. Библиотека MSDN Microsoft [Электронный ресурс]
http://msdn.microsoft.com/ru-ru/library/w0x726c2%28v=vs.90%29
9 Рекомендуемые специализированные программные средства
Visual Studio 2010
10 Материально-техническое обеспечение дисциплины
Лаборатория, оснащенная 12-15 современными компьютерами. Проектор для
презентаций
РАСПРЕДЕЛЕНИЕ СОДЕРЖАНИЯ ДИСЦИПЛИНЫ ПО ВИДАМ
ЗАНЯТИЙ
1. ЛЕКЦИИ
№
пп
Разделы и темы дисциплины по учебной программе
Кол-во
часов
Семестр ___3__
Введение
Технология разработки программ на языке высокого уровня
1
1
1.2
Этапы разработки программ на языке высокого уровня (таблица
спецификаций, алгоритм, таблица тестов, написание программы,
отладка, тестирование)
Виды вычислительных процессов
2.
Разветвляющийся вычислительный процесс
2.1
2.2.
Алгоритмы разветвляющихся процессов
Программа на языке C# (операторы, комментарии). Элементы языка
(константы, идентификаторы, типы данных, операции, оператор
присваивания, операторы разветвления if и switch)
3.
3.1.
3.2.
Циклический вычислительный процесс
3.3
Работа с векторами и матрицами
4.
Модульное программирование
4.1.
Функция. Схема иерархии функций задачи. Входные параметры и
результат выполнения функции
Проектирование функций (таблицы спецификаций, алгоритмы).
Тестирование задачи
Функции в языке C# (заголовок и тело функции, параметры функции и
возвращаемое значение, способы вызова функций)
1.
1.1
4.2.
4.3.
Алгоритмы циклических процессов
Виды циклов в языке C# (for, while, do while), их особенности
5.
Обработка строковых данных
5.1.
Описание строк в С#
5.2.
Функции для копирования и объединения строк
5.3.
Функции для сравнения строк
5.4.
Функции поиска в строке
5.5.
Корректировка строк
6.
Разработка Windows – приложения в C#
6.1.
Отличия
программирования,
управляемого
данными,
от
программирования, управляемого событиями
Формы и программные модули C#. Элементы управления в C#, их
свойства и события
6.2.
7.
Обработка файлов
7.1.
Структура как развитие понятия типа
1
1
1
0.5
1
1
1
1.5
1
0.5
0.5
0.5
0.5
0.5
0.5
1.5
0.5
7.2.
Файлы - последовательный и прямой доступ
7.3.
Функции языка C# для обработки файлов (открытие и закрытие, чтение и
запись, удаление и переименование)
Итого
2. ЛАБОРАТОРНЫЕ РАБОТЫ
Название работы
№
пп
1
0.5
1
17
Кол-во
часов
Семестр __3__
Лабораторная работа № 1 Разветвляющийся вычислительный
6
процесс
2
3
4
Лабораторная работа № 2 Циклический вычислительный процесс
Лабораторная работа № 3 Модульное программирование
Лабораторная работа № 4 Разработка Windows-приложения с
6
8
10
обработкой строковых данных
Итого
34
3. ПРАКТИЧЕСКИЕ ЗАНЯТИЯ
Не предусмотрены
№
пп
1
2
4. САМОСТОЯТЕЛЬНАЯ РАБОТА
Вид работ
Кол-во
часов
Семестр __3___
Подготовка к лабораторным работам
Выполнение курсового проекта
27
30
Всего
Подготовка к экзамену
Итого с экзаменом
57
36
93
1/--страниц
Пожаловаться на содержимое документа