ОСНОВЫ АЛГОРИТМИЗАЦИИ И ПРОГРАММИРОВАНИЯ
КОНСПЕКТ ЛЕКЦИЙ
ББК
УДК
Х
Утверждена на заседании кафедры прикладной информатики Тамбовского филиала ФГОУ ВПО МГУКИ «__» августа 2009 г., протокол № __
Составители: канд. техн. наук, доцент В.Н. Точка,
Основы алгоритмизации и программирования:конспект лекций для студентов, обучающихся по специальности 080801 «Прикладная информатика (в менеджменте) (дневной формы обучения)»:/ сост. В.Н. Точка. - Тамбов, 2009.- 100 с.
© Тамбовский филиал ФГОУ ВПО МГУКИ, 2009
СОДЕРЖАНИЕ
1.1. Базовый синтаксис С# .....................................................................................8
1.2. Переменные ...................................................................................................9
1.2.1. Простые типы переменных ......................................................................10
1.2.2. Именование переменных .........................................................................11
1.2.3. Соглашения, используемые при именовании .............................................11
1.2.4. Литеральные значения ............................................................................11
1.2.5. Литеральные строки................................................................................12
1.2.6. Объявление переменных и присваивание им значений ...............................12
1.3. Выражения ....................................................................................................12
1.3.1. Математические операторы .....................................................................13
1.3.2. Операторы присваивания ........................................................................14
1.3.3. Старшинство операторов .........................................................................14
1.4. Пространства имен .........................................................................................14
1.5. Вопросы для повторения ............................................................................16
2.1. Булева логика .................................................................................................17
2.2. Операторы работы с битами ............................................................................18
2.2.1. Логические операторы присваивания .......................................................19
2.2.2. Старшинство операторов с дополнениями ................................................20
2.2.3. Оператор goto. ........................................................................................20
2.3. Ветвление ......................................................................................................21
2.3.1. Тринарный оператор ...............................................................................21
2.3.2. Оператор if. ............................................................................................21
2.3.3. Проверка большего количества условий с помощью оператора if ................22
2.3.4. Оператор switch ......................................................................................23
2.4. Организация циклов .......................................................................................23
2.4.1. Цикл do. .................................................................................................24
2.4.2. Цикл while..............................................................................................24
2.4.3. Цикл for .................................................................................................24
2.4.4. Прекращение выполнения цикла ..............................................................25
2.4.5. Бесконечные циклы ................................................................................25
2.5. Вопросы для повторения ............................................................................25
3.1. Преобразованиепеременных из одного типа в другой ........................................26
3.1.1. Неявные преобразования .........................................................................26
3.1.2. Явные преобразования ............................................................................27
3.1.3. Выполнение явных преобразований с помощью команд преобразования .....28
3.2. Сложные типы переменных ............................................................................28
3.2.1. Перечислимый тип .................................................................................28 3.2.2. Определение перечислимых типов ...........................................................28
3.2.3. Структуры .............................................................................................29
3.2.4. Массивы ................................................................................................29 3.2.5. Циклы foreach. ........................................................................................31
3.2.6. Многомерные массивы ...........................................................................31 3.2.7. Массивы массивов ..................................................................................31
3.2.8. Действия над строками ............................................................................32
3.3. Вопросы для повторения ............................................................................33
4.1. Описание и использование функций ................................................................34
4.2. Возвращаемые значения..................................................................................35
4.3. Параметры .....................................................................................................35
4.3.1. Соответствие параметров ........................................................................36
4.3.2. Массивы параметров ...............................................................................36 4.3.3. Передача параметров по ссылке и по значению .........................................36
4.3.4. Выходные параметры .............................................................................37
4.4. Область действия переменных .........................................................................38 4.5. Функция Main() ..............................................................................................39
4.6. Функции структур ..........................................................................................40 4.7. Перегрузка функций .......................................................................................40
4.8. Вопросы для повторения ............................................................................41
5.1. Объектно-ориентированное программирование ................................................42
5.2. Объект ...........................................................................................................42
5.2.1. Свойства и поля ......................................................................................43
5.2.2. Методы..................................................................................................43
5.2.3. Конструкторы ........................................................................................44
5.2.4. Деструкторы ..........................................................................................44
5.2.5. Статические члены класса и члены класса экземпляра ................................44
5.3. Ссылочные и значимые типы данных ...............................................................45
5.3.1. Структуры .............................................................................................45
5.3.2. ООП в приложениях Windows .................................................................45
5.4. Вопросы для повторения ............................................................................46
6.1. Определение классов в С# ...............................................................................47
6.2. Конструкторы и деструкторы ..........................................................................49
6.3. Типы структур................................................................................................50
6.4. Неглубокое и глубокое копирование ................................................................51
6.5. Вопросы для повторения ............................................................................52
7.1. Члены классов ................................................................................................52
7.1.1. Определение членов................................................................................52
7.1.2. Определение полей .................................................................................52
7.1.3. Определение методов ..............................................................................52
7.1.4. Определение свойств ..............................................................................53
7.2. Свойства членов .............................................................................................55
7.2.1. Дополнительные действия с членами класса .............................................55
7.3. Вопросы для повторения ............................................................................56
8.1. Потоки ..........................................................................................................57
8.1.1. Классы для ввода и вывода ......................................................................57
8.1.2. Классы File и Directory.............................................................................57
8.1.3. Класс FileInfo..........................................................................................58
8.1.4. Класс DirectoryInfo ..................................................................................58
8.1.5. Имена пути и относительные пути ...........................................................58
8.1.6. Объект FileStream ...................................................................................58
8.1.7. Позиция внутри файла ............................................................................59
8.1.8. Чтение данных .......................................................................................59
8.1.9. Запись данных ........................................................................................60
8.2. Объект StreamWriter........................................................................................61 8.3. Форматирование данных .................................................................................62
8.4. Объект StreamReader. ......................................................................................62
8.4.1. Чтение данных .......................................................................................63
8.4.2. Файлы с ограничителем ..........................................................................63
8.5. Вопросы для повторения ............................................................................64
ЗАДАНИЯ ДЛЯ САМОСТОЯТЕЛЬНОЙ РАБОТЫ ........................................65 СПИСОК ЛИТЕРАТУРЫ ...................................................................................66
Компьютерная программа это последовательность операций над данными. Это утверждение оказывается справедливым даже для наиболее сложных случаев, таких, например, как развернутые, многофункциональные Windowsприложения типа Microsoft Office Suite. И хотя пользователи зачастую не задумываются над структурой приложений, внутренняя сущность последних заключается именно в этом.
Когда используется приложение, например, калькулятор, вводятся данные, представленные в форме чисел, и выполняются над этими числами различные операции почти так же, как с помощью карандаша и бумаги.
Если фундаментальное свойство компьютерных программ заключается в выполнении операций над данными, то это предполагает наличие, во-первых, некоторого способа хранения данных и, во-вторых, определенных методов для выполнения манипуляций над ними. Для обеспечения этих двух функций используются соответственно переменные и выражения.
Рассмотрим базовый синтаксис, используемый при программировании на С#.
1.1.Базовый синтаксис С#
Внешне код на С# очень напоминает код на C++ или на Java. Компиляторы С# не обращает внимание на лишнее пустое пространство, которое может состоять из пробелов, возвратов каретки или символов табуляции (эти символы известны под общим названием символов пустого пространства). Отсюда можно сделать вывод, что мы обладаем большой свободой в выборе способа форматирования нашей программы, хотя следование определенным правилам помогает создавать более удобные для чтения программы.