Основы программирования (ОП) презентация

Введение в программирование
Задачи дисциплины (СМ)
Состав дисциплины (СМ)
Основные понятия (СМ)
Модели для программиста (СМ)
Программа основное (СМ)
Пример простой программы на СИ/СИ++ (СМ)
Почему С/С++ (СМ)
Языки программирования (СМ) и системы программирования (СМ)
Программы нужны для преобразования информации в самом общем виде (текст, графика, звук, изображение и др.).
Программы создаются специалистами на основе заданий (ТЗ) и требуют тщательного проектирования, разработки и проверки (отладки).
Значение программ в современном мире трудно переоценить. Они везде используются. Самый общий взгляд на работу программы:

Текущие Актуальные темы (1)
Задачи дисциплины (СМ)
Введение в программирование (СМ).
Основные общие понятия программирования (СМ)
Основные понятия (СМ)
Модели для программиста (СМ)
Пример простой программы (СМ)
Проекты (СМ). Первый проект в VS (СМ)
ЛР ОП (СМ)
ЛК ОП (СМ)
УПР ОП (СМ)
ДЗ ОП (СМ)
Рубежный контроль по ОП (РК1) и (РК2)

Текущие Актуальные темы (2)
Главная (СМ)
Основы программирования (СМ) Программа (СМ)
Общий вид (СМ). Операторы (СМ)
Проекты (СМ)
Операторы (СМ) и данные (СМ)
ЛР ОП(СМ)
ДЗ ОП (СМ) – 10 ЛР
Почему С++ (СМ)
Обзор тем по дисциплине (СМ)
Блок-схемы их необходимость и построение (СМ)
Модели программиста (СМ)
Программа (СМ)

Почасовой состав дисциплины (ОП)
Лабораторные работы OП – 8ЛР – 34 час (СМ)
Лекции по курсу OП – 1.5 раза в неделю - 51 час (СМ)
Упражнения по ОП - 34 час (СМ)
Практикум по ОП/ДЗ – 17 час (СМ) – только УЦ5Ц-31Б
Экзамен по курсу: 2 вопроса (билеты) и задача на программирование.
АВТОМАТЫ Требования: Все ЛР в срок и ДЗ (ЛР № 10)
Домашнее задание в рамках лабораторно - вычислительного практикума по индивидуальной теме для каждого студента СРС в рамках практикума по ОП.
Рубежный контроль – 2 раза в семестр на ЛК (8н и 15 недели): “Программа для работы с файлом БД для своей структуры записи”. (СМ)
Сайт по дисциплине 0П (: www.sergebolshakov.ru
ВХОД НА САЙТ: Главная -> меню слева -> 2-й к (СУЦ-ОП)-> Пароль:
Пользователь/Пароль: УЦ5-31 / 13-5ЦУ
Пособия и литература по ОП (уже есть на сайте)
Самостоятельная работа (Это - Отчеты ЛР по ОП, Выполнение ДЗ по ОП, Подготовка к РК, сдача зачета и экзамена, самостоятельное изучение литературы), ДЗ выполняется в рамках практикума по ОП.

ЛР по дисциплине (ОП)
Лабораторные работы OП – 8ЛР – 34 час
-------------------------------------------------------------------------------
ЛР №1 ВЫЧИСЛЕНИЯ( Теория, Задание, Контроль, МУ, DOC)
ЛР №2 ЦИКЛЫ (Теория, Задание, Примеры, Контр. МУ, DOC)
ЛР № 3 МАССИВЫ(Теория, Примеры, Задание,Конт.МУ, DOC)
ЛР № 4 СТРОКИ(Теория , Примеры, Задание, Конт. (МУ)(DOC)
ЛР №5 ФУНКЦИИ(Теория , Примеры, Задание, (МУ, DOC)
ЛР №6 СТРУКТУРЫ(Теория, Примеры, Задания, МУ, DOC)
ЛР №7 ФАЙЛЫ(Теория, Примеры, Задания, МУ, DOC)
ЛР № 8 СПИСКИ(Теория , Примеры, Задания, МУ, DOC)
---------------------------------------------------------------------------------
ЛР № 10 ДЗ (комплексная ЛР) (см. Теория, МУ, DOC)

Темы по дисциплине (ОП)
Вводная (СМ)
ЛР по ОП (СМ)
Проекты и отладка (СМ)
Основные понятия (СМ)
Выражения и операторы языка (СМ)
Модели программиста (СМ)
Вычисления (СМ)
Циклы (СМ)
Массивы (СМ) (СМ2)
Указатели и ссылки (СМ)
Строки (СМ)
Функции (СМ)
Структуры (СМ)
Файлы (СМ)
Списки (СМ)
Библиотеки работы с файлами и их использование(СМ) (СМ2)
Работа со структурами (СМ)
ДЗ по ОП и документация. Разработки ТЗ на ДЗ (СМ).

Задачи дисциплины ОП
Состав дисциплины (СМ). Сайт дисциплины (СМ)
Задача дисциплины ОП:
Формирование базовых знаний и понятий в области программирования (СМ),
Изучение универсального языка (СМ) программирования и современной системы программирования (С и С++ - СМ) Пример
Освоение технологии создания (СМ), разработки (СМ), программирования и отладки (СМ) программ на универсальных языках программирования (СМ)
Получение первоначальных навыков оформления документации на ПО и отчетов по работе (ТЗ,ДЗ по ОП).
Получение навыков освоения и изучения современных языков программирования(СМ) и систем программирования (СМ).
Изучение моделей, связанных с программированием
Литература по дисциплине ОП(СМ)

Почему С/С++?
Доводы за СИ/СИ++:
Базовый язык для многих других языков (С#, JAVA, PHP, специализированных языков для БД)
Объектно-ориентированный язык и структурный язык программирования.
Прост в понимании, лаконичен и логичен
Необходим для изучения других предметов специальности.
Знания его Часто требуется для устройства на работу программистом
Большинство проектов сделано на С/С++ - > 40%
Доступны Системы программирования для С/С++.

Основы программирования (Понятия)
Программирование – это деятельность направленная на создание программ для компьютеров (СМ).
Программа (СМ) – это упорядоченная совокупность предписаний (указаний, инструкций, команд, операторов) на Языке программирования (СМ) для компьютера для выполнения поставленной задачи. Программа оформляется в виде текста набранного символами (в электронном или бумажном виде).
Язык программирования ЯП (СМ) - это система взаимосвязанных формализованных правил для написания и оформления программ (Пример СМ.).
Программирование выполняется в среде системы программирования(СМ), состоящей из множества взаимосвязанных программ (компилятор, отладчик, редактор, IDE ). Например VISUAL STUDIO VS 2005/2010/2012 – (СМ). IDE – Integrated Developer Environment –Интегрированная среда разработки программ на ЯП

Пример простейшей программы на СИ
#include
void main(void)
{ // Вывод текста
printf( "HELLO!, Привет!!!\n" ); getchar();
}
Библиотека Ввода/вывода
Главная программа (main)
Вывод текста в окно (функция printf)
Запрос нажатия клавиши (функция getchar)
Операторные скобки СИ
Комментарий в строке СИ
Получим в окне консоли (нет русификации слова - ПРИВЕТ)
Для русификации вывода в КС нужно переключить кодовую страницу!

Пример программы СИ с русификацией
Библиотеки в/в и системы
Главная программа
Русская Кодовая страница 1251
Вывод текста для Запроса ввода числа
Комментарий в строке СИ
#include
#include
void main(void)
{ system(" chcp 1251 > nul");
// Ввод и вывод целого числа
printf("Привет!\n");
printf("Введите целое число:");
int i;
scanf ("%d",&i);
printf("Вы ввели i= %d\n", i);
system(" PAUSE"); }
Описание целой переменной i
Ввод целой переменной i (функция scanf)
Запрос паузы
Получим при вводе 55

Модели программиста
Машина Тьюринга (СМ)
Модель фон Неймана (СМ)
Оперативная память (СМ)
Модель программы (СМ)
Модель Блок-схем (СМ)
Разработка программ (СМ)
Модель работы СП (СМ)
Общие понятия ЯП (СМ)
Проекты СП (СМ)
Отладка программ (СМ)

Модель ЭВМ (Структура)
Составляющие ЭВМ Фон Неймана:
Память – Оперативная память (ОП): используется для хранения команд и данных.
Устройство управления (УУ) выполняет команды, поступающие из ОП.
Арифметико-Логическое устройство(АЛУ): выполняет вычисления и действия необходимые для команд.
Устройства ввода и вывода данных: Выполняют ввод и вывод данных извне необходимых для работы программы.
Современный МП (Микропроцессор), МП= УУ+АЛУ

Машина Тьюринга
Принципы построения Машины Тьюринга (МТ):
МТ - Это математическое построение предназначенное для уточнения понятия АЛГОРИТМА (конечный автомат)
Это Машина так как используются понятия: память, команда, Устройство управления (УУ) и т.д.

Язык и языки программирования
Язык программирования (ЯП) это взаимосвязанная система правил, на основе которых составляются программы. В ней есть:
Правила написания текста программы на ЯП (синтаксис ЯП),
Правила разработки содержания программ и (семантика ЯП)
Правила создания и отладки (СМ) исполняемой программы и проектов (СМ) в оболочке системы программирования (СМ)
Правила объединения программ в проекты (СМ) и использования стандартных и пользовательских библиотек готовых программ (СМ).
Языки бывают универсальные (для всех задач) и специализированные (для специального назначения).
Мы будем использовать универсальный язык С/С++ для СП Microsoft VS (СМ)
Все ЯП имеют много общего (СМ), включая общие понятия(СМ).

Общие понятия ЯП и ИТ
Общие понятия ЯП:
Программа (СМ)
Переменная (СМ), Переменные этапа компиляции (СМ)
Константы (СМ)
Выражение (СМ)
Операции (СМ)
Комментарии (СМ)
Функции (процедура подпрограмма) (СМ)
Оператор (команда, инструкция) (СМ)
Указатель (ссылка) (СМ)
Составной оператор и операторные скобки (СМ)
Файл (СМ)
Структура (запись, класс) (СМ)
Проект и модули (СМ)
Массив (СМ), Строка (СМ)
Список (СМ)

Программа
Программа (СМ): Это совокупность команд и данных размещаемых в Оперативной памяти ОП компьютера (СМ).
Данные программы - СМ и действия над данными/команды - СМ. в памяти не различаются! Обобщенная Модель программы.
Программа после обработки компилятором (СМ) загружается операционной системой (ОС) и запускается на выполнение.
Результаты работы программы: сохраняются в памяти, выводятся на экран компьютера, записываются в файлы или распечатываются на принтере в виде бумажной копии или запоминаются в файлах (СМ).
Программу можно представить как упорядоченную совокупность строк {Si } или даже символов {Ci }:
S1 S2 S3 Sk Sk+1… или даже C1 C2 C3 Ck Ck+1 … В качестве строк на языке СИ/СИ++ могут быть записаны:
Описатели данных (СМ)
Операторы языка (СМ)
Комментарии (СМ)
Программа вводиться в простом текстовом редакторе без форматирования.

Данные в программе
Данные в программе могут быть представлены:
Переменными(СМ) программы (изменяемые значения)
Константами программы (СМ) ( неизменяемые значения)
Значениями из динамической области памяти (ДП -СМ),
Вводятся с клавиатуры функциями (scanf - СМ)
Результаты полученные при вызове стандартных и пользовательских функций и подпрограмм. (СМ)
Считываться из файлов, доступных программе (СМ)

Действия над данными в программе
Действия над данными могут выполняться:
Операторами программы, главный оператор для вычисления Оператор Присваивания (СМ).
Функциями и процедурами программы, в этом случае данные передаются в процедуру в качестве указателя (СМ).

Переменная (имя и тип)
Переменная программы – Это основной элемент для хранения данных программы и она располагается в оперативной - ОП памяти(СМ). Значения переменной доступны во время выполнения программы Каждая Переменная имеет уникальное имя (СМ) (в данной программе) и заданный при ее описании тип (СМ).
Аналогом переменной является вычислительная строка обычного калькулятора (Запустить).
Значения переменных используются в операторах и могут быть изменены. Их значения используются во все время работы программы.
Все переменные перед первым использованием должны быть объявлены (СМ).
Имя переменной (Например - Var)
Тип переменной (Например int )
Описание переменной на СИ:
Int Var;
ОП
Значение переменной используется в программе
Var
Новое <Значение> переменной заносится программе! ПРИСВАИВАЕТСЯ
Var = sin(100);
Summ = Var;
Summ
<Значение>

Имена переменных в СИ/СИ++
Имена переменных в СИ/СИ++ задаются так:
Из латинских букв и цифр (“_” – подчеркивание тоже считается буквой),
Имена начинаются только буквой (однако, лучше “_” не использовать в начале - библиотеки)
Должны быть понятны (не надо таких А1, N3!)
Строчные и прописные различаются (var и VAR - разные)
Не должны превышать 31 символ (стандарт СИ).
Должны быть понятны и легко запоминаться(NB: венгерская нотация - CountAndPrintFlag).
Имена должны быть уникальными в программе и не пересекаться со стандартными именами.
Не желательно делать их длинными, так как они используются в выражениях и операторах (Например : SumNegArray).
Иногда для имен используется термин Идентификатор
ПРИМЕРЫ имен : Counter, Array, List, i, j, Summa.

Типы переменных в СИ/СИ++ (1)
В СИ/СИ++ предусмотрено ограниченное число типов переменных. В у стандартных типов различны: размер переменной в ОП, диапазон возможных значений и битовый формат представления данных.
Возможны следующие основные типы переменных:
short st = 1; // Короткий целый
int it = 0; // Целый
long lt = 0; // Длинный целый
char ct= 0; // Целый символьный
float ft = 0; // Короткий вещественный
double dt= 0; // Длинный вещественный
Кроме этого предусмотрены модификаторы описаний:
long int lit= 0; // длинный
unsigned char ust= 0; // без знака
signed char ust= 0; // Со знаком

Диапазоны значений переменных в СИ
Диапазоны значений переменных можно уточнить в заголовочных файлах (показать!):
#include // Для целых
#include
// Для вещественных
Для основных типов приведем, для примера, значения в таблице:
Вопрос задача: Как вычислить диапазон значений в программе?

Стандартные библиотеки Математики
acos(X) - возвращает значение арккосинуса аргумента
asin(X) - возвращает значение арксинуса аргумента
atan(X) - возвращает значение арктангенса аргумента
cos(X) - возвращает значение косинуса аргумента
exp(X) - возвращает значение экспоненты
abs(X) - возвращает абсолютное значение аргумента
log(X) - возвращает значение натурального логарифма аргумента
log10(X) - возвращает значение логарифма аргумента по основанию 10
pow(X,Y) - возвращает значение Х, возведенное в степень Y
sin(X) - возвращает значение синуса аргумента

Константы СИ/СИ++ (1)
Константы это данные программы, которым не присваивается отдельного имени, они используются в выражениях языка.
Константы записываются в операторах языка (в выражениях) и в вызовах функций.
Они принадлежат программе и располагаются в ОП (СМ).
Константы могут быть разных типов (как и переменные):
Числовые константы (целые и вещественные)
Строковые константы (нет отдельного типа переменных).
Символьные константы.
Для уточнения типов числовых констант записываются спецификаторы: U, u (unsigned), L, l(long), F, f (float) , D , d (double).
Целые числовые константы: 1234(тип int), 12345L (тип Long), 567UL (тип unsigned long),

Константы (2)
Символьные представляют один символ заключенный в одиночных кавычках (')Например: 'а' , ' Ж' , либо числовые символьные константы - '\х0А' - шестнадцатеричная, '\0700' – восьмеричное, Специальные символы , например (см. документацию):
\n новая-строка
\r возврат-каретки
\а сигнал-звонок
\t горизонтальная-табуляция
'\0' нулевой символ
Вещественные константы (с плавающей точкой) могут иметь две части: дробную (мантисса) и экспоненциальную:
[<знак>DDD].[DDD] [<знак>DD] , Пример 123.5 , 10.5 Е+10 и т.д.
Строковые константы - это любые символы заключенные в кавычках:
"Большаков " , для кавычки в тексте слэш "Большаков \"Сергей\ " " А "

Комментарии СИ/СИ++
Комментарии в программе служат для пояснения ее текста и содержания задачи и алгоритма и обычно, выполняется на естественном языке программиста (у нас русский)
В СИ/СИ++ допустимы следующие виды комментариев:
Строчные и многострочные комментарии.
В строчных комментариях используется двойной прямой слеш (//)и комментируется только одна строка или ее продолжение:
// Увеличение переменной i на единицу
i++; // (инкремент)
В многострочных комментариях комментируется несколько строк
(/* <любой текст> */):
/* Начало комментария
for ( int i = 0 ; ct !=0 ; i++ , ct++ )
{ // i++ ;
it = i+1; // Для печати
*/ //конец комментария

Выражения (1)
Выражения – это запись на ЯП позволяющая вычислить значение заданного типа (числовые и логические ). В выражениях используются данные:
Переменные программы (СМ)
Переменные этапа компиляции ((СМ))
Константы программы (СМ)
Знаки операций (СМ). Важно - Старшинство операций.
Элементы массивов (СМ) и поля структур (СМ)
Скобки для изменения порядка вычислений «(« и «)»
Вызовы функций с возвратом данных (СМ)
Переменные этапа компиляции (СМ)
Операции в выражении выполняются слева направо с учетом их приоритета (см. документацию).
Скобки ("(",") " ) изменяют порядок выполнения – то что в скобках выполняется ранее
Тип выражения определяется типом первой переменной в выражении.
При необходимости ы выражении используются библиотечные функции преобразования типа (СМ).

Выражения (2)
Выражения, также как и типы данных, бывают:
Числовые (целые и вещественные);
Логические, имеющие значения истина(true - 0) или ложь(false -1)
Выражения отношения ( часть логических выражений)
Если в выражении встречаются данные разных типов, то:
Производится автоматическое преобразование данных, если это возможно, либо используются cast – преобразования (СМ)
Либо необходимо использовать специальные функции библиотеки преобразования типов
(СМ)
Либо фиксируется синтаксическая ошибка компиляции ("несовместимость типов данных в выражении").

Преобразование типов
Для преобразования типов используется библиотека
,
Содержащая следующие функции:
Преобразование типов выполняется также cast операциями СМ

Cast преобразования типов данных
Для числовых данных СИ++ допустима упрощенная форма преобразований для числовых переменных и констант: Форма записи такова:
<Переменная числового типа> = (<Новый тип>)<Числовое выражение>
или:
<Переменная числового типа> = <Новый тип>(Числовое выражение>)
Например:
float f = 10.5f;
it =(int)(f + 2.5f); // it = 13
it =int(f); // it = 10

Операции в выражении
Переменные и константы в выражении разделяются знаками операций, которые делятся на следующие группы:
Арифметические (+ , -, *, /, ++, --, %)
Сдвига (<< , >>)
Унарные операции (+ , - )
Отношения ( >, <, ==, !=, >=,<=)
Логические побитовые (& , | , ^, ~)
Логические операции(&&, ||, !,)
Условная операция (?:)
Операция запятая (,)
Операции для присваивания (+=, -=, *=, /=)
Операции адресации (& и *)
Конструкции вида <Выражение 1> <Опер.> =< Выражение 2 > Значит: <Выражение 1> = <Выражение 1> <Опер.> <Выражение 2>

Переменные/Константы этапа компиляции
В СИ/СИ++ предусмотрена специальная фаза трансляции, которая называется фазой препроцессора(СМ). В это время, константы/переменные этапа компиляции (#define) заменяются в тексте исходного модуля.
Общее правило:
#define имя константы ˽ подставляемый-текст
Описание констант директивой препроцессора:
#define NMAX ˽ 20
Использование констант в программе :
int Mas[NMAX ]; // Описание массива
Замена констант на фазе препроцессора:
int Mas[20];

Проекты и Модули (1)
Программа состоит из набора модулей, которые совместно обрабатываются (СМ) Различают модули следующих видов:
Исходные модули, разрабатываемые программистом (*.с и*.cpp)
Объектные модули, являющиеся результатом компиляции (*.OBJ)
Заголовочные модели (header), подключающие библиотеки (*.h)
Исполнимые модули - результат создания программ (*.exe, *.com)
Эти модули совместно обрабатываются для получения результата. В системах программирования (СМ) предусмотрен специальный механизм – проект (Solution – решение *.sln), который объединяет различные модули для совместного использования. Проект нужно русифицировать (СМ).
Проекты, в зависимости от типа решаемой задачи могут иметь разный тип, настройки и назначение. Их преимущества (СМ)
В учебном процессе курса мы будем использовать простые консольные проекты на базе стандартных библиотек (СМ.).

Создание Проекта в VS (1)
Для создания консольного проекта в VS нужно выполнить следующие действия (МУ ЛР№1):
Запустить оболочку VS
Выбрать В меню Файл->Создать->Проект
Выбрать в списке: Консольное приложение Win32 (при установленном шаблоне Visual C++).
Ввести в поле «Имя» First, установив галочку у поля «Создать каталог для решения»
Нажать кнопку «ОК»
Нажать кнопку «Далее»
Установить галочки у полей: «Библиотека ATL» и «Библиотека MFC», «Пустой проект».
Нажать кнопку «Готово»
Добавить в раздел проекта новый исходный файл (first.cpp)

Создание Проекта в VS (2)
Набрать текст в окне редактирования first.cpp :
#include
#include
void main(void)
{
// Пример проекта
system ("Pause ");
return ; }
Запустить компиляцию – клавиша F7
Запустить отладку – клавиша F5
Посмотреть результат в консольном окне (см ниже).
Русификация консольного проекта (СМ)

Русификация консольного проекта
Для русификации консольного проекта в VS нужно:
Добавить в проект заголовочный файл:
#include
Добавить в начало main установку кодовой страницы:
system(" chcp 1251 > nul");
При первом запуске консольного окна настроить использование в нем шрифта Lucida Console :
Системное меню окна КС ("-")-> СВОЙСВА->ШРИФТ -> Lucida Console)->
Проверить вывод
русского текста в окне
КС(СМ)

Преимущества использования проектов
Применение проектов СП дает следующие преимущества:
Удобства в построении многомодульных программ
Автоматическое слежение за новыми изменениями (версиями) программы и перекомпиляция их при необходимости.
Общие настройки параметров и каталогов для сборки программы и их запоминание в проекте( для компиляции, редактирования, компоновки и отладки - СМ) .
Создание специальных отладочных версий и окончательных сборок программного продукта.
Индикация процесса создания программ (шаги создания: компиляция компоновка, подключения библиотек)
Применение современных возможностей объединения модулей в сложный продукт (зависимости модулей и т.д.)

Операторы
Операторы языка выполняют действия в программе, они разделяются на два основных типа:
Операторы, изменяющие данные (оператор присваивания -СМ)
Операторы, управляющие последовательностью выполнения других операторов (переходы, циклы, ветвление, выбор путей выполнения из множества) - СМ.
Особое и, даже промежуточное место, занимает оператор вызова функций – СМ (он и изменяет данные и управляет порядком выполнения)
Операторы в СИ/СИ++ разделяются специальным символом («;»)
S1; S2; S3; Sk; Sk+1; - отсутствие разделителя трактуется как ошибка!
Группа операторов заключенная в фигурные (операторные скобки ({,}) также считается оператором (составным оператором, блоком) –
{ S1; S2; S3; Sk; Sk+1 }; Примеры блоков (СМ).

Оператор присваивания (1)
Оператор присваивания (ОП) - самый главный оператор программ имеет следующие формы написания:
<Левая часть ОП> = <Правая часть ОП>
<Левая часть ОП> <Операция>= <Правая часть ОП>
Где:
<Левая часть ОП> - это переменная, или адресное выражение, куда будут записаны данные, а
<Правая часть ОП> - это выражение самого общего вида (СМ). Типы вычисляемой переменной и тип выражения правой части должны совпадать.
При несовпадении типов и невозможности их автоматического приведения используются специальные функции (СМ) или допустимые cast – выражения для преобразования типов(СМ)
Примеры оператора присваивания:
i = i + 1; Mas[i] = sin (2*a*x) ; *Pointer = 20; Summa+= Mas[i];

Операторы управления
В качестве операторов управления применяются следующие (СМ):
Оператор перехода goto (СМ);
Оператор ветвления if - else (СМ);
Операторы цикла (for, while , do) (СМ);
Оператор переключатель (switch) (СМ);
Операторы управления циклами ( break, continue ) (СМ, СМ);
Оператор возврата из функции (return) (СМ);
Операторы управления изменяют традиционную(сверху вниз СМ) последовательность выполнения других операторов.
Вызов функции/процедуры так же являются операторами управления (СМ), они записываются на основе имени вызываемой функции и списка параметров – аргументов.

Функции понятие (1)
В функции сгруппированы повторяющиеся части программ, к которым обеспечивается переход с возвратом и передачей параметров. Более подробно о функциях (СМ). Пусть программа выглядит так:
S1; S2; Sn;.. Sn+1; Sk+1 Sk+2; Sk+3; Sn;.. Sn+1; Sk+..; (Синим показаны повторы)
Вызов функции может быть выполнен отдельно или включаться в состав выражения. Тогда получим:
S1; S2; Sв; Sk+1 Sk+2; Sk+3; Sв; Sk+..; Где ; Sв; - оператор вызова функции
Возврат из функции (return) (и передача
вычисленных параметров
Вызов функции и передача фактических параметров

Функции (2)
Для использования функции нужно:
Оформить описание функции
Выполнить вызов функции и возврат из функции.
Описание функции содержит:
<Тип возврата> <Имя функции> = (<Список формальных параметров ",">)
{<Составной оператор – тело функции> }
Для возврата из функции предусмотрен оператор return:
return [<Выражение типа возврата функции>];
Вызов функции выполняется так:
<Имя функции> = (<Список Фактических параметров ",">)
Пример описания функции сложения:
int Summa ( int a , int b)
{ return (a + b);}; // return – Оператор возврата из функции!!!
Пример вызова этой функции при инициализации переменной S:
int S = Summa(1,1); // Результат S=2
Функция может и не возвращать значение и не иметь параметров, тогда задается тип возврата void и оператор возврата (return) без выражения.

Составной оператор
Составной оператор это любая группа операторов заключенная в операторные скобки (для СИ –"{","}", для Паскаля begin и end):
{S1; S2; S3; Sk; Sk+1;};
Синонимом понятия составной оператор является понятие блок (блочное/структурное программирование)
Составные операторы могут быть вложенными ( без ограничений вложенности):
{S1; S2; {S3; Sk;} Sk+1;};
Блоки используются для написания функций и структурного программирования.
Переменные объявленные в блоке имеют область видимости ограниченную внутри блока и они недоступны вне блока.
В разных блоках могут быть переменные с одинаковыми именами.

Структура
Структура (запись, класс) – это специальная конструкция языка, позволяющая совместно сохранять и манипулировать данными разных типов.
Первоначально описывается шаблон структуры(совокупность типов и имен структуры), а затем на его основе описываются структурные переменные.
Разрешается описывать массивы структур, указатели на структуры, передавать структуры параметрами в функции.
Шаблон структуры (Описание):
{<тип> <Имя поля 1>;
<тип> <Имя поля 2> ;
<тип> <Имя поля 3>;
<тип> <Имя поля 4> ;}
Пример:
struct Student {
char Fam[20];
char Name[14;
int Kurs;
float Stipend;]} ;
Ivanov

Указатели
Указатель (Pointer, Ссылка - Reference) – это переменная специального типа, которая содержит адрес другой переменной или области памяти. С указателем связаны две адресные операции:
Именования (&) – вычисление адреса и
Разыменования – взятие значения по адресу (*)
Описание указателя:
<Тип > * <Имя указателя>;
Пример описания указателя:
int i = 5 ; // Целая переменная
int * pInt; // Указатель на целое;
Операции с указателем:
pInt =&i; // Именование
int j = * pInt; //Получим j = 5 // Разыменование
* pInt = 10; // Запись по адресу, получим: i = 10
Переменная j
<Значение>=5
Вычислим: j = * pInt;

Файл (1)
Файл – это поименованная совокупность информации, определенного типа организации и расположенная в определенном месте памяти (внешней или внутренней) компьютерной системы, представленная в электронном виде.
Файл – это часть внешней памяти компьютера, имеющая идентификатор (имя) и содержащая данные
Файл – это поименованная совокупность единиц хранения информации (например, байт, строк, записей), расположенных в распознаваемом порядке (например, последовательно) и имеющей специальное обозначение конца совокупности данных
Файл может быть рассмотрен как совокупность строк или байт, записей и т.д. (см. Рисунки, EOF – End Of File – конец файла) :
Для работы с файлами используются библиотеки:
и
Файл БД

Файл (2)
Файл – это поименованная совокупность осмысленной и взаимосвязаннойинформации, определенного типа организации поименованная по правилам ОС (имя и расширение).
Файл – это часть внешней памяти компьютера, имеющая идентификатор (имя) и содержащая данные
Файл – это поименованная совокупность единиц хранения информации (например, байт, строк, записей), расположенных в распознаваемом порядке (например, последовательно) и имеющей специальное обозначение конца совокупности данных
Файл может быть рассмотрен как совокупность строк или байт, записей и т.д. (см. Рисунки, EOF – End Of File – конец файла) :
Для работы с файлами используются библиотеки:
и

Массивы (1)
Массив - это множество однотипных переменных, имеющих одно имя и упорядоченных по номеру (в ОП элементы располагаются подряд 0-N).
Для использования отдельной переменной указывается ее номер (индекс) – переменная с индексом (также называется элемент массива)
Количество переменных в массиве определяет его размер ( <число> - пусть N). Размер массива зафиксирован при работе программы.
Первый элемент массива имеет индекс 0, а последний (N-1). N- Размер
Для задания размера массива может использоваться константа этапа компиляции (define или константная переменная const).
Если в массиве предусмотрено 2 индекса такой массив называется двумерным (задается два размера N и M). В двумерном массиве данные располагаются построчно. Количество размерностей массива не ограничивается.

Массивы (2)
С массивами в ЯП связаны также следующие понятия:
Описание массива
Размер и размерность массива
Элемент массива, переменная с индексом
Описание массива:
<Тип> <Имя массива> [<размер> ] = [{<начальные значения>}];
Пример Описания массива (целый массив в 20 элементов):
int Mas[20];
Инициализация массива:
int Mas[5] = {1,2,3,4,5};
Элемент массива и переменная с индексами:
<Имя массива> [<индексное выражение> ]
Пример использования элементов массива:
Mas[ i + 5 ] = 10 ;
Пример Описания двумерного массива (10*5):
int Dmas[9][4];
Элемент двумерного массива.
Dmas[i][j] = 30;

Строка
В СИ/СИ++ в число стандартных типов не входит тип строка (СМ).
Для работы со строками используются массивы типа char.
Для работы со строками используется библиотека
, в которой предусмотрены функции: копирования, сравнения, преобразования строк и др. В С++ есть тип string.
Пример описания строки:
char Family[14]; //Строка фамилии(описание) – массив char
Пример копирования строки
#include
…
strcpy(Family, "Иванов"); //Константа строка – в "кавычках"
Пример слияния строк:
strcat(Family, "˽Иван"); // Строка Family = "Иванов˽Иван"
Определение размера строки:
int RazmStr = strlen(Family);

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

Система программирования С/С++
Система программирования (СП) это совокупность взаимосвязанных системных программ для разработки и изготовления программ (СМ). Основные компоненты МП это:
Компилятор СП исходных текстовых программ на ЯП
Текстовый редактор для ввода текстовых программ
Компоновщик (редактор связей) и библиотеки СП (стандартные), позволяющий объединить программы в единое целое.
Отладчик, помогающий искать ошибки в программе
Оболочка СП (Интегрированная среда программирования IDE), объединяющая все перечисленные части в одно целое.
Мы будем использовать систему программирования Microsoft Visual Studio версии 2005/2010/2012. (Предпочтительно иметь одинаковые версии в аудитории и на своем компьютере!).

Фазы обработки программ в СП

Модули и модульное программирование
Модульное программирование основано на разделении задачи на части (ИМ) и их автономной отладки. Разновидности модулей:
Исходный модуль (ИМ) - это результат написания программы (или ее части) на языке программирования (*.cpp, *.h)
Объектный модуль (ОМ) – это промежуточная форма программы, формируемая после обработки ИМ компилятором СП (*.obj).
Исполнимый модуль (ИСМ) – модуль получаемый в результате совместной компоновки (объединения) компоновщиком (редактором связей)всех объектных модулей проекта и готовый для выполнения на компьютере (*.exe, *.com, *.dll и др.). Исполнимый модуль содержит отладочную информацию и может быть подвергнут отладке с использованием отладчика. Данные программы включаются в СП (СМ)

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

Оперативная память
ОП – это место/устройство в компьютере где хранятся данные и программы.

Блок-схемы программ
Для безошибочной разработки программ и процедур целесообразно на начальных стадиях (СМ) описать ее алгоритм в виде блок схемы.
Блок схема – Это графическое описание алгоритма в виде ориентированного графа, в котором вершины определяют действия (операторы), в связи показывают переходы между ними. Предусмотрено ограниченное число вершин (СМ1 , СМ2)
Блок схема оформляется в виде чертежа (Пример - СМ), позволяет вручную оценить правильность алгоритма и находить ошибки в программе.

Блок схемы программ (Элементы) 1
(1)Процесс - последовательное выполнение группы команд.
Ветвление- Выбор пути выполнения по условию
Цикл - Повторное выполнения группы команд

Блок схемы (Элементы) 2
(Переключатель- выбор пути ветвления из множества
Ввод/Вывод: печать на экран и ручной ввод :
Конец:
Начало:
Вызов процедур:

Пример Блок схемы с циклом

Простая циклическая программа
Пример простой программы для вычисления суммы (Sum) отрицательных элементов массива (iMas)
#include
int Sum = 0; // инициализация переменной для суммы
// Массив
int iMas[]={123,-5, 9,-3 ,-2}; //5 эл.
int razm = sizeof (iMas)/sizeof(int); //Размер массива
for ( int i = 0; i < razm ; i++ )
if(iMas [i]<=0 )
Sum += iMas[i];
printf(«Сумма отрицательных в массиве[%d] = %d \n" , razm, Sum);
Блок-схема программы показана на слайде (СМ)
Примечание: В данной программе, для упрощения, не показана русификация проекта.

Модель процесса разработки программ
В данном процессе на каждом из этапов возможен возврат к любому из предыдущих этапов :процесс разработки программ является итерационным.
Шаги разработки Шаги итераций

Теория и темы по ЛР №1
Вычисления (МУ, DOC) через (VS –ЛР № 1)
Проекты (консольные) (СМ) и их русификация (СМ). Проект( преимущ. СМ)
Первый проект (СМ) и программа (СМ). Состав проекта (СМ)
Технология создания исполняемых программ (СМ)
Основные понятия (СМ). Переменные, константы, выражения, типы.
Оператор присваивания (СМ)
Справка и помощь (СМ). Литература по ОП (СМ)
Отладка программ (СМ).
Форматированный ввод/вывод в СИ (СМ)
Блок-схемы программ (СМ)
Библиотеки и заголовки (СМ)
Математическая библиотека (СМ)
Библиотека преобразования типов (СМ).Cast –преобразования (СМ)
Циклы (СМ) Операторы цикла (СМ).
Контрольные Задания ЛР №1 (СМ)

Проекты и их преимущества
В чем преимущества проектов (МУ)?
Много модулей
Компиляция при необходимости
Общие параметры и их запоминание
Мобильность проектов (снизу вверх)
Ведение версий
Разновидности проектов с предустановленными параметрами (Консольные, Интернет, Forms и др.)
Оптимизация программ в проектах (время и оперативная память)

Задание ЛР № 1
Изучение, теоретической части ЛР (теория, МУ DOC) – 3-й Раздел.
Создать первый Проект (СМ), русифицировать его (СМ).
Выполнить Первый простой пример F5 (см. МУ).(СМ)
Подключить математическую библиотеку, пример (см. МУ) (СМ). sin (!)
Изучить и опробовать функции ввода/вывода(МУ) (СМ) ( printf и scanf).
Сделать все (!) примеры из МУ (МУ) в созданном проекте (3.10-3.15).
Выполнить простую программу с вводом, вычислением и выводом результата (МУ– п.3.12.
Выполнить программу по своему варианту (4.6) с вводом/выводом.
Разработать Блок-схему своей программы, вставив ее в отчет ЛР (СМ).
Подготовить ответы на все контрольные вопросы (раздел 8 МУ). (МУ)
Подготовить отчет по шаблону (СМ) и примеру (СМ) и Требований (СМ)
Продемонстрировать программу ЛР и Защитить ЛР по отчету (разд. 7).
Выполнить программу с дополнительными требованиями (изменение переменной, цикл вывода данных в таблице). (раздел 6 МУ)

Контроль ЛР № 1
Создание и русификация проекта. - п.п 4.2/3. МУ. (СМ), (СМ). ( МУ DOC)
Выполнение простого примера. - п.п 4.4 (СМ)
Подключить математическую библиотеку функций и констант, - п.п 4.5
Изучить и опробовать функции библиотеки ввода/вывода - п.п 4.6
Выполнить простую программу с вводом, вычислением и выводом результата - п.п 4.7.
Выполнить программу по своему варианту п.п 4.8 (см. таблицу) в том числе и в пошаговом режиме и просмотром переменных.
Продемонстрировать работающую программу ЛР - п.п 4.8
Подготовить отчет по шаблону (СМ) и примеру (СМ) и с учетом Требований (СМ). обязательной блок-схемой. п.п - 4.10
Разработать программу с дополнительными требованиями (изменение переменной, цикл вывода данных в таблице). - п.п 4.9
Подготовить ответы на все контрольные вопросы.
Умение выполнять все примеры из теоретической части ЛР п.п 4.1. МУ.
(выборочно!)

ЛР № 1 Подключение математики
Для использования математической библиотеки (СМ) нужно подключить следующий заголовочный файл:
#include
Для использования стандартных констант (e, π и др.) нужно перед этим установить специальный режим их использования:
define _USE_MATH_DEFINES
Тогда в программе можно вычислять функции:
F = 2*sin(X + M_PI/2 ); // F = sin (X + π/2 )
Объявление библиотеки и установка режима должны быть выполнены в начале исходного модуля главной программы проекта (до main).
Состав библиотеки и название констант можно посмотреть в режиме справки (СМ) или просмотром модуля (match.h)

ЛР №1 Форматированный ввод/вывод
Форматированный Ввод/вывод в СИ выполняется специальными функциями:
printf – вывод данных в окно консоли (СМ) и
scanf – ввод данных с клавиатуры (СМ)
Каждая из этих функций имеет форматную строку и список переменных для ввода/вывода.
<формат вывода> <список ввода/вывода>
<формат вывода>- константная строка в которой заданы условия ввода/вывода переменных (Например: "X=%d").
<список ввода/вывода> - перечень переменных для операций ввода/вывода, причем при вводе данных необходимо задавать указатели (адреса переменных).
Для разных типов переменных указываются свои форматы (d,f) (СМ)
Ввод вывод в С++ (СМ). Операции "<<" и "<<"

Функция вывода - printf
Функция printf – Используется для вывода данных в окно консоли (КС) и ее вызов имеет вид (СМ):
printf ( <формат вывода> <список ввода/вывода>);
Формат, задается в виде константной строки ("…")и определяет тип преобразования данных при выводе переменных из списка (Vi), для каждой переменной должен быть задан свой формат (Фi) –(СМ):
Список переменных не ограничивается (функция с переменным числом аргументов). Пример применения (вывод 3-х переменных):
char symb='Ж'; int numb = 33; char Str[25] = "Строка текста";
printf ("%10.3s %c %2d" , Str, symb, numb);
Получим: ˽˽˽˽˽˽˽Стр Ж 33
7 пробелов и напечатаны первые 3 символа( спецификация - %10.3s ).

Функция ввода данных - scanf
Функция выполняет ввод данных с клавиатуры в режиме работы консольного окна(СМ). Для корректного вода русского текста должна быть обеспечена русификация (СМ). Функция имеет вид:
scanf( <формат ввода> <список ввода/вывода>);
В отличие от вывода в списке вывода записываются указатели (&Vi):
Пример ввода данных (переменные аналогичные СМ)
printf ("Введите:");
scanf("%s %c %d", Str, &symb, &numb);
printf ("%10.5s %c %2d" , Str, symb, numb);
Получим после ввода и вывода:
Введите: Пример˽5˽77˽
Приме˽5˽77

Форматы ввода/вывода
Предусмотрены следующие возможности для вывода типов:
[<общий размер вывода>] [.<точность>]% [.<Спецификатор вывода>] <тип вывода>
Где: [.<точность> - размер дробной части или части строки
<Спецификатор вывода> - {l, h, …} – задает размер данных (l - float, double).
<общий размер вывода> - поле, отводимое для печати данных
<тип вывода> - формат ввода/вывода Основные:
d -преобразование в десятичный формат;
о -преобразование в восьмеричный формат;
x-преобразование в шестнадцатеричный формат;
n-используется для запоминания текущей позиции в строке вывода;
f,g,е – печать действительных типов с порядком (e) и без (f,g).
p – выводится в формате адреса (указатель)
s-печать в формате строки (передается указатель);
с-печать одного символа.

ЛР №1 Ввод/вывод в С++
Пример Ввода вывода в С++ с помощью классов потоков (cin и cout)
#include
// - 1
#include
#include
using namespace std ;
void main(void) // - 2
{ // Вывод текста
system(" chcp 1251 > nul"); // !!! 2
getchar(); // - 4
cout << endl<< "Введите iVar = :";
int iVar=0;
cin >> iVar ;
cout << endl<< "Вы ввели: iVar = :"<< iVar <
system(" PAUSE"); // 3// !!! 3
return; };

Справка и помощь
При программировании в СП важную роль играет возможность оперативного получения справочной информации (по ЯП, по СП, по компонентам оболочки и т.д.). В VS предусмотрено два варианта подключения справочной системы:
Подключение к справочной системе онлайн (через Интернет)
Установка на компьютер справочной системы MSDN (Microsoft Developer Network).
Если такие возможности обеспечены, то
получение справки выполняется оперативно таким образом:
Выделяется нужный фрагмент текста для справки (Например имя функции sin) и нажимается клавиша F1.
Кроме того, доступ к справочной системе возможен через пункт главного меню "Справка".
Помимо этого справочная информация доступна в литературе, документации и специальных сайтах программистов.

Библиотеки и заголовочные файлы
Реализация проектов по разработке программ невозможна без использования стандартных библиотек. Библиотеки могут:
Подключаться в программу из СП (СМ)
Подключаться в программу из ОС (Языки нижнего уровня)
Приобретаться как отдельные программные продукты
Разрабатываться пользователем самостоятельно.
Для подключения библиотек в С/С++ нужно:
Описать и подключить заголовочный файл с описанием библиотеки (директива препроцессора include ):
#include <имя библиотеки>
Например подключение библиотеки ввода вывода
#include
При создании проекта подключить библиотеки ( ATL, MFC)

ЛР №2 Теория
Ветвления и циклы (МУ, DOC) через (VS –ЛР № 1)
Ветвления и циклы, причины, назначение и преимущества ( СМ)
Операторы перехода (СМ) и метки в программе (СМ – Модель программы) , операторы управления (СМ)
Условия и операторы ветвления (СМ) и уловные выражения (СМ)
Циклы (СМ). Операторы построения циклов (СМ)
Оператор переключатель (СМ)
Операторы управления циклами (СМ)
Понятие процедуры (СМ), как элемента ветвления в программе
Понятия о модулях (СМ) и модульном программировании (СМ)
Примеры программ с ветвлениями и циклами (СМ),(МУ)
Контрольные задания ЛР №2 (СМ) (МУ)

ЛР №2 Зачем нужны ветвления и переходы?
Для изменения -(МТ) последовательности выполнения (СМ):
Необходимостью безусловного перехода (goto- СМ) к выполнению другого оператора программы, например завершающего программу или блок (безусловный переход на метку).
Необходимость выбора альтернативных путей выполнения в программе (условный оператор (if - СМ) и оператор переключатель выполнения групп операторов (switch) - СМ).
Необходимость многократного повторения последовательности операторов ( операторы циклического повторения – for (СМ), while (СМ), do (СМ)) – (СМ) или построения циклов (СМ).
Вызов повторяющейся последовательности операторов, настраиваемых на заранее выделенные параметры (вызов процедур и функций) (СМ).
Прервать весь цикл (break - СМ) или выполнить через шаг цикла (continue - СМ)

Оператор goto
Оператор goto безусловно передает управление на указанную метку: Метка должна быть доступна при использовании(видна). Формально так:
goto <метка>;
. . . . .
<метка>: <оператор>;
Метка – Это любой идентификатор, с двоеточием.
Пример программы с меткой:
goto Label1;
printf("Это Никогда не печатается!!!\n");
Label1: // Это - Метка
printf("Переходим сюда!!\n");
Пример программы с меткой:
Label0:
printf("Это печатается бесконечное число раз!!!\n");
goto Label0; // Это - Бесконечный цикл

Оператор if – else (1)
Оператор ветвления предписывает выполнение одного из двух составных операторов в зависимости от проверки логического условия. Формально оператор ветвления if ( если ) – else ( иначе) – имеет вид (блок схемы - СМ):
if (<логическое условие>)
{ <составной оператор 1, выполняемый при истинности условия>}
[ else [ if ]
{ < составной оператор 2, выполняемый при ложности условия >} ] ;
Пример простого условного оператора (Блок-схема - СМ):
// условный оператор (максимум из двух переменных) - 2 варианта
int a = 5;
int b = 3;
if ( a >= b) // логическое условие
printf("Максимально а = %d a>=b !\n" , a);
else
{ printf ("Максимально b = %d a

Оператор if –else (2)
Пример вложенного условного оператора для выбора из максимума трех переменных
(A,B,C) NB – блок схема- СМ:
if ( A > B ) // логическое условие 1
{// Соствной оператор
if ( A > C ) // логическое условие 2
printf("Максимально (A) - %d\n" , A);
else
printf("Максимально (C) - %d\n" , C); }
else
{
if ( B > C ) // логическое условие 3
printf("Максимально (B) - %d\n" , B);
else
printf("Максимально (C) - %d\n" , C); };

Блок-схема простого условного оператора имеет вид (2 выбора):
Оператор if (3)
Блок-схема Вложенного условного оператора
имеет вид (4 выбора):

Оператор switch – case (1)
Оператор переключатель позволяет выбрать действия из множества возможных альтернатив.
Блок схема может быть представлена двумя вариантами (на базе условий и альтернатив):
Формальноя описание переключателя:
switch (<выражение>) {
case <конст-выр 1>: <Составной оператор 1>
case <конст-выр 1>: <Составной оператор 1>
default: <Составной оператор К> }

Оператор switch – case (2)
Оператор переключатель позволяет выбрать одну из альтернатив (case) в
зависимости от вычисленного целочисленного выражения (num) или отдельного символа. Пример оператора:
//Оператор ПЕРЕКЛЮЧАТЕЛЬ !!!!
int num = 2; // задаем для демонстрации выбора
switch ( num)
{ case 1:
printf("Выбор 1!\n");
break;
case 2:
printf("Выбор 2!\n");
case 3:
printf("Выбор 3!\n");
// break !!!!!!!!!!!
break;
default:
printf("Выбор по умолчанию!!\n"); };

Оператор switch – case (3)
Оператор переключатель позволяет выбрать одну из альтернатив в зависимости
от вычисленного символьного значения выражения
Пусть для сравнения задаются символы – переменная csimb ( у нас - 'Ж'):
// Переключатель для символов
char csimb = 'Ж';
switch ( csimb)
{ case 'I':
printf("Выбор I!\n");
break;
case 'Ж':
printf("Выбор Ж!\n");
case 'N':
printf("Выбор N!\n"); break;
default:
printf("Выбор по умолчанию!!\n"); };
То получим результат (нет break!):
Выбор Ж!
Выбор N!

Оператор цикла for
Оператор цикла for (кратко СМ, общее - СМ), позволяет заданное число
раз повторить составной оператор тела цикла (Блок схема для общего вида цикла – СМ, для цикла for см ниже ). Формально:
for (<выражение 1>; <выражение 2>; <выражение 3>)
<Составной оператор – тело цикла>
Где:
(<выражение 1> и (<выражение 3> - выражения присваивания через запятую, а
<выражение 2> - выражение отношения.
Правило: Вычисляется <выражение 1>, проверяется <выражение 2> и , если оно истинно (true) , выполняется тело цикла <Составной оператор> и вычисляется <выражение 3>, если условие ложно (false) то цикл завершается. Пример:
for (int i =1 ; i <= 5 ; i++ )
{
printf("Шаг цикла(for) - %d\n" , i); // Тело цикла
};
Цикл выполняется с начальным значением i = 1, На каждом шаге цикла печатается строка (("Шаг…"), после печати проверяется условие (<= 5) и при его истинности циклы заканчиваются. Если условие ложно, то выполняется увеличение i на единицу и циклы продолжаются.

Блок схема для цикла for
Блок схема для цикла for помогает понять его работу:
В
операторе цикла for можно описывать локальные переменные (int i) и выполнять несколько вычислений (k = 10 ,j++)
for (int i =1 ; i <= 5 ; i++, k = 10 , j++ ) // несколько выражений
{
printf("Шаг цикла(for) - %d\n" , i); // Тело цикла };

Оператор цикла while
Блок-схема оператора цикла while (СМ) соответствует циклу с начальной. проверкой условия
продолжения цикла: проверяется условное выражение и , если оно истинно, то тело цикла выполняется (составной оператор). Если ложно (=0), то циклы заканчиваются. Формально это выглядит так.
while (<Условное выражение>)
<Составной оператор – тело цикла>
Пример
// Цикл while печатает строку, пока (while) k < 5
int k = 0;
while ( k < 5)
{
printf("Шаг цикла (while) - %d\n" , k);
k++; };

Оператор цикла do
Блок-схема оператора цикла do (СМ) соответствует циклу с завершающей. проверкой условия
продолжения цикла: тело цикла выполняется (составной оператор). а затем проверяется условное выражение, расположенное после слова while и Если оно ложно (=0 - false), то циклы заканчиваются, , если оно истинно, то тело цикла снова выполняется (составной оператор). Формально это выглядит так:
do
<Составной оператор – тело цикла>
while (<Условное выражение>)
Пример цикла do ( цикл выполняется 5 раз при k = 0,4):
//Цикл do
int i = 0;
do
{
printf("Шаг цикла(do) - %d\n" , i);
i++; i++;
} while ( i < 4);

Оператор break
Оператор break, расположенный в теле цикла прекращает выполнение любого (for, do, while)
оператора цикла. Пример:
// Цикл for с условной остановкой на втором шаге
for (int i =1 ; i <= 5 ; i++ )
{
printf("Шаг цикла(break) - %d\n" , i);
if ( i == 2) break;
};
Если индекс i достигает значения 2, то циклы заканчиваются.
Цикл также закончится, если в теле цикла встретится оператор return (оператор return – оператор завершения функции или всей программы - в функции main).
Оператор break используется также в операторе переключатель для прекращения просмотра альтернатив (СМ)

Оператор continue
Оператор continue, расположенный в теле цикла прекращает выполнение текущего шага – итерации
любого (for, do, while) оператора цикла. Пример:
// Цикл for с условным пропуском части операторов на втором шаге ( continue)
for (int i =1 ; i <= 5 ; i++ )
{
printf("Шаг цикла(break) - %d" , i);
if ( i == 2) { printf("Пропуск части 2 %d!!\n", i); continue; };
printf("Тело - часть 2!!\n");
};
Цикл при этом продолжается по общим правилам до его завершения.

ЛР №2 Примеры
Безусловный переход (МУ) (СМ) (DOC)
Условный оператор if (МУ) (СМ) и выражение
(СМ)
Логическое выражение/операция (МУ) (СМ)
Вложенность операторов условия (МУ) (СМ)
Максимум из 3-х (МУ) (СМ)
Решение квадратного уравнения (МУ) (СМ)
Циклы на основе If (МУ) Простой (СМ), Табуляции (СМ)
Циклы из теоретической части (МУ) (СМ)
Сумма четных чисел при вводе (МУ) (СМ)
Распечатка чисел Фибоначи (МУ) (СМ)
Печать заданного при вводе количества простых чисел (МУ) (СМ)
Диапазоны печати для задания 12 и 11 (МУ) (СМ)

ЛР №2 Примеры (1)
Безусловный переход (МУ) (СМ)
Lab0:
goto Lab1;
printf("Это Никогда не печатается!!!\n");
Lab1: // Метка
//
goto Lab0; // Бесконечный цикл при таком переходе - Закомментировано
printf("Переходим сюда!!\n");

ЛР №2 Условный оператор (2)
Условный оператор (МУ) (СМ)
// условный оператор (максимум из двух
переменных) - 2 варианта
int a = 5;
int b = 3;
if ( a >= b)
printf("Максимально а = %d a>=b !\n" , a);
else
printf ("Максимально b = %d a
if ( a > b)
printf("Максимально а = %d a>b !\n" , a);
else
{
if ( a < b) // вложенный условный оператор
printf ("Максимально b = %d a
else
{ printf ("Максимально b = %d a
};

ЛР №2 Условное выражение
Условное выражение/ условная операция (МУ) – используется для альтернативных вычислений.
Конструкция
условного выражения (правило записи):
<условное выражение> :=(<логическое условие>)?<Выражение 1>:<выражение 2>
Смысл условного выражения : вычисляется <условие> и , если оно истинно , то в операции участвует <Выражение 1>, иначе вычисляется <Выражение 2> .
<логическое условие> - условное выражение (вычисление true или false).
Примеры:
int x =5 , y =3 , z =0;
// Использование условное выражение в операторе присваивания z = ((y > x)? y : x); // Вычисление z = мах{х,у}
// В вызове функции: Печать максимального из х и у
printf("Макс.из х = %d и y=%d равно-> %d\n" ,
x , y , ((y > x)? y : x));
Результат: Макс.из х = 5 и y=3 равно-> 5
.

ЛР №2 Вложенность if (4)
Вложенность операторов условия (МУ) (СМ)
int a = 5;
int b
= 3;
if ( a >= b)
printf("Максимально а = %d a>=b !\n" , a);
else
printf ("Максимально b = %d a
if ( a > b)
printf("Максимально а = %d a>b !\n" , a);
else
{
if ( a < b) // вложенный условный оператор
printf ("Максимально b = %d a
else
{ printf ("Максимально b = %d a
};

ЛР №2 Максимум из 3-х (5)
Максимум из 3-х (МУ) (Блок – схема -
СМ)
int A = 8 , B = 4 , C =1;
if ( A > B )
{
if ( A > C )
printf("Максимально (A) - %d\n" , A);
else
printf("Максимально (C) - %d\n" , C); }
else
{
if ( B > C )
printf("Максимально (B) - %d\n" , B);
else
printf("Максимально (C) - %d\n" , C); };

ЛР №2 Максимум из 3-х Блок-схема (5)
Блок-схема выбора максимума из 3-х представлена ниже:

ЛР №2 Корни уравнения (6)
Решение квадратного уравнения (МУ) (блок- схема СМ) ax2+bx+c=0
float a,b,c,z,
d,e,f,x1,x2;
printf("\nВведите а b и с:\n") ;
scanf ("%f%f%f",&a,&b,&c);
printf("\nДля a = %4.2f b = %4.2f c= %4.2f \n" , a, b ,c );
// Промежуточные вычисления
z=2.0f*a;
e=-b/z;
d=b*b-4*a*c; // детерминант
f=sqrt(fabs(d))/z;
// Проверка корней
if(d>=0)
{ x1=e+f; x2=e-f; // действительные корни
printf("\nКорни уравнения действительные\n");
printf("\n x1= %4.1f",x1);
printf("\n x2= %4.1f\n",x2); }
else { printf("\nКорни уравнения мнимые\n");
printf("\nВешественная часть e= %4.1f",e);
printf("\nМнимая часть f= %4.1f\n",f); };

ЛР №2 Блок-схема(6)
Вычисление действительных (X1 и X2) корней или комплексных (мнимая – е
и действительная часть - f), зависит от вычисленного значения детерминанта d).

ЛР №2 Цикл на базе if (7)
Цикл на основе if (МУ) (,Блок схема
- СМ)
// Организация цикла для суммы арифметической прогрессии с помощью if
int j = 1; // Начальные условия цикла
int Sum = 0;
int step = 5;
M1:
if ( j < 10) // Проверка продолжения цикла
{
Sum +=j*step; // Тело цикла
j++; // Тело цикла
goto M1; // Тело цикла
};
printf ("\nЗначение Sum = %d для j =%d\n" , Sum, j);
Результат:
Значение Sum = 225 для j =10

ЛР №2 Блок схема (7)
Блок схема цикла на основе оператора if. Задается выполнение
10 циклов суммирования членов арифметической прогрессии (шаг 5). После суммирования выполняется печать результата.

ЛР №2 Цикл табуляции на базе if (7)
Цикл Табуляции функции на основе if
(МУ) приведен ниже. (Блок схема - СМ)
// Начальные условия цикла
float x= 0.05F; // начальное значение (!=0)
int b = 2; int a = 1; // здесь a и b задаенм при инициализации
float Step = 1.0F , z;
// Цикл табуляции функции
CIKL:
if ( x <= 10.f ) { // Проверка завершения
z= (float) (5.0*sin( (0.5F*b*pow(x,2)))/x); // Вычисление z pow – функция возведения в степень
// z=cos(2*a); // Ошибка а - int
// z=cos(2.0*a); // использование действительной константы
// z=cos((double)2*a); // использование cast- преобразований
// Вывод строки
printf("\nФункция z =%7.3f для x= %4.2f", z, x);
x += Step; // изменение x на шаг step
goto CIKL; // Продолжение цикла
};

ЛР №2 Блок схема (7)
Блок схема цикла на основе оператора if для табуляции
функции.

ЛР №2 Операторы цикла(8)
Циклы из теоретической части (МУ) (СМ)

ЛР №2 Сумма четных (9)
Сумма четных чисел при вводе (МУ)

ЛР №2 Числа Фибоначи (10)
Распечатка чисел Фибоначи (МУ)

ЛР №2 Простые числа (11)
Печать заданного при вводе количества первых простых чисел (МУ)

ЛР №2 Диапазоны печати(12)
Диапазоны печати для контрольных заданий 12 и 11 (МУ) (СМ)

ЛР №2 Задание, Контроль
Определение минимума с помощью условных операторов из трех целых чисел.
(МУ, DOC)(СМ) – п.п 5.3
Вычисление корней уравнения с использованием переключателя (МУ) (СМ) – п.п 5.4
Построить цикл с помощью if для вывода функции (СМ) п.п 5.5
Построить цикл с помощью операторов цикла для табуляции функции по варианту (СМ) п.п 5.6
Д.Т. Поиск максимального значения на основе оператора if (с равенствами) (МУ) (СМ)
Д.Т. Вычисления с запоминанием в массиве. (СМ) (МУ)
Д.Т. Вычисления с запоминанием значений и вводом аргументов (СМ) (МУ)
Д.Т. Простые числа и числа Фибоначи (в диапазоне чисел) (МУ)
Д.Т. Вычисление минимума в инициализированном массиве.

ЛР №2 Задание – 5.3
МИНИМУМ ИЗ 3-х
if ( A < B )
{ if
( A < C )
printf("Минимально (A) - %d\n" , A);
else
printf("Максимально (C) - %d\n" , C); }
else
{
if ( C < B )
printf("Минимально (C) - %d\n" , C);
else
printf("Минимально (B) - %d\n" , B); };

ЛР №2 Задание – 5.4
Переключатель вместо условия
...
// Переключатель
switch (Var) {
case 1:
{ x1=e+f;
x2=e-f;
printf("\nКорни уравнения действительные\n");
...
break; }
case 2: {
printf("\nКорни уравнения мнимые\n");
...
break; };
default:
printf("\nНет корней\n");

ЛР №2 Задание – 5.5
Цикл вычисления if
// Начальные условия цикла
x= 0.05f;
b= 0.2f;
float Step
= 1.0F;
// Ввод границы для печати функции
printf("Введите значение границы печати функции (не более) a:");
scanf ( "%f", &a);
// Цикл табуляции функции
CIKL:
if ( x <= 10.f )
{
if ( x == 0.0f) // Проверка деления на 0
{
printf("\nДеление невозможно z - неопределённо при x= %4.2f",x); }
else {
z= 5.0f*sin( 0.5*b*powf(x,2))/x; // Вычисление
if ( z > a )
// Печать
printf("\nФункция z =%7.3f для x= %4.2f", z, x); };
x += Step;
goto CIKL; // Продолжение цикла

ЛР №2 Задание – 5.6
Цикл вычисления while
printf("\nТабуляция функции оператор цикла(while):\n") ;
float z1, x1,
a1, b1;
// ачальные условия цикла
b1= 0.2f;
a1 = 0.0f; // Граница печати
x1= 0.05f; // Начальное значение аргумента
// Цикл вычислений
while ( x1 <= 10.f )// проверка конца цикла
{ if ( x1 == 0.0f) // проверка деления на ноль
{ printf("\nДеление невозможно z1 - неопределено при x1= %4.1f",x1); }
else { z1= 5.0f*sin( 0.5f*b1*x1*x1)/x1; // x1*x1
if ( z1 > a1 ) // проаерка печати
printf("\nФункция z1 =%7.3f для x1= %4.2f", z1, x1); };
x1 += 1.0f ; };

ЛР №3 Теория Список тем
Массивы и указатели (МУ, DOC) через (VS –ЛР №
3)
Понятие массива (СМ1, СМ2) (МУ, DOC)
Описание массива (СМ). Понятие строки. (МУ)
Размер (СМ) и размерность массива и их задание и определение (СМ) (МУ, DOC)
Инициализация массивов одномерных и многомерных (СМ) (МУ, DOC)
Работа с элементами массива(СМ) (МУ, DOC)
Понятие указателя в СИ/СИ++ (СМ1 , СМ2)(СМ) (МУ, DOC)
Ввод массивов (scanf) (СМ) (МУ, DOC)
Описание указателей и операции с ними (СМ) (МУ, DOC)
Указатель на массивы и работа с ним, (СМ) (МУ, DOC)
Адресная арифметика (СМ) (МУ, DOC) Указатель на строки (СМ).
Массивы указателей (СМ)(МУ, DOC). аргументы командной строки (СМ)
Указатели на указатели (СМ) и на функции (СМ) (DOC)
Динамическая память (СМ) и работа с ней (библиотека функций ДП) (СМ) (DOC).
Динамические массивы (СМ), работа с ними, их ввод и вывод (DOC).
Многомерные массивы и работа с ними (СМ) (МУ, DO DOC)
Примеры (СМ) и Контрольные задания ЛР №3 (МУ) (МУ, DOC)
Массивы (СМ) и указатели (СМ) как параметры функций (СМ).

ЛР №3 Понятие массива
Для удобства работы, сокращения размера программы и повышения ее
наглядности в СИ/СИ++ используются массивы (СМ).(МУ, DOC).
Массив – Это упорядоченное множество однотипных переменных, расположенных последовательно (!) в оперативной памяти компьютера (СМ).
С массивами связаны следующие понятия:
Описание массива (СМ)
Размерность и размер массива (СМ) и их определение (СМ)
Элемент массива (СМ)
Инициализация массива (СМ)
Многомерные массивы (СМ)
Динамические массивы (СМ)
Массивы в программировании используются для (преимущества массивов):
Организации циклов в программе
Повышения наглядности и понятности текста программы (!)
Уменьшения размера программы в ОП (!)
Сокращения времени выполнения программы (!).

ЛР №3 Описание массива
Описание массива выполняется до его первого использования в программе
(МУ, DOC).
В общем случае описание массива выполняется так:<тип массива > <имя массива> [[<размер массива>]]… [<размер массива>] [= <Инициализация массива>];
где:
<тип массива > - стандартный или пользовательский тип СИ/СИ++ (int, float, char)
<имя массива> - допустимое и уникальное в блоке имя в языке СИ/СИ++.
[<размер массива> - целочисленное выражение этапа компиляции (!)
<инициализация массива> - задание начальных значений элементов массива (СМ)
Примеры описаний одномерных массивов:
Количество записей размеров массива не ограничивается. Многомерные массивы (СМ)
#define MAX 20 // Переменная этапа компиляции
int iMas [10]; // описан массив iMas целого типа, содержащий 10 элементов char sMas [MAX]; // массив sMas символьного типа, содержащий MAX элементов
int iMas []; //Ошибка, не указан размер нет инициализации вместе (!)
Пример описания двумерного массива:
int iDMas [5][5]; //Двумерный массив iMas целого типа, содержащий 5*5 элементов
float fMas [5][MAX ]; // Двумерный массив 5*MAX элементов

ЛР №3 Инициализация массивов
При описании массива можно задать начальные значения его элементов
(МУ, DOC).
Это выполняется так для одномерных массивов с заданным размером:
<тип><имя массива>[<размер>]= {<выражение>, <выражение>, …] }
или без явного задания размера:
<тип><имя массива>[]= {<выражение>, <выражение>, …] }
Во втором случае размер массива определяется автоматически по числу заданных выражений. В выражениях могут быть использованы: целочисленные переменные , значения которых задано к моменту описания данного массива. Если заданный при описании размер превышает число выражений, то последние элементы инициализируются нулем. Если число выражений меньше чем заданный размер массива, то выдается ошибка.
Примеры:
int iMas1[4] = {3,3,2,4}; // Инициализация массива – 4 элемента
int iMas1[] = {3,3,2,4,5}; // Инициализация массива – 5 элементов
int iMas1[3] = {3,3,2,4}; // Ошибка! Много инициализаторов
int elem = 3;
int iMas1[4] = {elem, elem}; // Массив <3,3,0,0,> – 4 элемента
В выражениях инициализации переменные должны быть заранее вычислены или инициализированы.

ЛР №3 Элементы массива
Элементом массива называется одна переменных из множества составляющих этот массив.
(МУ, DOC). Понятие Элемент массива ≡ Понятию переменная!
Для его указания задается номер этой переменной в массиве (массив пронумерован).
Номер задается с помощью целочисленного индексного выражения. Элемент одномерного массива записывается так:
<имя массива>[<индексное выражение>]
Для двумерного массива:
<имя массива>[<индексное выражение 1>] [<индексное выражение 2>]…
В индексном выражении могут быть использованы:
Переменные целого типа и целочисленные константы
Переменные этапа компиляции и вызовы функций
Переменные константного типа.
Примеры элементов одномерного массива:
Mas[i] , Mas[i+1], Mas[fun()], Mas[15], //fun() – возвращает целое значение
Примеры элементов двумерного массива:
Mas[i][j] , Mas[i+1][10]

ЛР №3 Размер Массива
Размер массива можно определить в программе динамически (МУ, DOC):
Пример:
int iMas1[]
= {3,3,2,4,5};
int Razm = sizeof(iMas1)/sizeof(int); // Razm = 5

ЛР №3 Понятие указателя
Тема: Массивы и указатели (МУ, DOC)
Указатель( Pointer) - Это
переменная специального типа, которая содержит адрес другой переменной или области памяти. (СМ) (МУ, DOC). (!!! Указывает)
При описании переменной должен задаваться тип переменной на которую она ссылается. Поэтому описание указателей производится так:
<тип> * <имя> [=<адресное выражение>]
Пример описания указателя и работы с ним:
int * pIntVar; // Указатель на переменную типа int
int i=5; // целая переменная
double *pDVar; // Указатель на переменную типа double
Double = dVar = 5.5;
pDVar = &dVar // Вычисление указателя
pIntVar = &i; // Вычисление указателя
int iVar = *pIntVar; // чтение по адресу iVar = 5
*pIntVar = 10; // запись по адресу i = 10
Печать через указатель и указателя(СМ) и ввод через указатель (СМ):

ЛР №3 Ввод и вывод с указателями
Печать через указатель и указателя:
printf ("\nПечать по
указателю = %d\n", *pI pIntVar );
printf ("\nПечать значения указателя (адреса) = %p\n", pI pIntVar);
double *pDVar; // Указатель на переменную типа double
double dVar = 5.5;
Печать через указатель действительного значения:
pDVar = &dVar ; // Вычисление указателя
printf ("\nПечать по указателю (double) = %7.2lf\n", *pDVar );
Ввод через указатель:
printf ("\nВведите целое:" );
scanf("%d", pIntVar); // Ввод по указателю
printf ("\nПечать введенного по указателю = %d\n", * pIntVar);
Результат:
Печать по указателю = 25
Печать значения указателя (адреса) = 001DF7A8
Печать по указателю (double) = 5.50
Введите целое:77
Печать введенного по указателю = 77

ЛР №3 Ввод и вывод Массивов
Ввод (СМ) и вывод (СМ) массивов выполняется в
цикле (МУ, DOC)

ЛР №3 Описание Указателей
Описание указателей (СМ1)(СМ2) (МУ, DOC)
При описании указателей перед именем переменной
ставится звездочка:
<тип> * <имя> [=<адресное выражение>]
Примеры описания указателя:
int * PtrMas; // Указатель на целую переменную
int **ppInt; // Указатель на указатель на переменную типа int
Для работы с указателями используются два типа операций:
Операция именования - вычисления адреса (&) и
Операция разыменования – получения значения по адресу (*).
Примеры:
int * PtrMas; // Указатель на целую переменную
int **ppInt; // Указатель на указатель на переменную типа int
int i = 5;
int pi =&i; // вычисления адреса переменной i
int b = *pi; // взятие значение переменной i по адресу pi (b =5)
Операции с указателями могут использоваться многократно(**):
int b = *pi; // взятие значение переменной i по адресу pi (b =5)
ppInt = π // формирование указателя на указатель
int c = **ppInt; // Двойное разыменование

ЛР №3 Указатель на массивы
Массивы и указатели (МУ, DOC)
Для работы с массивом
может задаваться указатель на массив, который вычисляется как адрес на первого элемента массива. Тогда имя указателя может использоваться в
индексном выражении. Примеры:
int Mas[] = {1,2,3,4,5}; // Описание массива
int * pMas; // Указатель на int
pMas1 = &Mas[0]; // Вычисление указателя как адреса первого элемента массива
pMas = Mas; // Имя массива == указателю на первый элемент (равно &Mas[0])
i = pMas[2]; // Индексное выражение с указателем, результат i = 3
При воде функцией scanf , для указателя задается выражение на основе адресной арифметики (СМ):
scanf("%d", &Mas[2]); // Ввод третьего элемента массива Mas[2]
scanf("%d", pMas1 + 3); // Ввод четвертого элемента массива Mas[3]
scanf("%d", pMas1); // Ввод первого элемента массива Mas[0]
scanf("%d", (int *)pMas1[3]); // Ввод четвертого элемента массива Mas[3] // Ошибка этапа выполнения pMas1[3]– это не адрес а элемент!!!!!!!!!!!!
Для ввода через указатель и индекс i в цикле (Д.П. - СМ) нужно использовать адресное выражение:
int i = 2;
scanf("%d", pMas1 + i); // Ввод третьего элемента массива Mas[2]

ЛР №3 Адресная арифметика
Массивы и указатели (МУ, DOC)
Если в целочисленном выражении используется указатель,
то вычисление выполняется по правилам адресной арифметики (МУ, DOC):
Результатом вычисления будет адрес.
В сложении каждая единица при сложении или вычитании соответствует размеру типа объявленного для указателя (int = 4 , проверьте sizeof). Примеры:
int * pOld= pInt; i = 2;
printf ("\nАдресная арифметика:\n" );
printf ("\nПечать значения указателя (до) = %p\n", pInt );
pInt++; // увеличение на 4 – это размер int
printf ("\nПечать значения указателя (после) = %p \nИзменение в адресах: %d в числах: %d \n", pInt , pOld-pInt , (pOld-pInt)* sizeof(int) );
pInt +=i; // увеличение на 8 - размер int * 2
pInt = pInt - 1 ; // уменьшение на 4
pInt +=i*2; // увеличение на 16 i = 8 * 2
Результат работы фрагмента:
Адресная арифметика:
Печать значения указателя (до) = 0028FC40
Печать значения указателя (после) = 0028FC44
Изменение в адресах: 1 в числах: 4

ЛР №3 Указатель на строки
Строки (СМ) и указатели на них(МУ, DOC)
В Си
нет отдельного типа строка (СМ). Для хранения текстовых переменных используются символьные массивы (char).
Имя этого массива одновременно является указателем. В функциях библиотеки строк
(
) и пользовательских функциях. Функции (СМ) и строки (СМ).
Имя этого массива одновременно является указателем. В функциях библиотеки стьрок и пользовательских функциях. Функции (СМ) и строки (СМ). Работа со строками будет рассмотрена в ЛР №4 (СМ). Пример:
// Указатели на строки
char * pStr; // Указатель на строку
char Str[]="Это строка!";
pStr = Str; // Вычисление указателя
printf ("\nПечать строки через указатель = %s\n", pStr );
pStr = &Str[0]; // Или так
printf ("\nПечать строки через указатель = %s\n", pStr );
Результат:
Печать строки через указатель = Это строка!
Печать строки через указатель = Это строка!

ЛР №3 Массивы указателей
Массив указателей объявляется так:(МУ, DOC):
<тип> * <имя> [=<размер - выражение>]
= {<список инициализации>};
или
<тип> * <имя> [ ] = {<список инициализации>}
Примеры:
int i = 1, j = 1 , k= 2, l = 3, m = 4 ;
int * ipMas[10]; // массив указателей на int без инициализации
int * ipMas[]={&j,&k,&l,&m}; // массив указателей на int с
Работа с массивами указателей:
ipMas[2] = &i; // Адресация ipMas[2] содержит адрес i
j = *ipMas[3]; // Разыменование j = l
ipMas[2] = &i; // Адресация ipMas[2] содержит адрес i ( i = 4 )
i = *(ipMas[3]); // Разыменование i = l ( i = 4 )
pInt = ipMas[2] ; // Новый указатель
*pInt = 5; //Получим i = 5
Массивs указателей используются для передаче строк параметров при использовании аргументов командной строки (СМ).
int main(int argc,char* argv[],char* env[]){…};

ЛР №3 Аргументы командной строки
Аргументы командной строки используются для передачи параметров в
программу при ее запуске (МУ, DOC).
Они задаются в качестве параметров функции main. мы ох рассмотрим в ЛР № 5 при изучении функций. Два из этих параметров являются массивами на указатели типа char ( параметры и переменные окружения) (СМ).

ЛР №3 Многомерные массивы (1)
Массив, в котором задано более одной размерности называется многомерным
(двумерным, трехмерным и т.д.) (МУ, DOC). При описании многомерных массивов указывается несколько размеров:
<тип> <имя> [=<размер – выражение1> ]… [=<размер – выражение2> ]…
Пример:
int MasD[10][5]; // двумерный массив 10*5
Каждый из индексов многомерного массива задается в пределах от 0 до значения размер (у нас в примере: 0-0 и 0-4 ). При работе с индексной переменной многомерного массива переменная с индексом задается так:
<имя массива> [=<индекс 1> ][<индекс 2> ]…
Примеры переменных с индексами многомерных массивов:
MasD[1][2] = 6; // берем элемент с индексами 1 и 2
MasD[i][i+1] = 6; // берем элемент с индексами i и i+1
Инициализация многомерных массивов проводится построчно.
<тип> * <имя> [=<размер - выражение>] = {{<список инициализации1 >},…{<список инициализации2>}, …};
Примеры инициализации многомерных массивов:
int C[3][6] ={ { 1,2,3,4,5,6}, { 1,2,3,4,5,6},{ 1,2,3,4,5,6} };
int D[3][6] ={ { }, {},{ } }; // Массив пустой

ЛР №3 Многомерные массивы (2)
Печать многомерного массива через указатель:
int MMas [3][3]={{11,12,13},{21,22,23},{31,32,33}};
int * pMas=
(int *)MMas;
for (int i =0 ; i < 3; i++) // циклы печати
for (int j =0 ; j < 3; j++)
{ printf("%d - %d = %d \n",i,j, MMas[i][j] ); // Правильно
printf("%d - %d => %d \n" ,i,j,*((int *)(pMas + i*3 + j )) );};
Вывод: 0 - 0 = 11
0 - 0 => 11
0 - 1 = 12 …
Печать двумерного как одномерного:
int * pMas= (int *)MMas;
for (int i =0 ; i < 9; i++)
printf("%d - %d => %d \n" ,i,*((int *)(pMas + i )) );
Результат:
0 - 1 => 11
1 - 1 => 12
2 - 1 => 13 …

ЛР №3 Динамическая память
Динамическая память (ДП) это область оперативной памяти ОП (СМ),
которую можно временно запрашивать (захватывать) нужного размера и освобождать при необходимости.
Для работы с этой памятью в СИ/СИ++ существует библиотека:
, в которой предусмотрены функции:
malloc ()– захват ДП байтами,
calloc ()– захват ДП блоками
free – () освобождение ДП
realloc ()– переопределение ДП
Для работы с ДП необходимо объявить указатель заданного типа, после работы память нужно освободить, иначе в ОП будет скапливаться "мусор":
Пример захвата и освобождения ОП/ДП:
pDynMas = (int *) malloc(100); // выделение 100 байт ДП
free (pDynMas); // освобождение ДП
В СИ++ захват памяти выполняется оператором new, а освобождение оператором delete
Пример:
int * piDyn = new int; // Выделяется область для одной целой переменной
delete piDyn; // Освобождение по указателю
Для массива в СИ нужно записать:
int *pDynMas = (int *) calloc (10,sizeof(int) ); // 10 блоков по размеру int
free (pDynMas); // освобождение ДП

ЛР №3 Динамические массивы
Использование ДП позволяет работать в СИ/СИ++ с массивами переменной
длины.(МУ, DOC)
Для этого выполняется следующее:
Объявляется указатель такого типа как требуемый массив:
int *pDynMas = (int *) calloc (10,sizeof(int) );// Динамический массив int в // 10 элементов
pDynMas[5] = 10; // работа с динамическим массивом
free (pDynMas); // освобождение ДП по массив
Если используется цикл, то можно заполнить ДП так:
PtrMas = (int *)malloc(sizeof (int)*5);
for ( int k = 0 ; k < 5 ; k++)
PtrMas[k] = k + 10; заполнение массива от 10 до 15
int l = PtrMas[3] ; // l = 13 – проверка заполнения
free(PtrMas); };
Печать динамического массива:
for ( int k = 0 ; k < 5 ; k++)
printf("PtrMas[%d] = %d\n",k, PtrMas[k] );// Или через указатель
printf("PtrMas[%d] = %d\n",k, *(PtrMas + k) );} ;free(PtrMas);

ЛР №3 Массивы и функции
Передача массивов в функции будет рассмотрена в ЛР№5 (СМ)(МУ,
DOC) (СМ)
Для передачи в функцию массива необходимо передать в нее в качестве параметра указатель (СМ) на этот массив и отдельно его размер и, если необходимо, то и размерность массива и размер по каждому измерению.

ЛР №3 Указатели и функции
Передача массивов в функции будет рассмотрена в ЛР№5 (СМ)(МУ,
DOC)
Главное: если мы хотим в функции изменять значения переменной, то для этого необходимо передавать в эту функцию в качестве параметра указатель на эту переменную, так как в СИ передача параметров выполняется по ЗНАЧЕНИЮ!!!

ЛР №3 Контрольные Задания
Массивы и указатели: (СМ) (СМ) (МУ, DOC) ЛР№3 Теория (СМ)
Описания
массивов (СМ (МУ, DOC) - п.п 5.2
Ввод массива (СМ) (МУ, DOC) п.п 5.3
Печать массива столбиком (СМ (МУ, DOC) - п.п 5.3,4
Сумма элементов массива (СМ (МУ, DOC) п.п 5.3
Минимум в массиве (СМ)(МУ, DOC) - п.п 5.5
Инициализация и суммы положительных и отрицательных(СМ (МУ, DOC) - п.п 5.6
Указатель для минимального элемента массива и печать (СМ (МУ, DOC) - п.п 5.7
Запоминание в массиве суммы ряда и печать (СМ (МУ, DOC) п.п 5.8
Описание двумерных массивов (СМ (МУ, DOC) - п.п 5.10
Заполнение и сумма в динамическом массиве из 10-ти элементов (СМ) - п.п 5.9
Д.Т. Умножение матриц С = А*В (n*m) и их печать. (СМ) (МУ, DOC)
Д.Т. Ввод вывод двумерного массива (СМ)(МУ, DOC) (СМ) (МУ, DOC)
Д.Т. Максимум в массиве в двумерном массиве и номера (СМ) (МУ, DOC)
Д.Т. Программная инициализация двумерного массива (СМ) (МУ, DOC)
Д.Т. Печать в виде матрицы (СМ) (МУ, DOC)
Д.Т. Массив максимумов в матрице по строкам/столбцам. (СМ) (МУ, DOC)

ЛР №3 Ввод массива
Массивы и указатели (МУ, DOC)
int MasInp[3]; // Массив для
// ввода
printf("Введите
целый массив размером %d \n", sizeof(MasInp)/sizeof(int));
for (int k = 0 ; k < (sizeof(MasInp)/sizeof(int)) ; k++ ) {
printf("\nВведите элемент MasInp[%d]:", k);
scanf("%d" , &MasInp[k]); //ввод
} ;

ЛР №3 Печать массива
// Распечатка введенного массива
printf("Массив размером %d: \n", sizeof(MasInp)/sizeof(int));
for (int k = 0 ; k < (sizeof(MasInp)/sizeof(int)) ; k++ ) {
printf("\nЭлемент MasInp[%d] = %5d", k,MasInp[k]); };
printf("\n"); ;
В результате получим:
Элемент массива MasInt[ = 0 ] = 1
Элемент массива MasInt[ = 1 ] = 2
Элемент массива MasInt[ = 2 ] = 3
Элемент массива MasInt[ = 3 ] = 4
Элемент массива MasInt[ = 4 ] = 5

ЛР №3 Динамический массив-rand() ДСЧ
Программа и блок-схема
#include
#include
// Выделение памяти под
массив 10 элементов //int указатель PtrMas
int *PtrMas = (int *)malloc(sizeof(int)*10);
// Цикл заполнения случайными числами
for ( int k = 0 ; k < 10 ; k++) {
PtrMas[k] = rand(); //Зfносим Число от 0 до 32767- RANDMAX
// Печать элемента
printf("Случайное число № %d. = %d\n",
k,PtrMas[k] ); };
free(PtrMas); //
ДСЧ – Датчик случайных чисел!!! (функция rand в библиотеке stdlib.h)

ЛР №3 Примеры и задания
Описания массивов (СМ) (МУ, DOC).1
Ввод массива (СМ) (МУ, DOC).2
Печать
массива столбиком (СМ)(МУ, DOC).2
Сумма элементов массива (СМ)(МУ, DOC).3
Максимум/минимум в массиве (СМ)(МУ, DOC).4
Суммы положительных и отрицательных элементов массива (СМ)(МУ, DOC).5
Указатель на массив (СМ)(МУ, DOC).6
Вычисление суммы ряда и запоминание в массивах во X и Z. (СМ)(МУ, DOC).7
Сортировка инициализированного массива по возрастанию/убыванию (СМ)(МУ, DOC).8
Динамический массив Заполнение случайными числами – 10 (СМ1 ,СМ2)(МУ, DOC).9
Д.Т. Ввод вывод двумерного массива (СМ)(МУ, DOC)
Д.Т. Максимум в массиве в двумерном массиве (СМ)(МУ, DOC)
Д.Т. Программная инициализация двумерного массива
Д.Т. Печать в виде матрицы
Д.Т. Массив максимумов в матрице по строкам/столбцам. (СМ)(МУ, DOC)
Д.Т. Умножение матриц С = А*В (n*m) и их печать. (СМ)(МУ, DOC)

ЛР №3 Поиск минимума в массиве
// Начальные условия цикла поиска минимума
int MasInt
[] = {1,22,3,-4,5,4,0};
int NumMin = 0;
int Min = MasInt[0];
int RazmMin = sizeof(MasInt)/sizeof(int);
for ( int i = 1; i < RazmMin; i++)
if ( Min > MasInt[i])
{ Min = MasInt[i]; NumMin = i; };
// вывод результата
printf("\nВ массиве Min= %d его номер N = %d \n", Min ,NumMin);
int * pMin; // Указатель на int
pMin = &MasInt[NumMin];printf("\Печать c указателем = %d \n", *pMin);
Получим в результате:
В массиве Min= -4 его номер N = 3
Печать c указателем = -4

ЛР №3 Частичные суммы в массиве
Программа фрагменте:
double MasD[] = {3.0 , -5.1, 1.0
, -7.2};
double SumPlus = 0.0;
double SumNeg = 0.0;
int Razm = sizeof(MasD)/sizeof(double);
for (int i =0 ; i < Razm ; i++)
{ if (MasD[i] > 0.0) SumPlus+=MasD[i];
else SumNeg+=MasD[i]; };
// Вывод результата
printf("\nСумма положительных = %lf \n", SumPlus);
printf("Сумма отрицательных = %lf \n", SumNeg);
В результате получим:
Сумма положительных = 4.000000
Сумма отрицательных = -12.300000

ЛР №3 Сортировка массива
int MasSort[]= {3,5,11,0,2}; // Блок-схема (СМ). Алгоритм(СМ)
printf("Массив MasSort до
сортировки размером %d: \n", sizeof(MasSort)/sizeof(int));
int RazmSort = sizeof(MasSort)/sizeof(int);
for (int k = 0 ; k < (sizeof(MasSort)/sizeof(int)) ; k++ ) {
printf("\nЭлемент MasSort[%d] = %5d", k,MasSort[k]); };
printf("\n");
// Сортировка
for (int k =0; k< (RazmSort- 1) ;k++ ) {
for (int i =0; i< (RazmSort- 1) ;i++ ){
if (MasSort[i] <= MasSort[i+1]) // Убывание
{// Swap int Temp;
Temp = MasSort[i];
MasSort[i] = MasSort[i+1];
MasSort[i+1] = Temp; } ; }; };
printf("Массив MasSort после сортировки размером %d: \n", // Печать
sizeof(MasSort)/sizeof(int));
for (int k = 0 ; k < (sizeof(MasSort)/sizeof(int)) ; k++ ) {
printf("\nЭлемент MasSort[%d] = %5d", k,MasSort[k]); };

ЛР №3 Сортировка. Блок-схема
Программа (СМ). Алгоритм(СМ)

ЛР №3 Сортировка. Убывание. Алгоритм.
Программа сортировки (СМ). Блок-схема (СМ). Сравнение попарно и замена.
Исходный
массив
Первый
Проход – нет порядка.
Второй
Проход – порядок (убывание)есть
Нужно
Получить

ЛР №3 Сумма в массиве
Подсчет суммы в массиве (МУ, DOC):
// Описание массива
int Mas[5]
= { 1,2,3,4,5}; // элементы с индексами 0 ... 4
// Простой цикл с массивом
int SumMas = 0;
for (int k = 0 ; k < 5 ; k++ )
SumMas = SumMas + Mas[k] ;
printf("\nСумма массива SumMas = %d \n" , SumMas);
Печать суммы в массиве
Сумма массива SumMas = 15

ЛР №3 Сумма в ряда
float MasF[10]; float MasX[10]; // Блок-схема (СМ)
float x0=0.0F; float
delx = 0.1F; float x = x0;
for ( int k=0 ; k < 10;k++)
{ x = x + delx;
float sum = 1.0f; // Начальное значение для переменной сумирования
float step = x; // Начальное значение для степени х
float fac = 1.0f; // Начальное значение для переменной текущего факториала
float Count = 1.0f;
float eps = 0.001F; // точность, с которой будет расчитана сумма ряда.
while ( step/fac > eps ) // проверка точности вычисления
{ sum+= step/fac; // суммирование членов ряда
Count += 1.0f ; // n - порядковый номер члена ряда
fac *= Count; // fac = fac * Count; - промежуточный факториал
step = step*x; }; // в степени xprintf(" Ряд - exp = %f Функция из библиотеки = %f Аргумент x = %f\n",sum , exp( x), (x ));
MasF[k]= sum;
MasX[k]= x; };

ЛР №3 Блок схема Суммы ряда
Блок-схема программы суммы ряда(СМ)

ЛР №3 Указатели на функции
Эта тема будет рассмотрена в разделе ЛР №
5(МУ, DOC)

ЛР №4 Теория Строки
Строки в СИ/СИ++ (МУ)(DOC) (VS –ЛР № 4)
Описание и инициализация
строк (СМ) (МУ)(DOC)
Понятие строки (СМ1, СМ2).
Операции со строками (СМ). Длина строки (СМ) (МУ)(DOC)
Библиотека функций для строк
(СМ) (МУ)(DOC)
Массивы строк и указателей на строки (СМ) (МУ)(DOC)
Указатели на строки (СМ)
Копирование и сложение строк (СМ) (МУ)(DOC)
Ввод вывод строк (СМ)
Манипуляции со строками (СМ) (МУ)(DOC)
Преобразование строк (СМ)
Динамические строки (СМ) и массивы строк (СМ) (МУ)(DOC)
Преобразования чисел/данных в строку и обратно (СМ) (МУ)(DOC)
Анализ символов (СМ) (МУ)(DOC)
Сравнение строк (СМ) (МУ)(DOC)
Трансляция строк (СМ), Функции sprintf и sscanf (СМ)
Аргументы командной строки (СМ) (МУ)(DOC)
Примеры (СМ) (МУ)(DOC)
Контрольные задания (СМ) (МУ)(DOC)

ЛР №4 Теория Понятие строки
Строки в СИ/СИ++ (МУ)(DOC)
Строка(String) используется для хранения символьных
данных и текстов. В СИ/СИ++ в стандартной библиотеки она описывается как одномерный символьный массив:
char Name[10]; // Описана строка Name максимальной длинны 9 символов
Для работы со строками подключается специальная библиотека:
#include
Строки с программах на СИ должны завершаться нулевым символом ('\0'). Такая строка называется: "Null Terminated String" (Оканчивающаяся нулем).Только при этом условии библиотечные функции будут работать без ошибок. Строка:
char Family[10] ="Пример"; // Описана строка Family и инициализирована
Оставшаяся (незаполненная часть ) символьного массива не будет использоваться. Поэтому желательно в программах использовать динамические строки (СМ). В этом случае можно изменить размер динамического массива (realloc) и поместить в него строку большего размера чем первоначальный.
Операции(СМ) над строками выполняются только специальными функциями из стандартной библиотеки(
(СМ).
).

ЛР №4 Описание и инициализация строк
Строки в СИ/СИ++ (МУ)(DOC)
Для использования в программе строка
должна быть заполнена. Это может быть сделано при описании (Инициализация) или копировании строк.
Инициализация строки при описании:
char Str [20] = "Пример строки в СИ/СИ++!!"; // Инициализация
Заполнение строки при копировании:
strcpy(Str,"Строка заносимая в программе!");//Заполнение копированием
Можно заполнить строку посимвольно:
char Family[20]; // Описана строка максимальной длинны 19 символов
Str1 [0] = 'П';
Str1 [1] = 'р';
Str1 [2] = 'и';
Str1 [3] = 'м';
Str1 [4] = 'е';
Str1 [5] = 'р';
Str1 [6] = '\0'; // Нулевой символ заносится в этом случае отдельно в конце текста
Занося нулевой символ в середину строки мы ее обрезаем:
Str1 [4] = '\0'; // Строка принимает значение "Прим"

ЛР №4 Операции со строками
Строки в СИ/СИ++ (МУ)(DOC)
Операции со строками в СИ
выполняются специальными функциями из стандартно библиотеки
(СМ):
Копирование строк (strcpy)
strcpy(family, "Петров"); // копирование
strcpy(Name, "Иван"); // копирование
Сложение строк (strcat – конкатенация строк)
strcat (family , " "); // пробел между строками в ФИО
strcat (family , Name); // сложение строк
printf("Печать строки \"%s\"=\n",family); // Печать
Вычисление длины строки динамически (функция - strlen)
printf("Длина строки family после заполнения %d\n", strlen(family));
Общий размер выделенной памяти под строку можно получить использую оператор sizeof(<имя строки>). Это значение будет неизменным в программе.
printf("Длина строки family после описания %d\n", sizeof(String)); Разница между strlen и sizeof заключается в том, что функция вычисляет длину строки динамически, проверяя наличие нуль символа. При его отсутствии результат будет неправильным.

ЛР №4 Библиотека функций для строк
Строки в СИ/СИ++ (МУ)(DOC)
Для работы со строками
есть специальная библиотека функций
.
Кроме рассмотренных функций (СМ):
strcpy – копирования
strcat – сложения
strlen – динамического определения длины строки
Можно выделить также следующие:
strcmp – сравнение строк
strchr – поиск символа в строке
strncpy – копирование n символов
strncat – сложение символов
strupr – преобразование к верхнему регистру (ПРОПИСНЫЕ)
strlwr – преобразование к верхнему регистру (строчные)
strdup – дублирования строк
strtok- выделение подстрок по символоам. и др.
Многое функции библиотеки в новых версиях СП выполнены в защищенном варианте: strcpy_s, strcat_s – с контролем затирания памяти.

ЛР №4 Массивы строк и указателей на строки
Строки в СИ/СИ++ (МУ)(DOC)
Массив строк –
это двумерный массив типа char, в котором в каждой строке должен присутствовать нулевой символ ('\0'). Если такой массив инициализируется, то нулевой символ обеспечивается компилятором:
char MasStr[5][15]={"Строка0","Строка1","Строка2","Строка3","Строка4"};
При работе с таким массивом индексное выражение MasStr[i] является строкой (точнее указателем на строку).
// Печать массива строк
for (int i = 0; i < 5 ; i++ )
printf ("%s\n",MasStr[i]);
Массив указателей на строки – это массив указателей на тип char (инициализируем его):
char str1[10] ="Str1";
char str2[10] ="Str2";
char str3[10] ="Str3";
char * MasPtrStr[3]={str1,str2,str3}; // Инициализация строками
// Печать массива указателей на строки
for (int i = 0; i < 3 ; i++ )
printf ("%s\n",MasPtrStr[i]);

ЛР №4 Указатели на строки
Строки в СИ/СИ++ (МУ)(DOC)
Указатели на строки описывается
как обычный указатель на char:
strcpy(family, "Петров"); // копирование
strcpy(Name, "Иван"); // копирование
strcat (family , Name); // сложение строк
// Описание указателя на строку
// Вычисление указателя на family
char * PtrStr = family;
printf("Печать строки по указателю(family) \"%s\" \n",PtrStr);
// Новое вычисление указателя на Name
PtrStr = Name;
printf("Печать строки по указателю(Name) \"%s\" \n",PtrStr);
Результат печати:
Печать строки по указателю(family) "Петров Иван"
Печать строки по указателю(Name) "Иван"

ЛР №4 Теория 6. Ввод вывод строк
Строки в СИ/СИ++ (МУ)(DOC)
Для ввода и
вывода строк используются форматированный ввод/вывод (СМ)
Для вывода %s[-]<число1> - общее поле.<число2> минимум для вывода из строки:
char Str10[ 20 ] = {"Пример"}; // строка!
printf("Строка -> '%s' \n", Str10); // Выводит все
printf("Строка -> '%10s' \n", Str10); // Поле вывода 10
printf("Строка -> '%-10s' \n", Str10); // Поле вывода -10 сдвиг вправо
printf("Строка -> '%3.20s' \n", Str10); // Поле вывода точность - 20
printf("Строка -> '%-3.4s' \n", Str10); // Поле вывода 4 символа
Строка -> 'Пример'
Строка -> ' Пример'
Строка -> 'Пример '
Строка -> 'Пример'
Строка -> 'Прим'
Ввод: 1234567890
scanf ("%s" , Str10);
scanf ("%5s" , Str10); // Поле 5 символов
Строка -> '1234567890'
Строка -> '12345'
строки

ЛР №4 Теория 7. Копирование и сложение строк
Строки в СИ/СИ++ (МУ)(DOC)
Для копирования
и сложения строк предусмотрены функции библиотеки (СМ)
string.h> :
strcpy – копирования строк
strcat – сложения строк
strтcpy – копирования строк ограниченной длины
strтcat – сложения строк ограниченной длины
Примеры:
char Fam[14] ;
strcpy_s(Fam , "Петров");
printf ( "Строка Fam = %s имеет длину - %d \n", Fam , strlen (Fam));
strcpy_s(Fam , "Спиридонов");
printf ( "Строка Fam = %s имеет длину - %d \n", Fam , strlen (Fam));
printf ( "Максимальный размер Fam = %s равен - %d \n", Fam , sizeof (Fam)/sizeof (char) );
Результат:
Строка Fam = Петров имеет длину - 6
Строка Fam = Спиридонов имеет длину - 10
Максимальный размер Fam = Спиридонов равен - 14

ЛР №4 Теория 8. Манипуляции со строками
Строки в СИ/СИ++ (МУ)(DOC)
Функции работы со
строками включены библиотеку
(СМ). Они могут:
Сравнивать строки (СМ)
Выполнять поиск в строке (СМ)
Преобразовывать строки - регистровые (СМ)
Преобразование в числа строку и обратно (СМ)

ЛР №4 Теория 11. Регистровые преобразования
Преобразование строк к нижнему или верхнему регистру в
СИ/СИ++ (МУ)(DOC) выполняется функциями strupr (верхний)и strlwr (нижний):
Пример:
#include
#include
char string5[10] = "";
strcpy( string5 , "Sample");
printf( " %s\n", _strupr ( string5 ) );
setlocale( LC_ALL, "" );
strcpy( string5 , "Пример!"); // русские не преобразовывает
без setlocale( LC_ALL, "" )
printf( " %s\n", strupr ( string5 ) );
printf( " %s\n", strlwr ( string5 ) );
Результат получим такой:
SAMPLE
ПРИМЕР!
пример!

ЛР №4 Теория 12. Преобразования чисел/данных в строку
Строки в СИ/СИ++ Преобразования чисел/данных в
строку и обратно (СМ) (МУ)(DOC)
Для преобразования в строку чисел и обратно используются следующие функции:
atoi -преобразование строки в число типа int (целое)
itoa - преобразование числа типа int в строку
atof - преобразование строки, в представляемое ей число типа float
gcvt- преобразование числа типа double в строку
Примеры:
int iVar = atoi("125");// atoi и itoa
printf( "Строку в целое 125 => %d\n", atoi("125") );
char sVar[20]="";
printf( "Целое в строку 5 => %s\n", itoa ( 15 , sVar , 10) );
double dVar = atof("10,5") ; //
printf( "Строку в вещественное 10.5 => %10.2fl\n", dVar );
dVar = 15.7; // atof и gcvt
printf( "вещественное в строку 15.7 => %s \n", _gcvt (dVar,5,sVar) ); // gcvt
Получим:
Строку в целое 125 => 125
Целое в строку 5 => 15
Строку в вещественное 10.5 => 10,50
вещественное в строку 15.7 => 15,7

ЛР №4 Теория 10. Поиск в строк е
Поиск в строке(МУ)(DOC) выполняется функцией strchr.
strrchr – возвращает адрес первого вхождения символа в строке
strrchr - возвращает адрес последнего вхождения символа в строке
strspn, strcspn – позволяют найти подстроку в строке
Примеры:
char Name5[24] = "Василий"; // Посмотреть в отладчике
// strrchr - первое вхождение "и" в слове Василий
printf ("Строка исходная = %s Часть с первым найденным \"и\" = %s \n" , Name5 , strchr(Name5 , 'и') );
// strrchr - последнее вхождение "и" в слове Василий
printf ("Строка исходная = %s Часть с последним найденным \"и\" = %s \n" , Name5 , strrchr(Name5 , 'и') );
Результат поиска 'и':
Строка исходная = Василий Часть с первым найденным "и" = илий
Строка исходная = Василий Часть с последним найденным "и" = ий
Примеры
int num = strspn(Name5,"Ва"); // num = 2
num = strcspn(Name5,"ил"); // num = 3

ЛР №4 Теория 11. Динамические строки
Строки в СИ/СИ++ (МУ)(DOC)
Динамические строки используют динамическую
память (malloc, calloc и free)(СМ):
#include
// в начало
// Динамическая память для строк
char * pStr = (char *) malloc( 10); // malloc
strcpy( pStr , "Динамика!" );
printf ("Динамическая память - %s \n" , pStr);
// Освобождение памяти
free (pStr);
pStr = (char *) calloc (strlen("Новая память!") + 1 , sizeof(char)); // calloc
strcpy( pStr , "Новая память!" );
printf ("Новая память - %s Длиной => %d \n" , pStr, strlen ("Новая память!"));
free (pStr); // Освобождение памяти
Получим:
Динамическая память - Динамика!
Новая память - Новая память! Длиной => 13

ЛР №4 Теория 11. Массивы строк (1)
Строки в СИ/СИ++ (МУ)(DOC)
Заполнение динамического массива
при вводе строки("Студенты изучают СИ"):
int Razm;
printf ("Введите размер массива строк: \n" );
scanf ("%d", &Razm);
char * pStrMas =(char *) calloc (Razm , sizeof(char) * 20); // 20 символов 1 строка
printf ("\nВведите строки массива [%d]: \n" , Razm );
for (int i =0 ; i < Razm ; i++ )
// scanf ("%s", pStrMas + i * 20);
scanf ("%s", &pStrMas[ i * 20]);
for (int i =0 ; i < Razm ; i++ ) // Распечатка
printf ("Строки массива % d - %s\n", i , &pStrMas[ i * 20] );
Результат
Введите размер массива строк:
3
Введите строки массива [3]:
Студенты
изучают
СИ

ЛР №4 Теория 11. Массивы строк (2)
Строки в СИ/СИ++ (МУ)(DOC)
Слияние в одну
строку из введеноого массива :
char * pBigString = (char *) malloc( nMasSize + 2 + Razm );
// Добавим Пробелы воск. знак и нуль символ
pBigString[0] = '\0';
for (int i =0 ; i < Razm ; i++ )
{ strcat( pBigString , &pStrMas[ i * 20]);
strcat( pBigString , " ");
};
strcat( pBigString , "!");
printf ("Большая строка - %s \n" , pBigString);
free (pBigString);
Получим:
Большая строка из введенного массива- Студенты изучают СИ !

ЛР №4 Теория 13. Проверка символов
Проверка типа символов (МУ)(DOC). Для проверки символов используются
функции (они возвращают истина или ложно):
Функции, используемые для классификации символов, приведены ниже (библиотека
):
isalnum(c) isalpha(c) или isdigit(c) есть истина
isalpha(c) isupper(c) или islower(c) есть истина
isdigit(c) десятичная цифра
islower(c) буква нижнего регистра
…
isxdigit(c) шестнадцатеричная цифра
Пример:
if (isdigit( '5')) printf( "Символ 5 -> цифра\n");
if (isalpha( 'm')) printf( "Символ m -> буква\n");
Результат:
Символ 5 -> цифра
Символ m -> буква

ЛР № 4 Примеры. Сортировка строк
Пузырьковая сортировка массива (СМ) (МУ)(DOC)
#define RazmMas 5
// Массив
// Массив строк инициализируется в программе фамилиями
char StrMas[RazmMas][10]={"Сидоров", "Алетров", "Иванов", "Жучков" , "Акулов"};
// Сортировка
for (int k = 0 ; k < RazmMas - 1 ; k++)
for ( int i =0 ; i < RazmMas - 1; i++ )
{ if ( strcmp(&StrMas[i][0] , &StrMas[i +1][0]) > 0 ) // Для убывания
// if ( strcmp(&StrMas[i][0] , &StrMas[i +1][0]) < 0 ) // Для возрастания
// Обмен если условие сортировки не соблюдается
// Swap без функции
strcpy(TempStr , &StrMas[i][0] );
strcpy(&StrMas[i][0] , &StrMas[i+1][0]);
strcpy( &StrMas[i+1][0] , TempStr); };

ЛР №4 Теория 14. Сравнение строк
Строки в СИ/СИ++ (МУ)(DOC)
Сравнение строк выполняется функцией
strcmp:
#include
char Name[24] = "Василий"; // Посмотреть в отладчике нуль-терм.
setlocale( LC_ALL, "" ); // нужно подключить locale.h
if ( strcmp(Name , "Василий") == 0) printf ("Строки равны (идентичны)! \n" );
if ( strcmp(Name , "Алексей") > 0) printf ("Строки не равны (1-я > 2- й)! \n" );
if ( _strnicmp("Name" , "NAME" , 3 ) == 0) printf ("Строки равны (_strnicmp - идентичны)! \n" );
Получим:
Строки равны (идентичны)!
Строки не равны (1-я > 2- й)!
Строки не равны (1-я < 2- й)!
Строки равны (идентичны)!
Строки равны (_strnicmp - идентичны)!

ЛР №4 Теория Аргументы командной строки (1)
(МУ)(DOC) При запуске программы в можно
задавать параметры (аргументы) командной строки. Их общее число не должно превышать 128 байт.
Параметры программы в режиме отладки задаются в характеристиках проекта ПУТЬ: ПРОЕКТ->Свойства проекта-> Свойства конфигурации ->Отладка ->Аргументы Команды:
Отдельные параметры разделяются пробелами. ОС сама, перед вызовом программы устанавливает нужные значения количества и адреса строк массива указателей (argc, argv).
Для доступа к параметрам главная функция (main) содержит следующий заголовок:
void main(int argc, char * argv)
где: argc – целая переменная задающая число параметров (нулевой параметр всегда имя программы), а argv- массив указателей на строки параметров.
Распечатать параметры можно так:
printf("Параметры: число = %d\n", argc);
int i;
for (i = 0; i < argc; i++)
printf("%s\n", argv[i]); Получим:
D:\LR4_OP\Debug\LR4_OP_0.exe
aaa
333

ЛР №4 Теория Аргументы командной строки (2)
Аргументы командной строки и окружения. (МУ)(DOC)
При необходимости у главной функции может быть задан и третий параметр, который содержит массив указателей на переменные окружения ОС (envvar):
void main(int argc, char * argv[], char * envvar[])
Он может быть распечатан так:
// Переменные окружения программы
printf("Переменные окружения: \n");
for (i = 0; envvar[i] != NULL; i++)
printf("%d. %s\n", i,envvar[i]);
printf("\n");
Получим в результате:
Переменные окружения:
0. ALLUSERSPROFILE=C:\ProgramData
1. AMDAPPSDKROOT=c:\Program Files (x86)\AMD APP\
2. APPDATA=C:\Users\User\AppData\Roaming …

ЛР №4 Теория Трансляция строк
Для выделения (трансляции – "парзинга" -parse) используется функция strtok
(МУ)(DOC)
char strText4[] = "красный,зеленый,желтый\n";
char seps[] = ","; // Допустимый разделитель: (запятая
char *token; // Указатель на массив подстрок
printf( "Исходная строка:%s\n", strText4 ); // Разделители не видны
printf( "Подстроки (tokens):\n" );
// Получение первой подстроки:
token = strtok(strText4, seps ); //
while( token != NULL ) { // проверка наличия новых подстрок
// Вывод подстрок в цикле
printf( " %s\n", token );
token = strtok( NULL , seps ); } // Новая подстрока :
Получим результат:
Исходная строка:красный,зеленый,желтый
Подстроки (tokens):
красный
зеленый
желтый

ЛР №4 Теория 16. Функции sprintf и sscanf
Строки в СИ/СИ++ (МУ)(DOC)
Функции форматированного ввода
вывода (СМ)
Для работы со строками можно использовать специальные функции форматированного ввода в строку (sprintf) и вывода из строки (sscanf):
Пример:
char Sprint[50]; // Строка для вывода (куда выводим)
char sFam[]="Петров";
double dPerem = 55.5;
sprintf(Sprint,"Строка:sFam=%s_dPerem=%fl",sFam, dPerem); // Вывод в строку
printf("Строка Sprint после sprintf: %s\n",Sprint);
char SpInpt[50]; // Строка для ввода (куда вводим)
sscanf(Sprint,"%s",SpInpt); // Ввод из строки
printf("Строка SpInpt введенная sscanf из строки Sprint: %s\n",SpInpt);
Результат:
Строка Sprint после sprintf: Строка:sFam=Петров_dPerem=55,500000l
Строка SpInpt введенная sscanf из строки Sprint: Сторка:sFam=Петров_dPerem=55,500000l

ЛР №4 Примеры Общий
Строки в СИ/СИ++ (МУ)(DOC)
Описание и инициализация строк (МУ) (СМ).1
Ввод вывод
строк (МУ) (СМ).2
Манипуляция со строками и в строке (МУ) (СМ).3
Динамические строки и их дублирование(СМ(МУ)).4
Преобразование данных в строку и обратно (МУ) (СМ).5
Сортировка строк (МУ) (СМ).6
Выделение подстроки (МУ) (СМ).7
Обмен строк одинакового размера(МУ) (СМ).8
Выделение подcтрок – parsing (МУ) (СМ).9
Регистровые преобразования (МУ) (СМ).10
Формирование действительного числа с точкой (МУ) (СМ).11
Поиск и замена символов в строке(МУ) (СМ).12

ЛР №4 Выделение подстроки
Подстрока в строке. (МУ)(DOC). Задан начальный символ(begChar) и размер подстроки
(sizeSubstr):
// Выделение подстроки
int begChar =4 ; // Начальный символ подстроки
int sizeSubstr = 9; // длина подстроки
char strText5[] = "10123456789 123456789_123456789"; // Исходная строка
// Выделение динамической памяти с запасом на размер подстроки
char * pSubstr = (char *) malloc ( sizeof (strText5) + sizeSubstr +1); strncpy( pSubstr , strText5 + begChar, sizeSubstr + 1 );
pSubstr[5] = '\0'; // Сознательное укорачивание подстроки до 5-ти символов
printf( "Строка: %s Подстрока = %s c =%d число=%d\n",strText5, pSubstr ,begChar,sizeSubstr );
Результат получим такой:
Строка: 10123456789 123456789_123456789 Подстрока = 34567 c = 4 число= 7

ЛР №4 Примеры Обмен строк
(МУ)(DOC) Для обмена используем дополнительный буфер строки (TempStr)
char TempStr[40];
char
S1[40] ="Первая строка";
char S2[40] ="Вторая строка";
printf( "Перед обменом: %s - %s\n", S1 , S2 );
strcpy(TempStr , S1 ); // Swap
strcpy(S1 , S2);
strcpy( S2 , TempStr);
printf( "После обмена: %s - %s\n", S1 , S2 );
Результат получим такой:
Перед обменом: Первая строка - Вторая строка
После обмена: Вторая строка - Первая строка

ЛР №4 Примеры Общий
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Описание и инициализация строк (МУ)
)(DOC) (СМ).1 п.п 3.2
Ввод вывод строк (МУ) (СМ).2 п.п 3.4
Манипуляция со строками и в строке (МУ) )(DOC)(СМ).3 п.п 3.3
Динамические строки и их дублирование(СМ) )(DOC)(МУ)).4 п.п 3.8,13
Преобразование данных в строку и обратно (МУ) )(DOC) (СМ).5 п.п 3.7
Сортировка строк (МУ) )(DOC)(СМ).6 п.п 3.12
Выделение подстроки (МУ) )(DOC) (СМ).7 п.п 3.10, п.п 4.2
Обмен строк одинакового размера(МУ) )(DOC) (СМ).8 п.п 4.3
Выделение подcтрок – (МУ) )(DOC) (СМ).9 п.п 4.2
Регистровые преобразования (МУ) )(DOC)(СМ).10 п.п 3.6
Формирование действительного числа с точкой (МУ) (DOC) 11 п.п 4.7
Поиск и замена символов в строке(МУ) (DOC).12 п.п 4.4, 5.3

ЛР №4 Задание Общий
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Создание большой строки (МУ)(DOC) (СМ).K1 п.п
5.1
Строка с инициалами (МУ)(DOC) (СМ).K2 п.п 5.2
Замена символов и подсчет в строке (МУ)(DOC) (СМ).K3 п.п 5.3
Ввод и вывод массива строк (МУ)(DOC) (СМ).K4 п.п 5.4
Изменение порядка символов в строке (МУ)(DOC) (СМ).K5 п.п 5.5
Динамические строки (МУ)(DOC) (СМ).K6 п.п 5.6
Д.Т. Функция SubString (МУ)(DOC) (СМ).K7
Создание функции SwapString для строк по длине (МУ)(DOC) (СМ).K8
Д.Т. Сортировка массива строк (МУ)(DOC) (СМ).K1
Д.Т. Поиск минимума и максимума в массиве строк(МУ)(DOC)СМ).K1
Д.Т. Замена подстроки в строке (МУ)(DOC) (СМ).K1
Д.Т. Функция сравнение строк (МУ)(DOC) (СМ).K1
Д.Т. Создание функции SwapString (МУ)(DOC) (СМ).K1

ЛР №4 Контроль
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Создание большой строки (МУ)(DOC) (СМ).K1 п.п 5.1
Строка
с инициалами (МУ)(DOC) (СМ).K2 п.п 5.2
Замена символов и подсчет в строке (МУ)(DOC) (СМ).K3 п.п 5.3
Ввод и вывод массива строк (МУ)(DOC) (СМ).K4 п.п 5.4
Изменение порядка символов в строке (МУ)(DOC) (СМ).K5 п.п 5.5
Динамические строки (МУ)(DOC) (СМ).K6 п.п 5.6
Д.Т. Функция SubString (МУ)(DOC) (СМ).K7
Создание функции SwapString для строк по длине (МУ)(DOC) (СМ).K8
Д.Т. Сортировка массива строк (МУ)(DOC) (СМ).K1
Д.Т. Поиск минимума и максимума в массиве строк(МУ)(DOC)СМ).K1
Д.Т. Замена подстроки в строке (МУ)(DOC) (СМ).K1
Д.Т. Функция сравнение строк (МУ)(DOC) (СМ).K1
Д.Т. Создание функции SwapString (МУ)(DOC) (СМ).K1

ЛР №4 1. Создание большой строки
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Создание большой строки
(МУ)(DOC) (СМ).K1 п.п 5.1
//Из трех строк, описанных и заранее инициализированных (Name[14], Fam[20], Otch[20]), создать новую строку FIO
char Fam2 [14] ="Большаков";
char Name2[20] ="Сергей";
char Otch2[20]="Алексеевич";
char FIO[56];
// Копирование и слияние без контроля
strcpy(FIO,Fam2);
strcat(FIO, " "); // Нужно для пробела между фамилией и именем
strcat(FIO, Name2);
strcat(FIO, " "); // Нужно для пробела между и именем и отчеством
strcat(FIO, Otch2);
printf ("Фамилия имя и отчество = %s !\n", FIO);
Получим Результат:
Фамилия имя и отчество = Большаков Сергей Алексеевич !

ЛР №4 2.Строка с инициалами
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Строка с инициалами (МУ)(DOC) (СМ).K2
п.п 5.2
#include
…
{
strcpy(FIO,Fam2);
strcat(FIO, " "); // Нужно для пробела между фамилией и инициалами
strncat(FIO, Name2,1);
strcat(FIO, ".");
strncat(FIO, Otch2,1);
strcat(FIO, ".");
printf ("Фамилия имя и отчество = %s !\n", FIO);
//////////////////////////////
system(" PAUSE");
} ;
Получим Результат:
Фамилия имя и отчество = Большаков С.А. !

ЛР №4 3.Замена символов
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Замена символов и подсчет в строке
(МУ)(DOC) .K3 п.п 5.3
// 5.3. Замена символов \"и3лмн№1Лк\" на пробел
char charMas[] = "Лимон лежал на столе № 135";
int RazmS = strlen(charMas);
printf ("Исходная строка =\n%s !\n", charMas);
// Цикл замен
for (int i=0 ;i < RazmS ; i++)
{ switch ( charMas[i] )
{case 'и':
case '3':
case 'л':
case 'м':
case 'н':
case '№':
case '1':
case 'Л':
case 'к':
charMas[i] =' ';
Counter++; break; }; };
printf ("Строка после замены символов \"и3лмн№1Лк\" на пробел\n%s !\n", charMas);
printf ("=\n%s !\n", charMas);
printf ("Число замен=\n%d \n", Counter);
Получим результат:
Исходная строка =
Лимон лежал на столе № 135 !
Строка после замены символов "и3лмн№1Лк" на пробел
о ежа а сто е 5 !
Число замен= 11

ЛР №4 4.Ввод вывод строк (1)
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Ввод и вывод массива
строк (МУ)(DOC) (СМ).K4 п.п 5.4
/////////////////////////////
// Динамический массив строк
/////////////////////////////
#include
…
// 5.4 Ввод массива строк
int MasSize;
printf ("Введите размер массива строк: \n" );
scanf ("%d", &MasSize);
char * pStrArray =(char *) calloc (MasSize , sizeof(char) * 20); // 20 символов - одна строка
printf ("\nВведите последовательно строки массива строк [%d] размером не более 20 символов: \n" , MasSize);
for (int i =0 ; i < MasSize ; i++ )
{ char Buf[80] = "";
// scanf ("%s", pStrMas + i * 20);
scanf ("%s", Buf);
// Контроль длины введенной строки
if (strlen(Buf) > 20)
{ printf ("Введенная строка превышает размер 20 (%d): \n", strlen(Buf) );
i--; }
// scanf ("%s", &pStrArray[ i * 20]);
else
{ strcpy(&pStrArray[ i * 20], Buf );
}; }
printf ("\n" );
// Распечатка массива
printf ("Порядок прямой\n" );

ЛР №4 4.Ввод вывод строк (2)
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Ввод и вывод массива
строк (МУ)(DOC).K4 п.п 5.4
// Распечатка массива
printf ("Порядок прямой\n" );
// Распечатка массива строк
printf ("..........................\n" ); // Рамка
for (int i =0 ; i < MasSize ; i++ )
{ printf ( ". [%d ] . %10s .\n", i , &pStrArray[ i * 20] );
}
// Распечатка массива строк
printf ("..........................\n" ); // Рамка
printf ("Порядок Обратный\n" );
printf ("..........................\n" ); // Рамка
for (int i = MasSize - 1 ; i >= 0 ; i-- )
{
printf ( ". [%d ] . %10s \n", i , &pStrArray[ i * 20] );
};
printf ("..........................\n" ); // Рамка
printf ("\n" );
Получим результат:
Введите размер массива строк:
3
Введите последовательно строки массива строк [3] размером не более 20 символов:
111
222
333
Порядок прямой
..........................
далее (МУ).

ЛР №4 5. Порядок символов
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Изменение порядка символов в строке
(МУ)(DOC) (СМ).K5 п.п 5.5
// 5.5 Изменение порядка символов в строке на обратный
char StrPer[] = "Линейка";
char cTemp;
RazmS = strlen(StrPer); // Размер строки - вычисление
printf ("Исходная строка =\n%s !\n", StrPer);
for (int i = 0 ; i < RazmS/2 ; i++)
{ // Обмен символов (Swap) Крайние символы меняются местами
cTemp = StrPer [ i];
StrPer[ i ] = StrPer[ RazmS - i - 1 ];
StrPer[ RazmS - i -1] = cTemp ; };
StrPer[RazmS] ='\0';
printf ("Результирующая строка =\n%s !\n", StrPer);
Получим результат:
Исходная строка =
Линейка !
Результирующая строка =
акйениЛ !

ЛР №4 6. Динамическая строка
Строки в СИ/СИ++ (МУ)(DOC) (Теория)
Динамические строки (МУ)(DOC) (СМ).K6 п.п
5.6
#include
// 5.6 Динамические строки
{ char FIO[56];
// Копирование и слияние без контроля
strcpy(FIO,"Петров");
strcat(FIO, " "); // Нужно для пробела между фамилией и именем
strcat(FIO, "Петр");
strcat(FIO, " "); // Нужно для пробела между и именем и отчеством
strcat(FIO, "Иванович");
char * pStrD; // 5.6 Указатель на динамическую строку
pStrD = (char *) calloc (40 , sizeof(char) ); // размер 40 символов
//strcpy(StrPer, "Пример!!!");
strcpy (pStrD, FIO);
printf ("Динамическая строка =%s !\n", pStrD);
pStrD[12] = 'Ж';
free(pStrD); }; // Освобождение ДП под строку
Получим результат:
Динамическая строка =Петров Петр Иванович !
Динамическая строка (измененная) =Петров Петр Жванович !

ЛР №5 Теория
Функции (МУ, DOC) через (VS –ЛР № 5)
Понятие функции и их
преимущества (СМ1) (СМ2)
Макросы в СИ и их назначение (СМ).
Описания функций (СМ), прототип (СМ) , заголовочные файлы и формальные параметры (СМ)
Данные в функциях и области видимости, статические данные (СМ)
Параметры функций и их изменение в функциях(СМ)
Вызов функций (СМ), фактические параметры и возврат (СМ)
Завершение функции и тип возврата. Оператор return (СМ)
Void функции (СМ)
Массивы в функциях (СМ)
Указатели и функции(СМ) и передача параметров (СМ)
Рекурсивные функции (СМ)
Проекты и размещение функций (СМ)
Примеры из МУ (СМ) (МУ, DOC)
Задания ЛР №5 (СМ) (МУ, DOC)
Параметры функции main (СМ)
Указатели на функции (СМ)
Встраиваемые функции (СМ)
Переменное число параметров в функциях (СМ) ?
Библиотеки функций и их разновидности и построение(СМ) (МУ, DOC)

ЛР №5 1.Понятие функции (2)
Функция – Это специально оформленный фрагмент программы (СМ), который
можно вызывать по уникальному имени и настраивать на разные значения параметров. (МУ, DOC). - синонимы термина функция: процедура : подпрограмма, метод.
Основные понятия, связанные с функциями:
Описание функций (СМ).
Формальные и фактические параметры функций (СМ).
Прототипы функций (СМ).
Вызовы функций (СМ).
Тело функции (СМ) и возврат из функции. (СМ)
Преимущества, применения функций в программировании:
Неоднократный вызов из разных мест (исключение повторов)
Использование библиотек функций в разных проектах (накопление )
Увеличение обозримости и структурированности программ
Облегчение отладки, за счет уже отлаженных частей программы.

ЛР №5 Описание функции
Описание конкретной функции выполняется один раз и содержит следующее:
Название функции,
уникальное имя в пределах всей программы (проекта).
Тип возврата функции (стандартный или пользовательский).
Список формальных параметров функции
Тело функции – составной оператор
Формальное определение (описание - синоним) функции:
<Описание функции> :=[<Спецификация типа возврата функции>] <Название функции> ([<Список Формальных параметров>]) {<тело функции>};
Простейший пример описания:
// Описание функции суммирования
int Summa (int a , int b)
{ return (a + b);};
И вызовы функции при инициализации и печати:
int k = Summa(1 , 1); // при инициализации переменной или при печати
printf("Результат из функции = %d!\n" , Summa(5 , 5) );

ЛР №5 Параметры функции
Различают следующие виды параметров функций:
Формальные параметры (задаются при описании функции
и используются/доступны только в теле данной функции) и
Фактические параметры (задаются при вызове функции).
Число формальных параметров практически не ограничивается, однако для функций их число желательно минимизировать, для обозримости.
Число и типы фактических параметров должны соответствовать формальным параметрам описания (исключение параметры, задаваемые по умолчанию). Пример с разными параметрами (формальные а, b , pStr):
#include
…
void Func (int a, float b, int *r, const char * pStr) // целый, веществ. и строка
{ *r = (int)(a + (int)b + atoi( pStr )); }; // Тело функции
Вызов функции и печать (фактические: a,f,Rez):
float f = 1.0f;
int Rez = 0 , a = 1;
Func (a, f, &Rez, "1"); // вызов функции
printf("Результат из функции Func = %d!\n" , Rez );
Получим:
Результат из функции Func = 3!

ЛР №5 Прототипы функций
Прототипы функция задаются для возможности контроля фактических параметров при вызове
функций. В прототипе задается так:
<Прототип функции> :=[<типа возврата >] <Имя функции> ([<Список типов параметров>]);
Перед первым вызовом функции прототип должен быть уже задан. Это делается в главном модуле или заголовочном файле в начале главного модуля проекта .
Примеры прототипов функций:
int MinMas ( int * iMas , int Razm, int * Min1, int * Num);
void SWAP(int * a, int * b);
int Summa3 (int a , int b);
При задании прототипа может быть указан тег параметра и его значение по – умолчанию:
void SWAP(int * first , int * second); // теги: first и second
int Summa3 (int a = 0 , int b = 2 ); // Умолчание: 0 и 2
Заголовочные библиотек содержат прототипы всех своих функций.

ЛР №5 Вызов функций
Вызовы функций имеют вид:
<Вызов функции> ::= <Название функции> ([<Список Фактических
параметров функции>]);
Вызовы функции можно сделать:
В любой строке программы, если она не возвращает значений
В любом выражении, она возвращает значение (в любом операторе, использующем выражения)
В качестве фактического параметра вызова другой функции
Примеры вызовов функций
В программе:
MaxMas( Mas5 , Razm , &MaxMas5, &NumMax); // нет присваивания
В выражении:
MaxMas5 = MaxMas( Mas5 , Razm , &MaxMas5, &NumMax); // Оператор присваивания
В качестве параметра:
printf ( "Max в = %d \n" , MaxMas( Mas5 ,sizeof(Mas5)/sizeof(int), &MaxMas5, &NumMax)); // параметр функции

ЛР №5 Возврат из функции (void)
Из любой функции должен быть обеспечен возврат (СМ).
Он выполняется двумя способами:
При выполнении оператора возврата:
return <Выражение типа возврата функции> ;
При достижении закрывающей операторной скобки ("}") тела функции, для функций неопределенного типа.
Выходов из функции с помощью оператора return может быть много, в зависимости от алгоритма, реализованного в функции.
Если тип возврата не определен (задается условный тип void ). оператор возврата return должен быть задан без выражения, например:
return; // ";" – обязательна!
При выходе по концу составного оператора через скобку ("}") , считается, что тип возврата не задан (по-умолчанию считается int!).
Функции типа void не может вызываться в выражениях и фактических параметрах. Пример функции типа void :
void Summa (int a , int b , int * RezSum); // тип возврата не задан

ЛР №5 Тело функции
Тело функции это составной оператор любой сложности(в фигурных скобках –"{","}")
(СМ). Иногда используют термин БЛОК! Пример:
void SWAP(int * a, int * b)
{
int Temp; // Тело функции
Temp = *a; // Тело функции
*a = *b; // Тело функции
*b = Temp; // Тело функции}
Вызов функции SWAP:
//SWAP функция
void SWAP( int *, int *); // Прототип
int k1 = 1 , k2 = 2;
printf ("До SWAP функция k1 , k2 %d %d \n",k1 , k2);
SWAP(&k1 , &k2);
printf ("После SWAP функция k1 , k2 %d %d \n",k1 , k2);
Результат работы фрагмента программы:
До SWAP функция k1 , k2 1 2
После SWAP функция k1 , k2 2 1

ЛР №5 Данные в функциях
Данные, которые можно использовать в функциях следующие:
Формальные параметры, переданные
в функцию.
Локальные переменные, описанные в данной функции.
Константы допустимых типов.
Глобальные параметры модулей проекта
Областью видимости(ОВ) называется та часть программы, где переменные использовать можно.
При вызове функции с фактическими параметрами они подставляются на место формальных параметров и могут использоваться в теле функции (СМ). ОВ – тело функции.
Локальные параметры описываются непосредственно в функции и используются для реализации алгоритма, они доступны только в данной функции. ОВ от места их описания до конца блока, в котором они описаны.
Глобальные параметры, описываются в начале модуля (файла) или в заголовочном файле и доступны во всем модуле (заметьте: extern)

ЛР №5 Размещение функций
Описания Функций в проекте могут быть размещены:
В этом же программном
модуле в его начале (до main), в этом случае прототипа функции задавать не надо.
В этом же программном модуле в его конце (после main), в этом случае прототип функции в начале модуля задавать обязательно.
В другом исходном модуле проекта, прототип должен быть задан обязательно в либо начале главного модуля или либо в подключаемом к нему заголовочном файле.
В подключаемом в этот модуль заголовочном файле, прототипа в этом случае задавать не нужно.
В специально созданных пользовательских и стандартных библиотеках СИ: *.LIB или *.DLL.
Если описание или прототип функции не обнаружены компилятором и компоновщиком или она переопределена выдается ошибка!!,

ЛР №5 Рекурсивные функции
Рекурсивной называется такая функция, которая может вызывать саму себя (при
этом ошибки не возникает). В рекурсивной функции должно быть предусмотрено завершение ( return ), то есть должна существовать такая ветка в алгоритме, которая не содержит рекурсивного вызова себя.
Наиболее показательной является функция вычисления факториала:
0! =1; n! = 1*2*3*4*(n-1)*n;
Можно и так: n! = (n-1)!*n ,
причем красным помечена рекурсия!
Функцию вычисления факториала можно написать так:
int fact( int n)
{ int rez;if ( n == 0 )
return rez = 1;else return rez = n * fact ( n - 1 ) ; };
Вызов функции вычисления факториала (fact) из основной программы:
printf ("fact 5 = %d\n" , fact(5) );
Результат вызова рекурсивной функции см. в отладчике(5! =120):
fact 5 = 120

ЛР №5 Массивы в функциях
Для передачи массива в функцию может быть выбран один
из вариантов (МУ, DOC) :
Фиксированное число элементов в массиве (размер массива фиксирован в программе или задан глобальной переменной)
Через указатель на массив и его размер (размер указан отдельным числовым параметром, наиболее приемлемый вариант)
Задание нулевого элемента в конце массива (имеет ограниченное применение, из-за возможности нулей в массиве)
Передача структуры параметров (указатель и массив в структуре)
Основная проблема с массивом параметром – Это передача размера массива (фиксированное, глобальное, параметр, вычисляемое).
При формировании массивов в функциях целесообразно использовать динамическую память, в этом размер может вычисляться в самой функции и проблема его передачи отсутствует.

ЛР №5 Указатели и функции
Фактические параметры передаются в функции по значению. Поэтому изменить
значение переменных внутри функции невозможно!
В связи с этим, только при передаче указателя на переменную возможно их изменение (СМ). Для передачи указателя нужно:
В описании функции для параметра задать тип указателя (* - задан формальный параметр psum ):
int Summa (int pmas, int Razm , int * psum){…}; // Описание
И при вызове функции применить перед параметром операцию адресации/именования (& - - задан формальный параметр Sum в виде указателя на переменную).
int iMas[5] = {1,2,3,4,5};
int Sum = 0;
int S = Summa (iMas, 5 , &Sum); // Вызов функции
В самой же функции для изменения значения переменной нужно использовать операцию разименования/разадресации (*):
*psum = … // Изменение переменной по указателю в теле функции

ЛР №5 Передача параметров в функции
Важное ПРАВИЛО СИ: ПАРАМЕТРЫ В ФУНЦИИ ПЕРЕДАЮТСЯ ПО
ЗНАЧЕНИЮ!
Это означает, что изменить фактический параметр в функции нельзя!
Пример функции (sum - параметр):
// Попытка изменить параметр ы функции
int Summа (int a , int b, int sum) //
{ sum = (a + b); // попытка изменения
return (a + b); };
Проверка изменения :
int s1 = 0, s2;
s2 = Summа(2,2,s1); // s1 = 0 s2 = 4
Значение s2 в операторе присваивания изменилось (4), а значение параметра s1 не изменилось (было 0). Просмотр проводиться в отладчике!
Для изменения параметра в функции нужно передать в функцию его адрес (указатель или ссылку на переменную!) (СМ)

ЛР №5 Указатели на функции
В СИ/СИ++ допускается использовать указатели на функции для обеспечения
большей динамики в программе. Покажем на примере:
// Функции для демонстрации указателя на функции
int fun1 (int i) { return i=5;};
int fun2 (int i) { return i=10;};
В основной программе, указатель на функцию (pFun) вычисляется динамически:
int i , j , k =5;
int (* pFun) (int); // указатель на функцию с параметром int
pFun = &fun1;
i = (pFun)(k); // выражение одинаковое для вызова функции через указатель
printf ("pFun = &fun1 => %d\n" , i );
pFun = &fun2; //
j = (pFun)(k); // выражение одинаковое для вызова функции через указатель
printf ("pFun = &fun2 => %d\n" , j );
j = pFun(k); // можно и так
printf ("j = pFun(k) => %d\n" , j );
В результате получим:
pFun = &fun1 => 5
pFun = &fun2 => 10
j = pFun(k) => 10

ЛР №5 Переменное число параметров
1

ЛР №5 *.Библиотеки функций
1

ЛР №5 Встраиваемые функции
Функции, которые включаются в код программы, а не вызываются называются
встраиваемыми (спецификатор inline). Пример функции проверки четности:
//описание inline функции
inline int even (int x)
{ return ! (x%2); } ; // возврат по модулю 2 четное 1 (истина) нечетное 0 (ложь)
Вызов inline функции:
i = 10 ;
if (even (i)) printf ("Число %d является четным\n", i );
else printf ("Число %d является нечетным\n", i );
i = 5 ;
if (even (i)) printf ("Число %d является четным\n", i );
else printf ("Число %d является нечетным\n", i );
В результате получим:
Число 10 является четным
Число 5 является нечетным

ЛР №5 Макросы
Макросы (или макрокоманды) обрабатываются на этапе компиляции (СМ), преобразуются с помощью
параметров и вставляются в программу в виде текста для последующей компиляции.
Для описания макрокоманд используется директива компилятора СИ/СИ++ define, или формально:
#define <имя этапа компиляции> <пробел “ ”> <выражение этапа компиляции>
Для макроса без параметров (переменная компиляции), во всей программе выполняется подстановка ее значения Пример:
#define NMAX 10 // Описание переменной этапа компиляции
Если задаются параметры, то это записывается так:
#define <имя этапа компиляции>(<список параметров макроса",">) <пробел “ ”> <выражение этапа компиляции с параметрами>
После настройки параметров текст вставляется в программу. Пример макроса с параметрами и его использования
#define sum (a,b) (a+b) // Макрос суммы двух параметров
int s = sum(2,2); // получим: s = (2+2);
Или другой пример макроса:
#define max1(a,b) ((a>b)?a:b) // Макрос максимума их двух

ЛР №5 *.Понятие функции
1

ЛР №5 Примеры
Смотрите: (МУ, DOC) (2016) через (VS –ЛР № 5). Теория (СМ)
Простая
функция суммирования 2-х целых (Summa). (СМ)
Функция максимума в целом массиве (MaxMas). (СМ)
Функция с попыткой возврата значений (Summ). (СМ)
Функция с возвратом указателя (SumMas). (СМ)
Функция с константным параметром (Summ) (МУ)
Функции с передачей массива в качестве параметра (Summ51 ) (DOC)
Функция с массивом с нулевым элементом(Summ6). (DOC)
Рекурсивная функция факториала ( fact ). (СМ)
Макросы (max и Swap). (DOC) (СМ)
Пример с распечаткой параметров программы и окружения (DOC) (СМ)
Пример с inline функцией. (МУ) (DOC) (СМ)
Пример с вызовом функции через указатели. (МУ) (DOC) (СМ)

ЛР №5 1. Примеры
Смотрите: (МУ, DOC) (2016) через (VS –ЛР № 5)
Простая функция
суммирования 2-х целых (Summa).
Описание функции:
int Summa (int a , int b) // формальные параметры функции а и b
{// начало функции
// тело функции – всего один оператор return
return (a + b); }; // конец функции
// возвращаемое значение функции типа int
Прототип функции:
// Прототип функции
int Summa (int a , int b);
//вызов функции при инициализации:
int k = Summa(1 , 1); // k=2
Вызов функции и результат:
// Вызов функции при печати в параметрах функции printf
printf ( "Сумма = %d \n" , Summa(12,13)); // фактические параметры константы
Результат:
Сумма = 25

ЛР №5 2. Максимум
Смотрите: (МУ, DOC) (2016) через (VS –ЛР № 5). Функция
(MaxMas).
Описание функции:
int MaxMas ( int * iMas , int Razm, int * Max1, int * Num)
{ int TempMax;
int NumMax=0;
TempMax = iMas[0];
for ( int i = 1; i < Razm; i++)
if ( TempMax <= iMas[i]) { TempMax = iMas[i]; NumMax= i;}
*Max1 = TempMax;
*Num= NumMax;
return *Max1; };
Прототип функции:
int MaxMas ( int * iMas , int Razm, int * Max);
Вызов функции и результат:
int Mas5[]={1,1,4,1,-2, 30,0, 7};
int NumMax = 0; int MaxMas5 = 0;
MaxMas5 = MaxMas( Mas5 ,sizeof(Mas5)/sizeof(int), &MaxMas5, &NumMax);
printf ( "Max = %d Номер = %d\n" , MaxMas5, NumMax );
Результат: Max = 30 Номер = 5

ЛР №5 3.Возврат указателя
Смотрите: (МУ, DOC) (2016) через (VS –ЛР № 5).указателя (SumMas)
Описание
//
Указатель возврат и сумма в масиве
int SummMas (int * mas , int * psum)
{ int sum = 0 ;
for (int i = 0 ; i < 5 ; i++ )sum = sum + mas[i];
*psum = sum ;
return *psum; }; // возвращаемое значение функции через указатель
Вызов
//Возврат указателя
int iMas[5] = {1,2,3,4,5}; // 0 - 4
int Sum;
printf ("Сумма в массиве ВОЗВРАТ iMas = %d \n" , SummMas ( iMas, &Sum) );
printf ("Сумма в массиве ПАРАМЕТР iMas = %d \n" , Sum );
Результат:
Сумма в массиве ВОЗВРАТ iMas = 15
Сумма в массиве ПАРАМЕТР iMas = 15

ЛР №5 Задание Общее
Смотрите: (МУ, DOC) (2016) через (VS –ЛР № 5)
Создать макрос
(СМ) 5.1
Функция суммы 3-х чисел (СМ) 5.2
Функция печати массива (СМ) 5.3
Функция Swap (СМ) 5.4
Функция минимума или максимума (СМ) 5.5
Функция сортировки (СМ) 5.6
Рекурсивная функция (СМ) 5.7

ЛР №5 Задание 5.1
Смотрите: (МУ, DOC) 5.1 Создать макрос
Создать и отладить макрос вычисления
минимума или максимума их 3-х переменных. Задание уточняется таблицей вариантов. Исходные значения задаются в программе в виде констант. Результат вывести на печать.
// Макрос вычисления максимума их двух переменных
//#define max(a,b) ((a>b)?a:b)
Макрос вычисления максимума их ТРЕХ переменных
#define max3(a,b,c) ((a>b)?((a>c)?a:((b>c)?b : c)):((b>c)?b : c))
int imax = max3(5, 2, 10); // Макровызов max3 с тремя переменными
Выполним макрос в виде параметра:
printf ("Максимум из трех = %d \n",imax);
Получим Результат:
Максимум из трех = 10

ЛР №5 Задание 5.2
Смотрите: (МУ, DOC). 5.2 Функция суммы 3-х чисел
Прототип и описание
функции:
// Прототип функции
int Summa3 (int a , int b, int c, int * psum);
// Описание функции
int Summa3 (int a , int b, int c, int * psum){
*psum = (a+b+c); // Тело функции
return *psum;};
Вызов функции:
int SUM;
int Sum= Summa3(2 , 3, 5 , &SUM); // Вызов с указателем
printf ("Сумма параметр из функции %d \n" ,SUM );
printf ("Сумма при возврате из функции %d \n" , Sum);
Результат работы функции (выполнить по шагам в отладчике):
Сумма параметр из функций 10
Сумма при возврате из функции 10

ЛР №5 Задание 5.3
Смотрите: (МУ, DOC). 5.3 Функция печати массива
Описание и прототип:
// Описание
Функции Печати массива
void PrintMas ( int * pMas, int Razm)
{ for(int i =0 ; i< Razm ; i++)
{ printf (" Элемент [%d] = %d \n" , i, pMas[i] );
};};
// Прототип функции печати массива
void PrintMas ( int * pMas, int Razm);
Вызов в программе :
// Вызов в программе
int iMas3[] = {1,2,3,4,5};
PrintMas(iMas3 , (sizeof(iMas3)/sizeof(int)));
Результат работы:
Элемент [0] = 1
Элемент [1] = 2
Элемент [2] = 3
Элемент [3] = 4
Элемент [4] = 5

ЛР №5 Задание 5.4
Смотрите: (МУ, DOC). 5.4 Функция Swap
Описание и прототип:
void SWAP( int
*, int *); // Прототип Функции
// Описание Функции обмена значениями SWAP в модуле second.cpp
void SWAP(int * a, int * b)
{ int Temp;
Temp = *a;
*a = *b;
*b = Temp; };
Вызов функции обмена:
//SWAP функция ВЫЗОВ функции SWAP
int k1 = 1 , k2 = 2;
int k1 = 1 , k2 = 2;
printf ("До SWAP функции k1= %d, k2 = %d \n",k1 , k2);
SWAP(&k1 , &k2); // ВЫЗОВ функции обмена SWAP
printf ("После SWAP функции k1= %d, k2 = %d \n",k1 , k2);
Результат:
До SWAP функции k1= 1, k2 = 2
После SWAP функции k1= 2, k2 = 1

ЛР №5 Задание 5.5
Смотрите: (МУ, DOC). 5.5 Функция минимума или максимума. Описание:
int MaxMas
( int * iMas , int Razm, int * Max1, int * Num)
{ int TempMax;
int NumMax=0;
TempMax = iMas[0];
for ( int i = 1; i < Razm; i++)
if ( TempMax <= iMas[i])
{ TempMax = iMas[i]; NumMax= i;}
*Max1 = TempMax;
*Num= NumMax;
return *Max1; };
Прототип:
int MaxMas ( int * iMas , int Razm, int * Max, int *Num);
Вызов и результат:
int Mas5[]={1,1,4,1,-2, 30,0, 7};…
MaxMas5 = 0; …
MaxMas5 = MaxMas( Mas5 ,sizeof(Mas5)/sizeof(int), &MaxMas5, &NumMax);
printf ( "Max = %d Номер = %d\n" , MaxMas5, NumMax );
Результат:
Max = 30 Номер = 5

ЛР №5 Задание 5.6
Смотрите: (МУ, DOC). 5.6 Функция сортировки использует функцию SWAP (СМ)
int
SortMas(int * iMas ,int Razm )
{ int Flag;
for (int k= 0 ; k
{ Flag = 0;
for (int i = 0 ; i
{ // if ( iMas[ i ] > iMas[ i+1] ) // возрастание
if ( iMas[ i ] < iMas[ i+1] ) // убывание
{ SWAP( &iMas[ i ], &iMas[ i+1] ); Flag = 1;} };
if (Flag == 0) break; };
return 0; };
Вызов функции сортировки и распечатка массива Блок схема (СМ):
// Вызов функции сортировки
int Mas6[]={5,0, 3,10,1}; // SortMas
printf ( "ДО сортировки функция!\n" );
PrintMas (Mas6 , sizeof(Mas6)/sizeof(int));
SortMas(Mas6 , sizeof(Mas6)/sizeof(int)); // и
printf ( "После сортировки функция!\n" );
PrintMas (Mas6 , sizeof(Mas6)/sizeof(int));

ЛР №5 Задание 5.6 Блок-схема
Смотрите: (МУ, DOC). 5.6

ЛР №5 Задание 5.7
Смотрите: (МУ, DOC)
5.7 Рекурсивная функция (СМ)

ЛР №6 Теория Общий
Структуры (МУ, DOC) через (VS –ЛР № 6)
Проблемы хранения и
обработки данных (СМ)
Понятие структуры (СМ1 , СМ2).
Описания и инициализация структур (СМ). Заполнение структур (rand)
Работа с полями структур. Квалифицированная ссылка (СМ)
Структуры и функции (СМ). Параметры и типы возврата (СМ).
Указатели на структуры, доступ к полям через указатель. (СМ).
Массивы структур и работа с ними. (СМ). Сортировка массива 4.5 (DOC)
Вложенные структуры, сложная квалификация (СМ).
Локальные структуры (СМ).
Рекурсивные структуры (СМ).
Динамические структуры (СМ). Заполнение структур (rand) (СМ)
Перечисления(СМ) и союзы (СМ).
Примеры из МУ (СМ), Контрольные задания (СМ)
Структуры и массивы (СМ), структуры и классы (СМ).
Специальные указатели на поля структур. (СМ).

ЛР №6 1.Проблемы хранения данных
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Проблемы
хранения и обработки данных в ИС (МУ, DOC):
Для решения задач автоматизации необходимо совместно, а не в виде группы переменных, хранить разнотипные данные для программы (например: о человеке, устройстве, организации и т.д.)
По-другому: трудно для хранения использовать множество разнотипных переменных с разными именами.
Для наглядности применения групп данных
Для использования данных разными процедурами, моделями, подсистемами и частями проекта
Массивы не подходят для этого, так как они хранят однотипные данные.
Структуры данных позволяют избавиться от этих проблем.

ЛР №6 2.Понятие структуры
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Понятие структуры
(СМ1).
Структура – это специальный механизм языка, позволяющий совместно использовать разнотипные данные для работы в программе с реальными предметами и явлениями предметной области программ.
Для работы со структурами нужно:
Выполнить описание шаблона структуры (описание структуры) (СМ)
Выполнить описание структурных конкретных переменных на основе шаблона структуры (СМ)
Использовать в операторах программы (вычисления, фактические и формальные параметры функций) структурные переменные в виде квалифицированной ссылки (СМ) на поля конкретной структурной переменной.

ЛР №6 3.Описание структур (1)
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Описания и инициализация структур (МУ). Формально шаблон структуры описывается так:
struct <имя структуры> {
<описание поля 1 структуры>;
…
<описание поля N структуры>;
} [<список описаний конкретных структурных переменных>];
Причем описание поля структуры это любое описание доступное в СИ/СИ++, за исключением описаний этой же структурной переменной (указатель допустим!). Число полей в структуре не ограничивается (!).
Пример описания структуры типа Student:
struct Student {
char Name[14]; // Фамилия студента
int kurs; // Курс обучения
Student * pStud; // Указатель на другого студента
bool pol; // Пол студента: true - women, false - men
float Stipen; // Размер стипендии
} Student1, Group31[30] }; // Необязательное описание переменных

ЛР №6 3.Примеры структур (2)
(МУ, DOC) (2016) через (VS –ЛР № 6).Примеры описаний:
struct
Complex { // Структура - комплексная переменная
double re; // действительная часть
double im; }; // мнимая часть
struct Date { // Структура - дата
int day; // День
int month; // месяц
int year; };// Год
struct Person { // Структура - Персона
char name[50];
Date birthdate; // структурная переменная дата рождения
double salary; }; // Оклад
struct Student S333; // Описание без инициализации полей
Student S1 = {"Петров" , 1 , false , 1500.0f }; // инициализация полей структуры
Student Group[30]; // Массив структур
Complex z;
Date d;
Person p;

ЛР №6 4.Работа с полями структур
Поля структур. (МУ, DOC) (2016) через (VS –ЛР
№ 6).
Для работы с полями используется конструкция квалифицированной ссылки. Формально это выглядит так:
<имя структурной переменной>.<имя поля структуры>
Например, для структурных переменных:
struct Student S333; // Описание без инициализации полей
Student S1 = {"Петров" , 1 , false , 1500.0f }; // Описание и заполнение
Student Group5[30]; // Массив структур
Работа с полями выглядит так:
S1.kurs = 2; // Для поля kurs структуры S1
Group5 [4].kurs = 3; // Для поля kurs 4-го элемента массива структур Group5
ПО СУТИ: ОТДЕЛЬНОЕ ПОЛЕ СТРУКТУРНОЙ ПЕРЕМЕННОЙ РАССМАТРИВАЕТСЯ КАК ПРОСТАЯ ПЕРЕМЕННАЯ!!!

ЛР №6 Структуры и функции (1)
(МУ, DOC) (2016) через (VS –ЛР № 5).Структуры
и функции .
При работе с функциями возможны случаи (прототипы):
Структура передается в функцию:
void PrintKurs (Student s);
Функция возвращает структуру:
Student Kurs10 (Student s);
Указатель на структуру передается в функцию:
void ChangeStudKurs(Student * pS, int NewKurs);
Функция возвращает указатель на структуру (статика)
Student * StudPerevod( Student * pS );
Функция возвращает указатель на структуру(динамика). Нужно потом освобождать память (free).
Student * StudNew(void);

ЛР №6 Структуры и функции (2)
(МУ, DOC) (2016) через (VS –ЛР № 5).Структуры
и функции .
Примеры использования структур в качестве параметров и возврата:
Student S1;
S1.kurs = 2;
PrintKurs(S1);
printf("Печать поля вне функции S1.kurs = %d\n", S1.kurs);
Kurs10(S1);
printf("Печать поля вне функции S1.kurs = %d\n", S1.kurs);
Student S0;
S0 = Kurs10(S1); // Присваивание структур!!! Kurs10 - возвращает структуру
printf("Печать поля вне функции S0.kurs = %d\n", S0.kurs);
Student S5 = { "Иванов",2 ,&S0 , 2000.0f };
// Параметр указатель на структуру
printf("Печать до функции ChangeStudKurs S.kurs = %d\n", S5.kurs);
ChangeStudKurs(&S5, 1);
printf("Печать после функции ChangeStudKurs S.kurs = %d\n", S5.kurs);
// Возврат указатель на структуру
printf("Печать до функции StudPerevod S.kurs = %d\n", S5.kurs);
// Вызов функци возвращающей структуру
printf("Печать после функции StudPerevod S.kurs = %d\n", (StudPerevod (&S5))->kurs);
Student * pStud;
printf("Печать после функции StudNew S.kurs = %d\n", (pStud= StudNew())->kurs);
free (pStud);
Результаты(DOC)

ЛР №6 8.Указатели на структуры
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Указатели
на структуры (СМ): Указатель на структуры описывается так:
<имя структуры * <Имя указателя> [ = <инициализация> ];
Примеры описаний указателей:
Пусть есть Структура:
struct Person { // Персона
char name[50];
Date birthdate; // структурная переменная дата рождения
double salary; }; // Оклад
указатели на структуру:
struct Person * pPerson; // или без ключевого слова struct
Person * pP1 ;
Person P1= { "Сидоров", {10, 3, 1978}, 1500.48 };
Вычисления указателя:
pPerson = & P1 ; // Структурная переменная
Использование указателя:
pPerson-> salary = 2000.0;
strcpy(pPerson-> name , "Иванов" );

ЛР №6 6.Вложенные структуры
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Вложенные структуры.
Вложенные
структуры: одни структуры описываются и используются внутри других (см. локальные структуры):
// Вложенные структуры B вложена в А
struct A {
int i;
struct B {int k;};
B b1; // описание структурных переменных
А а1; // //ОШИБКА! ШАБЛОН СТРУКТУРЫ НЕДОСТУПЕН!
A * pA; }; // ПРАВИЛЬНО! Задан УКАЗАТЕЛЬ НА СТРУКТУРУ
Вложенные структуры описание переменных и работа с ними.
// Вложенные структуры
A a1, c1; // Описание переменных
a1.b1.k = 5; // k- Поле из вложенной структуры
a1.pA=&c1; // Задание указателя на свою структуру

ЛР №6 Массивы структур
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Массивы структур
описываются как обычные массивы, но задается тип структурной переменной:
// Массивы структур
Person P1= { "Сидоров", {10, 3, 1978}, 1500.48 };
Person MasPerson[30];
Работа с элементами и полями массива структур:
// Присваивание одной структуры 2-му элементу массива
MasPerson[3] = P1;
// Цикл работы (занесение поля оклада salary )
for (int i =0 ; i < sizeof(MasPerson)/sizeof(Person) ; i++ )
{ MasPerson[i].salary = 10.0; };
MasPerson[0] = MasPerson[3] ; // 2 элемента массива структур
Работа с массивами структур в функции:
float SumSalaryMas (Person * pP, int Razm) // сумма полей salary массива
{ float SumSal = 0.0f;
for (int i = 0 ; i< Razm ; i++)
SumSal+= (pP + i)->salary ;
return SumSal; };

ЛР №6 Динамические структуры
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Динамические структуры.
Для работы с динамическими структурами описывается указатель на структуру данного типа (СМ):
Student * pStud;
Выделяется динамическая память:
#include
pStud = (Student * )malloc(size)
// Захват ДП
pStud = (Student * )malloc(sizeof(Student));
Работа с динамической структурной переменной^
pStud->kurs = 2;
strcpy(pStud->Name, "Федоров");
// ...
Освобождение ДП:
free (pStud);

ЛР №6 Локальные структуры
Структуры (МУ, DOC) (2016) через (VS –ЛР № 5)
Локальные структуры
– Это вложенные структуры (СМ), которые описаны в внутри составного оператора (блока) (СМ).

ЛР №6 Рекурсивные структуры
(МУ, DOC) (2016) через (VS –ЛР № 5)
Рекурсивные структуры это
такие структуры, в которых описаны указатели на переменные этого же структурного типа (СМ). Пример описания:
struct Elem{ // структура элемента списка
Elem * next; // указатель на Elem
Elem * prev; // указатель на Elem
int ListVal;
};
Пример использования:
// Рекурсивные структуры
Elem E2, E3;
Elem E1= {&E2, &E3,5};
// Навигация
Elem * pE;
pE = &E1;
pE = pE->next; // Навигация

ЛР №6 Перечисления
(МУ, DOC) (2016) через (VS –ЛР № 5)
Перечисления enum – это
специальный вид структурных переменных, позволяющий создать список целых поименованных констант. использующихся программ . Например, можно перенумеровать дни недели, месяцы. Формально это выглядит так:
enum [ <имя> ] {список перечисления} [ список переменных];
Пример описания перечисления:
enum day { mon = 1 , tue , wed , thu , fri , sat , sun };
Причем каждой символьной константе перечисления соответствует целое число! У первой 0 (по-умолчанию, или заданное число – 1 у нас). У остальных значения по порядке: {1,2,3,4,5,6,7}.
Использование перечислений:
d day d1; // Переменная типа перечисления day
d1 = sun; // Вычисление значения переменной (sun = 6)
d1 = (day )5; // !Ошибка допустим только заданный набор 1-7
Неименованные перечисления (уже есть enum для: true и false в СИ):
enum {FALSE,TRUE }; // FALSE = 0 и TRUE = 1

ЛР №6 Союзы/объединения(union)
(МУ, DOC) (2016) через (VS –ЛР № 5) Союзы.
Союзы – это
специальный тип структурных переменных, позволяющих хранить в одном месте ОП (СМ) разные данные. Союзы имеют:
Описание союза (шаблона).
int ival; // целое поле
float fval; // вещественное поле
char *sval; // указатель на строку
}; u // u – переменная описана вместе с шаблоном
Описание переменных данного типа.
u_tag U1; // u_tag – это новый тип данных!!!!
Использование полей союза (строк и числовых полей).
U1.ival = 5; // целое поле
U1.fval = 0.5f; // вещественное поле
// указатель на строку
char * pStr = (char *)new char[100] ;// Выделение ДП под строку
strcpy(U1.sval, 100 , "Объединения");

ЛР №6 Указатели на поя структуры
(МУ, DOC) (2016) через (VS –ЛР № 6)
Специальные указатели на поля структур.
Новая структура для демонстрации:
struct Student …
… int Kurs2;
Покажем работу указателя на поле на примере (указатель на поле выделен красным цветом pPole):
// Указатель на поле структуры (объявление)
int Student::*pPole;
// Указатель на поле структуры (задание значения)
pPole=&Student::Kurs; // здес может быть и другое целое поле структуры
Student S8={ "Сидоров" , "Василий", 1 , 2000.0f , 10 }; // Kurs = 1 , Kurs2 = 10
// Структура и указатель на поле
S8.*pPole =2; // Kurs = 2
// На Указатель pPole на поле задаем на новое поле (Kurs2 = 10 предварительно)
pPole=&Student::Kurs2;
S8.*pPole =3; // Kurs2 = 3
// Указатель на структуру и указатель на поле вместе
Student * pStud;
pStud=&S8;
pStud->*pPole=6; // Kurs = 6
Проверить работу фрагмента программы можно в отладчике или выполнить распечатку значений полей до и после изменения.

ЛР №6 Структуры и классы
(МУ, DOC) (2016) через (VS –ЛР № 6).
Отличия
свойств классов (class) и структур (struct):
Структуры являются предшественниками классов – основы Объектно-Ориентированного Программирования (ООП).
В классах дополнительно описываются функции (методы), которые предназначены для работы с полями (объекта!!!).
В структурах функции тоже допустимы но только для С++.
В классах все данные и методы первоначально скрыты от внешнего воздействия (Инкапсуляция).
В структурах все поля (данные) по - умолчанию открыты для пользователей.
В классах можно объявить новые операции над переменными данного типа(Полиморфизм).
Допускается создавать новые классы на основе существующих (Наследование). В структурах того нет.
В ООП можно динамически настраиваться на действия (выполнение функций классов) с переменными, в зависимости от типа объекта класса.
И классы и структуры задают новые типы данных!

ЛР №6 Примеры
(МУ, DOC) (2016) через (VS –ЛР № 6)
3 Основные понятия (МУ,
DOC, раздел 3)
3.10. Присваивание структур(DOC 3 раздел)
4.2. Копирование и обмен статических структур (DOC, 4 и 5 раздел)
4.3. Функция Swap для структур с динамическими строкам (DOC)
4.4. Заполнение случайных – rand() числовых полей массива структур (DOC 4 и 5 раздел)
4.5. Сортировка массива структур с помощью функции Swap (4 и 5 раздел).

ЛР №6 5.9 Задания Общее
(МУ, DOC) (2016) через (VS –ЛР № 6)
5.1. Создание
консольного проекта ЛР (СМ)
5.2. Описать структуру своего варианта ДЗ и работа с ней (СМ)
5.3. Функция Распечатки структуры (СМ)
5.4. Функция Распечатки структуры через указатель (СМ)
5.5. Массив структур, его инициализация и функция распечатки (СМ)
5.6. Функция копирования структур (СМ)
5.7. Функция обмена (Swap) для структур (СМ)
5.8. Использование перечислений по варианту (СМ)
5.9. Заполнение числовых полей массива структур случайными данными (СМ)

ЛР №6 5.1 Проект ЛР №6
(МУ, DOC) (2016) через (VS –ЛР № 6)
5.1.
Создание консольного проекта ЛР: Создать пустой консольный проект для выполнения ЛР № 6. Пример создания консольного проекта и его русификация рассмотрено в методических указаниях к ЛР №1 по дисциплине ОП (см. на сайте). В проект обязательно включить три модуля: first.cpp (для главной программы проекта), second.cpp (для размещения функций проекта) и header.h (для описаний структур и прототипов функций проекта). При подключении своего модуля из текущего каталога нужно использовать кавычки: #include "header.h"
Если поместить описание (int Counter = 0;) в second.cpp , то в first.cpp нужно указывать :extern int Counter; для доступа к этой внешней переменной.
Структура проекта показана на рисунке ниже:

ЛР №6 5.2 Описание структуры Варианта
(МУ, DOC) (2016) через (VS –ЛР № 6)
5.2.
Описать структуру своего варианта ДЗ
struct Student { // Структура со статическими строками
char Name[20]; // Имя студента
char Fam[20]; // Фамилия студента
int Kurs; //Курс студента
float Stipen; }; //Размер стипендии студента
Проектирование, придумывание структуры: Задачи, предметная область (!!!!).
Описание переменных и их инициализация:
Student S2 = { "Иван" , "Петров", 1 , 2000.0f };
Присваивание и копирование:
S1.Kurs = 2;
S1.Stipen = 5000.0f;
strcpy_s(S1.Name, "Петр");
strcpy_s(S1.Fam, "Иванов");
Распечатка структуры:
printf( "\nФамилия - %s \nИмя - %s \nКурс - %d \nСтипендия - %6.2f р. \n" ,S2.Fam,S2.Name, S2.Kurs , S2.Stipen );
Работа через указатель, печать через указатель, Динамическая структура (DOC):

ЛР №6 5.3 Функция Распечатки структуры
(МУ, DOC) (2016) через (VS –ЛР № 6)
Описание
функции (описание поместим в файл second.cpp):
// Описание функции
void StudentPrint( Student S)
{ printf( "Структура Student в функции:");
// Печать структуры Student
printf( "\nФамилия - %s \nИмя - %s \nКурс - %d \nСтипендия - %6.2f р. \n" ,S.Fam,S.Name, S.Kurs , S.Stipen , S.Kurs , S.Stipen ); };
Прототип функции (разметить в файле проекта header.h)
void StudentPrint( Student S);
Использование и результат (текст в главном модуле first.cpp):
// 5.3 Структуры для печати, заполнение см. выше
Student S1 = { "" , "", 1 , 2000.0f }; // Пустая структура
Student S2 = { "Иван" , "Петров", 1 , 12000.0f };
StudentPrint(S1); // 5.3 Функция печати вызов функции
StudentPrint(S2); //Вторая структура
Структура Student в функции:
Фамилия -
Имя -
Курс - 1
Стипендия - 2000.00 р.

ЛР №6 5.4 Печать через указатель
(МУ, DOC) (2016) через (VS –ЛР № 6)
Описание
функции (описание поместим в файл second.cpp):
void StudentPrintP( Student * pS)
{ printf( "Структура Student печать в функции (указатель):");
printf( "\nФамилия - %s \nИмя - %s \nКурс - %d \nСтипендия - %6.2f р. \n" ,pS->Fam,pS->Name, pS->Kurs , pS->Stipen ); };
Прототип функции (разметить в файле проекта header.h)
void StudentPrintP(Student * pS);
Использование и результат (текст в главном модуле first.cpp):
// 5.3 Структуры для печати, заполнение см. выше
Student S1 = { "" , "", 1 , 2000.0f }; // Пустая структура
Student S2 = { "Иван" , "Петров", 1 , 12000.0f };
StudentPrintP(&S2); //Вторая структура
StudentPrintP(&S1); // 5.3 Функция печати вызов функции
Фамилия - Петров Имя - Иван Курс - 1 Стипендия - 2000.00 р.
Структура Student печать в функции (указатель):
Фамилия - Петров
Имя - Иван
Курс - 1
…

ЛР №6 5.5/11 Массив структур, Функция
(МУ, DOC) (2016) через (VS –ЛР № 6)
5.5. и 5.11
Описание массива структур и его распечатка и функция печати массива,
//5.5 Массив структур и его описание инициализация
Student Group[] = { { "Сидоров" , "Василий", 2 , 2000.0f }, { "Иван" , "Петров", 2 , 2000.0f }};
// Распечатка массива структур в цикле
printf("Группа студентов:\n");
for ( int i = 0 ; i < sizeof(Group)/sizeof(Student) ; i++ )
StudentPrint(Group[i]);
// Распечатка массива структур в функции
StudentArrayPrint( pStudent , sizeof(Group)/sizeof(Student) );
Описание Функции печати массива структур:
void StudentArrayPrint( Student * pMas , int Razm )
{ for ( int i = 0 ; i < Razm ; i++ ) StudentPrint(pMas[i]); };
Результат работы:
Группа студентов:
Структура Student в функции:
Фамилия - Василий
Имя - Сидоров
Курс – 2 …

ЛР №6 5.6 Функция копирования
(МУ, DOC) (2016) через (VS –ЛР № 6)
Описание функции
(описание поместим в файл second.cpp):
void CopyStudent ( Student * Dest ,Student * Source) {
Dest->Kurs = Source->Kurs;
Dest->Stipen = Source->Stipen;
strcpy_s(Dest->Name, Source->Name);
strcpy_s(Dest->Fam, Source->Fam); };
Прототип функции (разметить в файле проекта header.h)
void CopyStudent ( Student * Dest ,Student * Source);
Использование и результат (текст в главном модуле first.cpp):
printf("ДО COPY:\n");
StudentPrint(S1);
StudentPrint(S2);
// 5.9 Вызов Функции копирования структур
CopyStudent ( &S2 , &S1 );
printf("ПОСЛЕ COPY:\n");
StudentPrint(S1);
StudentPrint(S2);

ЛР №6 5.7 Функция обмена
(МУ, DOC) (2016) через (VS –ЛР № 6)
Описание функции
(описание поместим в файл second.cpp):
void SwapStudent(Student * S1 ,Student * S2)
{ Student Stemp;
CopyStudent ( &Stemp , S1 );
CopyStudent ( S1 , S2 );
CopyStudent ( S2 , &Stemp );};
Прототип функции (разметить в файле проекта header.h)
void SwapStudent(Student * S1 ,Student * S2);
Использование и результат (текст в главном модуле first.cpp):
printf("ДО SWAP:\n");
StudentPrint(S1);
StudentPrint(S2);
SwapStudent( &S1 , &S2);
printf("ПОСЛЕ SWAP:\n");
StudentPrint(S1);
StudentPrint(S2);
ДО SWAP:
Фамилия - Иванов2 Имя - Петр2 Курс - 3 Стипендия - 10000.00 р.
Фамилия - Петров Имя - Иван Курс - 1 Стипендия - 2000.00 р.
ПОСЛЕ SWAP:
Фамилия - Петров Имя - Иван Курс - 1 Стипендия - 2000.00 р.
Фамилия - Иванов2 Имя - Петр2 Курс - 3 Стипендия - 10000.00 р.

ЛР №6 5.8 Перечисления
(МУ, DOC) (2016) через (VS –ЛР № 6)
5.8. Использование перечислений
по варианту (СМ)

ЛР №6 5.9 Заполнение массива ДСЧ
(МУ, DOC) (2016) через (VS –ЛР № 6).
Цикл
заполнения (текст в главном модуле first.cpp):
const int Rzm = 4; // Размер массива
Student Potok[ Rzm ]; // Статический массив для заполнения
// Для запуска новой последовательности случайных чисел
srand( (unsigned) time( NULL ) );
//srand( (unsigned) NULL ); // Если NULL // Цикл заполнения массива структур
for (int i = 0 ; i < Rzm ; i++ )
{ k = ( 6 *rand() / RAND_MAX ) +1 ; // СЛУЧАЙНЫЙ Курс 1-6
St = 1000.0f * 10.0f * rand() / RAND_MAX ; // СЛУЧАЙНЫЙ Размер стип.(0 - 10000)
Potok[i].Kurs = k;
Potok[i].Stipen =St;
strcpy_s (Potok[i].Fam, "Фамилия"); // Фамилию не генерируем, у всех
strcpy_s (Potok[i].Name, "Имя"); }; // Имя тоже не генерируем
printf("После Заполнения:\n");
StudentArrayPrint(Potok , Rzm); // Печать заполненного массива
После Заполнения:
Фамилия - Фамилия
Имя - Имя
Курс - 4
Стипендия - 7926.88 р.
Структура Student в функции: ……

ЛР №6 Структуры и массивы
Массивы – набор однотипных переменных, а структуры содержат элементы
разных типов.
У массивов их имя содержит адрес (указатель на массив)
Для задания адреса структурной переменной используется операция именования ("&") Пример: &S1
Структуры фактически определяют новый тип данных , а массивы нет.
Можно задать массив структур и в структуре определить поля – массивы члены - данных.

ЛР №7 Теория Общее
Файлы (МУ, DOC) через (VS –ЛР № 7)
Данные в программах
(СМ). Ввод вывод уровни (СМ)
Понятие файла (СМ1) (СМ2). Файлы и ОС (СМ).
Именование файлов (СМ). Ошибки их обработка (СМ) и их коды (СМ).
Открытие и закрытие файлов (СМ). Функции открытия и закрытия (СМ)
Операции с файлами (СМ). Навигация по файлам (СМ)
Уровни вода и вывода (СМ). Библиотеки работы с файлами (СМ)
Текстовые и бинарные/двоичные файлы (СМ)
Конец файла и его проверка (СМ)
Файл менеджеры (СМ)
Работа с содержимым файла и файлом целиком (СМ)
Примеры работы с файлами (СМ)
Контрольные задания (СМ).
Структура описания файла (СМ), дескрипторы файлов (СМ)

ЛР №7 Данные в программах
После завершения программы мы можем результат увидеть/получить так:
Вывести результаты
на экран дисплея и их посмотреть.
Можно результат посмотреть в ОП отладчике VS (окно просмотра локальных и глобальных данных)
Результат записать на “бумажке” (немного в шутку, но так тоже можно)
Вывести результат на устройство печати (т.н. бумажная твердая копия).
Записать результаты на внешний носитель относительно программы и CPU (диски, флэшки и т.д.). Для этого нужно сформировать/записать данные в электронный файл! (СМ)
Программа на ЯП
Результат работы программы
Программа на ЯП
Файл исходных данных
Файл результатов

ЛР №7 Понятие файла (1)
Файл – это поименованная(1) совокупность информации(2), определенного типа организации(3)
и расположенная в определенном месте(4) памяти (внешней или внутренней) компьютерной системы, представленная в электронном виде.
Файл – это часть внешней памяти компьютера, имеющая идентификатор (имя) и содержащая данные
Файл – это поименованная совокупность единиц хранения информации (например, байт), расположенных в распознаваемом порядке (например, последовательно) и имеющий специальное обозначение конца совокупности данных
Программный Файл – это поименованная и упорядоченная совокупность команд (инструкций, операторов, процедур, функций, подпрограмм и т.д.), которые предназначены для выполнения на компьютере (*.exe, *.com , *.dll и т.д.).

ЛР №7 Понятие файла (3). Свойства
Файл (определение) – это поименованная совокупность информации, определенного
типа организации и расположенная в определенном месте памяти (внешней или внутренней) компьютерной системы, представленная в электронном виде. Главное для файлов (свойства):
Файлы имеют уникальные имена (символы до 32 длина имени (СМ)
Файл имеет тип организации данных в файле (задается расширением имени файла !!!???) - (СМ)
Файл имеет дату создания и дату последнего изменения, размер
Файл имеет местоположение
Файлы (их содержимое) можно увидеть только с помощью других программ (ФМ, WORD и др.) файлы "не осязаемые"
Файлы бывают: программные, символьные, строковые, файлы БД, двоичные, текстовые, системные и пользовательские и т.д.
В одном месте не могут находится файлы с одинаковым именами и расширениями (СМ)

ЛР №7 Понятие файла (3). Типы.
Файл может рассматриваться как упорядоченная совокупность однородных записей
(одинаковых структурных типов), служащих для хранения и поиска информации (БД).
Файл может рассматриваться как упорядоченная совокупность символов( длинная строка)(СМ).
Файл – это поименованная и упорядоченная совокупность строк, причем, в зависимости от назначения, строки могут быть как NTS (Null Terminated String), либо завешаться специальным символом конца строки - (‘\n’ – ‘0A0DH’).(СМ)
Файл может рассматриваться как совокупность страниц (Page) или даже как совокупность бит информации.
Файл может представлять закодированные определенным способом рисунки (совокупность разноцветных точек) или мелодии (звуковые файлы – коды нот) и т.д.
Самыми простыми по организации являются текстовые файлы. О запоминаются побайтно (СМ). или построчно (СМ).

Байтовая структура файла
Файл заполненный байтами можно представить так:
EOF – (End Of File) –
специальный байт задающий конец файла (код русской буквы - ‘я’), этот факт можно использовать при чтении файла в цикле.
Проверку достижения конца файла можно выполнить также функцией feof().

ЛР №7 Именование файлов
Имя конкретного файла в ОС задается текстовой строкой в следующем
формате(имя и расширение):
<имя файла>[.<расширение имени файла>]
Примеры названий файлов:
“Баллада о детстве - В.Высоцкий.mp3” – имя звукового файла,
DATABASE.MDB – файл БД MS Access.
Sample.txt – двоичный текстовый файл.
Пример – имя файла без расширения.
Длина имени и расширения в современных ОС практически не ограничивается, но удобнее работать с короткими и понятными именами.
Расширение файла часто определяет тип его организайии.

ЛР №7 ОС и файлы
Во-первых, любая работа с файлами всегда выполняется под управлением
ОС (Операционной системы Служба – Файловая система.).
Понятия устройств и файлов обобщены в ОС до понятия потока ввода и вывода (Стандартные и пользовательские).
Под потоком ввода понимается чтение информации с клавиатуры или любого файла (stdin).
Под потоком вывода понимается вывод информации на экран монитора или в любой текстовый файл (stdout).
Стандартные потоки ввода и вывода имеют фиксированные названия и могут использоваться во всех программах.
Кроме перечисленных, в языке СИ доступен стандартный поток вывода информации об ошибках – stderr.
Кроме стандартных пользователи могут описать произвольное число собственных потоков ввода и вывода, связанных с файлами (см. структуру – FILE - СМ).

ЛР №7 Файл Менеджеры
Специальные системные программы позволяют удобно работать с файлами. Они называются
Файл менеджеры(ФМ):
ФМ предназначены для удобной и всесторонней работы с файлами
FAR - Manager
Total Commander
(также Windows Commander – немного устарел)
Работа с командами в режиме командной строки (cmd.exe) КС (СМ)
С ФМ можно выполнить любые действия с файлами:
Создание файлов,
Просмотр и Редактирование,
Копирование и перемещение,
Поиск,
Удаление,
Создание и удаление каталогов (папок),
Архивирование файлов и многое, многое, другое.

ЛР №7 ФМ - FAR
Для удобной работы ФМ имеют 2 панели (левую и
правую).
Клавиша TAB – переключение между панелями. Меню внизу определяет возможные действия (копирование, просмотр, удаление, редактирование).

ЛР №7 ФМ - Total Commander
ФМ - Total Commander - работает в среде
Windows.
Внизу расположено меню - подсказка и поле для ввода команд ОС (командная строка). Расширенное меню расположено выше панелей.

ЛР №7 Командная строка
Запуск cmd.exe (возможен ввод любой команды ОС):
> exit - завершение
cmd.exe

ЛР №7 Текстовые и бинарные (двоичные) файлы (1)
Различают такие основные разновидности файлов: текстовые
файлы и бинарные файлы. Рассмотрим теперь, в чем заключается различие между ними.
Тип файлов задается при их открытии (“wt” или “wb” или “rt” или “rb” ) (СМ).
Главное различие текстовых и бинарных файлов заключается в способе представления цифровых данных (чисел) в самих файлах. Символьные данные представляются одинаково (посимвольно).
Рассмотрим шестнадцатеричное и символьное представления файлов.
Для текстового файла такая распечатка выглядит так (целые числа представлены символами – код “1” - “31” и “2” - “32”, между ними пробел “20”):
Адр.: Шестнадцатеричное представление |Символьное представление
0000: D1 F2 F0 EE EA E0 31 20| 21 21 21 20 31 20 32 20|Строка1 !!! 1˽2……
В бинарных файлах цифровое представление данных из оперативной памяти побайтно копируется в файл во внутреннем представлении данных, т.е. копируются цифровые байты и биты, а не числовые символы. В текстовых файлах все записывается символами.
Для бинарного файла такая распечатка выглядит так (целое число 2 – представлено машинном виде двумя байтами с измененным порядком следования– “0200”):
Адр.: Шестнадцатеричное представление |Символьное представление
0000: C8 E2 E0 ED EE E2 00 7F| 30 32 00 00 00 00 00 00|Иванов_02........
0000: 00 00 00 00 00 00 00 00| 00 00 C9 42 02 00 00 00|......................
Дополнительно См. Методические указания к ЛР № 7. (показать в FAR!) (СМ)

ЛР №7 Текстовые и бинарные (двоичные) файлы (2)
Для проверки сказанного рассмотрим фрагмент записи
в файл.
// Структура для вывода в двоичный файл
struct Person { // Структура для примеров
char Name[24]; // Фамилия
float Stipen; // Стипендия
int Kurs; // Курс
};
// Описание струкутуры и вывод
Person P1 = {"Иванов_02", 100.5f , 2 };
…
FILE * pF = fopen( "txtbin.out" , "wb"); // Открыть для записи
fwrite( &P1, sizeof(Person) , 1, pF);
…
fclose(pF);
Файл затем нужно закрыть и выполнить его просмотр файловым менеджером содержимого файла - "txtbin.out" (например, FAR) в комбинированном режиме просмотра (СМ).

ЛР № Открытие и закрытие файлов
Для успешной работы с файлом и программа и
ОС должны проверить следующее:
существует ли файл с заданным именем в указанном каталоге (текущий каталог или по пути - Path),
доступен ли он для работы в программе (атрибуты – состояние файла), и в каких допустимых режимах,
не занят ли этот файл в данное время другой задачей – работающей сейчас и использующей этот файл (системы многозадачности).
Эти действия выполняются специальными командами и функциями (СМ), которые работают под управлением ОС, и вызывают открытие файла (open file) для дальнейшей работы:
Функции: fopen и _open открывают файлы для разных режимов. Только после успешного открытия файл доступен в программе!
После завершения работы с фалом он должен быть закрыт:
Функции: fclose и _close закрывают файлы для разных режимов.
Для работы с файлами используются специальные структуры (FILE) и дескрипторы файлов(FP). Предусмотрена возможность анализа ОШИБОК!

ЛР № Функции Открытия и закрытия(1)
Функции: fopen и _open открывают файлы для разных
режимов. Только после успешного открытия файл доступен в программе! Прототип :
FILE * fopen(<Имя файла> , <режим открытия>);
int ER; // Переменная для фиксации ошибок открытия
FILE *pF ; // Структура FILE для дескриптора файла
Пример вызова функции открытия файла:
pF = ("test.txt" , "w"); // Открыть текстовый файл для чтения или (wt)
ER = errno ; //Проверить код ошибки errno–Системная переменная
Если файл не может быть открыт, то структура дескриптора содержит код ошибки и значение ( NULL – файл не открыт!). Типы ошибок(СМ) для errno
После завершения работы с фалом он должен быть обязательно закрыт:
Функции: fclose и _close закрывают файлы для разных режимов.
Прототипы функций закрытия:
fclose(<Дескриптор>) ;
fcloseall( void) ; // закрыть все открытые файлы
Пример закрытия файла :
fclose(pF ) ; // Закрыть файл открытый ранее с pF
Для работы с файлами используются специальные дескрипторы (FILE) - (FP).

ЛР №7 Режимы открытия файлов
Для правильной работы с файлом (тип доступа) его нужно
открыть с соответствующем режиме (второй параметр функции open) (МУ):
"r" - открыть текстовый файл только для чтения (read), если файла нет то ошибка.
"w" - открыть или создать текстовый файл для записи(write), для созданных файлов содержимое очищается
"a" - открыть текстовый файл для добавления (append) записей в его конец, файл создается, если он не был создан .
"rb" - открыть ,бинарный файл только для чтения, если файла нет то ошибка.
"wb" - открыть или создать бинарный файл для записи, для созданных файлов содержимое очищается.
"ab" - открыть бинарный файл для добавления записей в его конец, файл создается, если он не был создан.
"r+" - открыть текстовый файл для чтения и записи, если файла нет то ошибка.
"w+"- открыть или создать текстовый файл для чтения и записи, для созданных файлов содержимое очищается.
Примеры см. (МУ, DOC ).

ЛР №7 Коды ошибок с файлами
При работе с файлами могут возникнуть ошибки (errno),
которые нужно проверить(некоторые показаны в таблице).коды:

ЛР №7 Проверка ошибок
Коды ошибок (СМ) позволяют уточнить ошибок (
):
…
#include
// коды ошибок
…
FILE pF= fopen("test333.txt" , "r"); // ошибка открытия файла (нет файла)
if(pF==NULL) printf("Ошибка!\n");
// Вспомогательная переменная
int err = errno; // errno Системная переменная, содержащая // ENOENT == 2 нет такого файла
if(err==ENOENT)printf("Нет такого файла!\n");
//Проверка возможности закрытия файла
if(pF!=NULL)
fclose(pF); // Закрытие файла с дескриптором pF

ЛР №7 Операции с файлами
Операции и функции для работы с файлами могут быть
разделены на две группы:
Действия над внутренними данными (содержимым) конкретного файла и
Действия над файлом в целом как отдельной единицей (СМ).
Создание файла, обычно происходит при открытии файла (open, fopen, create). Функции открытия и закрытия (СМ):
Открытие файла (_open, fopen).
Закрытие файла (_close, fclose).
Действия над содержимым конкретного файла (СМ):
Операция чтения данных из файла (_read, fread, fgetc, fgets, fscanf).
Операция записи данных в файл (_write, fwrite, fputc, fputs, fprintf ).
Перемещение текущего указателя чтения и записи для файла и его определение (fsetpos , fseek).(СМ)
Определение ситуации достижения конца файла(СМ) после чтения текущей записи (_eof, feof)
Получение дескриптора файла в структуре FILE (_fileno) (СМ).

ЛР №7 Операции с файлами
Для работы с внутренними данными файла предусматриваются следующие основные
операции и функции:
Создание файла, обычно происходит при открытии файла (open, fopen, create).
Открытие файла (_open, fopen).
Закрытие файла (_close, fclose).
Операция записи части данных в файл (fwrite, _write, fputc, fputs, fprintf ). (СМ)
Операция чтения части данных из файла (fread, _read, fgetc, fgets, fscanf). (СМ)
Перемещение текущего указателя для файла и его определение (fsetpos , fseek). (СМ)
Определение ситуации достижения конца файла после чтения записей (_eof, feof)(СМ)

ЛР №7 Двоичные файлы и функции fwrite (запись)
Структура для записи файла:
struct Person {
// Структура для примеров
char Name[24]; // Фамилия
float Stipen; // Стипенд файлаия
int Kurs; }; // Курс
FILE * pF; // Дескриптор файла
// Массив структур для записи в файл – безразмерная инициализация
Person MasPers [] = { {"Иванов", 10.5f , 1 } , {"Петров", 100.5f , 2 } , {"Сидоров", 1000.5f , 3 }};
Цикл записи файла на основе этого инициализированного массива структур. Файл открываем для записи как двоичный ("wb"). Число циклов вычисляется от размера структурного массива:
if (pF!=NULL) {// Файл открыт
for ( int i = 0 ; i < sizeof(MasPers)/sizeof(Person); i++)
{
MasPers[i].Kurs = i+10;
fwrite( &MasPers[i], sizeof(Person) , 1, pF); // Вывод записи
fclose(pF); }
};

ЛР №7 Двоичные файлы и функции fread (чтение)
Цикл чтения бинарного файла из структурных
записей:
F = fopen( "fwrite.bin" , "rb"); // Открытие файла для чтения
if (pF!=NULL)
{ Person PWork;
while (!feof(pF) ) // Проверка конца файла
{
fread( &PWork, sizeof(Person) , 1, pF); // Чтение одной записи из файла
if ( !feof(pF) ) // Можно ли печатать? Нет ли уже конца файла?
printf( "Персона из файла: %s %f %d\n", PWork.Name , PWork.Stipen , PWork.Kurs ); };
};
Результат чтения файла:
Персона из файла: Иванов 10.500000 10
Персона из файла: Петров 100.500000 11
Персона из файла: Сидоров 1000.500000 12

ЛР №7 Конец файла и его проверка
При обработке файлов (особенно при чтении)
необходимо знать, при каких условиях цикл чтения записей должен быть остановлен. Для этого нужно установить конец файла. В программе это можно сделать так:
Узнать размер файла и подсчитывать текущее число символов
Проверить конец файла специальной функцией СИ( _eof или feof – End Of File).
Проверить после операции чтения специальный байт конца файла – EOF .
Проверить значение текущего числа байтов, полученных из файла к данному моменту цикла чтения, и оценить по этой величине установить факт завершения или продолжения цикла чтения файла (должно быть прочитано нуль байт) – например, функции fread или _read.
Для определения размера файла можно использовать функцию _filelength:
printf("Длина файла = %ld \n",_filelength (pF->_file));
Проверка символа EOF может быть сделана так:
char ch = fgetc(pF); // ЧТЕНИЕ байта ,можно и просто if ( ! (ch== EOF) ) // Проверка символа конца файла EOF
Проверка функцией feof :
if ( !feof (pF) ) // Проверка конца файла
Проверка после чтения (ReadCounter = 0 при конце файла):
int ReadCounter = fread (&PWork,sizeof(Person) , sizeof(Person),pF);

ЛР №7 Работа с файлами целиком
Действия над файлом в целом как отдельной единицей.
Переименование
файла (rename)
Удаление файла (remove)
Установка и изменение атрибутов файла (chmod, access).
Определение размера файла (_filelength)
Определение имени файла и его местоположения (_fullpach, div)
Изменение потока для файла (reopen)
Все Системные команды ОС для работы с файлами (system).
И многие другие команды и функции доступные в ОС (type и др.).

ЛР №7 Навигация по файлам
Для перемещения текущего указателя чтения/записи по файлу используется функция
fseek (_lseek) .
// Перемещение указателя на новую позицию 3 (Pos -1), подсчет идет с нуля
PosNew = fseek( pF, (Pos - 1)*sizeof(Student), SEEK_SET);
При перемещении указателя мы может смещаться от позиции начала файла (SEEK_SET) , позиции конца файла(SEEK_END) и текущей позиции в файле (SEEK_CUR).
После перемещения запись или чтение выполняется с этой позиции. Для выполнения и записи и чтения двоичный файл открывается в режиме (r+b):
FILE * pF = fopen( "BDStud57.bin" , "r+b"); // Открытие файла для чтения и записи

ЛР №7 Библиотеки для работы с файлами
Для работы с файлами в СИ предусмотрены
функции и их библиотеки, которые подключаются так:
Библиотека ввода и вывода Си – RTL:
#include
// Основная библиотека ввода и вывода Си - RTL
#include
// Константы ввода и вывода
#include
// Функции низкоуровневого ввода и вывода
#include
// Константы управления файлами
#include
// Консольный ввод и вывод
#include
// Константы в/в
#include
// Константы в/в
#include
// Константы errno
В Подключение в С++
#include
и перед main
using namespace std;

ЛР №7 Структура FILE, Дескрипторы
Структура FILE для работы с файлами в этом режиме
показана ниже. Как видно из описания это имя объявлено описателем typedef.
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file; // Дескриптор (номер) открытого файла
int _charbuf;
int _bufsiz;
char *_tmpfname; };
typedef struct _iobuf FILE; // Задание типа структуры FILE
Дескрипторы нужны ОС и программисту для идентификации файла.
Поля структуры можно использовать в программе, например _file, показывает номер открытого файла.
Описание дескрипторов:
FILE * pFile;

ЛР №7 Примеры работы с файлами
(МУ, DOC) (2016) через (VS –ЛР № 7)
(Теория ЛР №7)
Работа с текстовым/двоичным файлом побайтно – (СМ) DOC -3.13
Работа с текстовым файлом построчно (СМ) DOC -3.14
Двоичные файлы и функции fread и fwrite (СМ) DOC-3.15
Двоичные файлы и функции,_read и _write (низкий уровень) (СМ)
Форматированный ввод и вывод в файлы (СМ) DOC-3.16
Низкоуровневый ввод и вывод в СИ (СМ) DOC-3.17
Навигация по файлам. Функции - fseek, lseek (СМ) DOC-3.18
Файл менеджеры (СМ)
Работа с файлами средствами ОС (СМ) DOC-3.21
Работа со строками и консолью : sscanf, cprintf и sprintf DOC-3.22
Задания программы с использованием файлов (СМ) Перенаправление потоков ввода и вывода (СМ) DOC-3.19

ЛР №7 Задания Общее
(МУ, DOC) (2016) через (VS –ЛР № 7) (Теория ЛР
№7)
5.2 Запись простого файла текстовыми данными (СМ). (fprintf)
5.2 Создание файла с текстовыми данными (СМ). Вар 2 (fputs)
5.2 Распечатка текстового файла (СМ).
5.3 Функция распечатки текстового файла (СМ).
5.4 Запись файла своих структур (СМ) - фрагмент (СМ).
5.5 Распечатка файла своих структур фрагмент (СМ).
5.5 Функция распечатки одной структуры (СМ).
5.6 Создать функцию распечатки файла своих структур (СМ).
5.7 Создание файла на основе массива фрагмент (СМ).
5.8 Функция записи файла на основе массива (СМ).
5.9 Создание массива на основе файла фрагмент (СМ).
5.10 Функция записи массива на основе файла (СМ).
5.11 Функция распечатки массива структур (СМ).
5.12 Слияние двух файлов в третий фрагмент (СМ).

ЛР №7 5.3 Функция распечатки файла
Описание функции (second.cpp):
void PrintTextFile (char * Filename)
{ FILE *pF;
char buf[80];
// Буфер для ввода из файла
pF = fopen( Filename , "r+");
for ( int i = 0 ; !feof(pF) ; i++)
{ fscanf( pF , "%s" , buf ); // Ввод форматированных данных - разделитель пробел
if ( !feof(pF) )
printf( "'%s'\n", buf ); } // Печать данных из файла
fclose(pF); return; };
Вызов функции (first.cpp):
PrintTextFile ("file52.out" );
Результат:
'Иванов'
'Петров'
'Сидоров'
…

ЛР №7 5.2 Текстовый файл (fprintf)
Создать и заполнить в цикле текстовый файл из
массива строк. Массив инициализируется строками с фамилиями студентов вашей группы. После создания файл (а не массив!) прочитать его распечатать (type и printf – функция форматированного вывода). Продемонстрировать преподавателю содержание файла с использованием файл менеджера (можно Far).
Описание массива строк и создание файла:
char MasFIO [20][20] = {{"Иванов"},{"Петров"} , {"Сидоров"} , {"Козлов"} };
FILE *pF52;
pF52 = fopen( "file52.out" , "w+"); // Открытие файла для записи
for (int i = 0 ; i < 5; i++) // Число циклов здесь задается константой - 4 (<5)
{
fprintf (pF52 , "%s\n" , &MasFIO[i][0]); //
}; fclose(pF52); // Закрытие файла
system( "type file52.out" ); // чтение файла системной командой
Распечатка в цикле (СМ).

ЛР №7 5.2 Текстовый файл (fputs, fgets)
Запись файла:
pF52 = fopen( "file522.out" , "wt+");
//
if (pF52!=NULL)
{ char MasFIO [20][20] = {{"Иван"},{"Петр"} , {"Сидор"} , {"Василий"} };
for (int k=0 ; k < 4 ; k++)
{ fputs(&MasFIO[k][0], pF52);
fputs( "\n", pF52); }
}
fclose(pF52);
Чтение и распечатка файла:
char Buf[80];
for ( int i = 0 ; !feof(pF52) ; i++)
{ fgets(Buf,80,pF52);
printf( "gets(%d): %s\n", i ,Buf ); // Печать данных из файла

ЛР №7 5.5. Своя структура
Своя структура для примеров ЛР№ 7:
struct Student { //
Структура со статическими строками
char Name[20]; // Имя студента
char Fam[20]; // Фамилия студента
int Kurs; // Курс студента
float Stipen; // Размер стипендии студента
Пример описания массива типа Student:
Student MasStud [] = { {"Гусев", "Иван" , 1 , 11.5f} , {"Уткин", "Петр" , 2 , 120.5f} , {"Синицын", "Олег" , 3 , 100.5f}};
и переменной nbgf Student :
Student StGuimc = {{"Гусев", "Антон" , 2 , 200.5f};

ЛР №7 5.4 Запись Файла своих структур
Массив структур:
Student MasStud [] = { {"Гусев",
"Иван" , 1 , 11.5f} , {"Уткин", "Петр" , 2 , 120.5f}
, {"Синицын", "Олег" , 3 , 100.5f}};
Откроем файл и запишем в цикле в него из массива:
FILE * pF54 = fopen( "BDStud54.bin", "wb"); // Открытие файла для записи
int Razm = sizeof(MasStud)/sizeof(Student); // Размер массива для цикла
Цикл записи структур в файл:
for ( int i = 0 ; i < Razm; i++)
fwrite( MasStud + i, sizeof(Student) , 1, pF54);
fclose(pF54);

ЛР №7 5.5 Распечатка файла структур
Student SWork; // Буфер для чтения
pF54 =
fopen( "BDStud54.bin" , "rb"); //
if (pF54!= NULL)
Цикл чтения и распечатки файла своих структур:
while (!feof(pF54) ) // Проверка конца файла
{fread( &SWork, sizeof(Student) , 1, pF54); // Чтение одной записи из файла
if ( !feof(pF54) ) // Можно ли печатать? Нет ли уже конца файла?
printf( "Студент из файла: Фамилия - %s Имя- %s Стипендия - %f Курс - %d\n", SWork.Fam ,SWork.Name , SWork.Stipen , SWork.Kurs ); };
fclose(pF54);
};

5.12 Слияние двух файлов в третий (1)
Функция слияния 2-х файлов:
void StudMergeFiles ( const
char * FileMerge, const char * FileName1 ,const char * FileName2 )
{ FILE * pF1;
FILE * pF2;
FILE * pFMerge;
Student2 SBuf;
int flag = 0;
pF1 = fopen( FileName1 , "rb"); // Открытие 1 для чтения
pF2 = fopen( FileName2 , "rb"); // Открытие 1 для чтения
pFMerge = fopen( FileMerge , "w+b"); // Открытие 1 для записи
// 1-й цикл записи
while (!feof( pF1 ))
{ fread( &SBuf, sizeof(Student2) , 1, pF1); // чтение одной записи файл 1
if (!feof(pF1))
fwrite( &SBuf, sizeof(Student2) , 1, pFMerge); };
(см. следующий слад)
// 2-й цикл записи
while (!feof( pF2 )) {
fread( &SBuf, sizeof(Student2) , 1, pF2); // чтение одной записи файл 2
if (!feof(pF2))
fwrite( &SBuf, sizeof(Student2) , 1, pFMerge); };

5.12 Слияние двух файлов в третий (2)
Функция слияния 2-х файлов (завершение)
…
fclose( pF1 );
Fclose
(pF2 );
fclose( pFMerge );}
Вызов и результат:
printf( "Контрольные задания !!!!!\n");
printf( "Контрольные задания поз 5.12 !!!!!\n");
printf(" Функция StudMergeFiles!\n" ); //
StudMergeFiles ( "BDMerge.bin","BDStud54.bin","BDStud58.bin");
printf("ПЕРВЫЙ!\n" ); //
StudPrintFile("BDStud54.bin");
printf("ВТОРОЙ!\n" ); //
StudPrintFile("BDStud58.bin");
printf("РЕЗУЛЬТАТ: ПЕРВЫЙ + ВТОРОЙ!\n" ); //
StudPrintFile("BDMerge.bin");

5.12 Слияние двух файлов в третий (3)
Результат слияния:
Контрольные задания !!!!!
Контрольные задания поз 5.12
!!!!!
Функция StudMergeFiles!
ПЕРВЫЙ!
Фамилия - Иван Имя - Гусев Курс - 1 Стипендия - 11.50 р.
Фамилия - Петр Имя - Уткин Курс - 2 Стипендия - 120.50 р.
Фамилия - Олег Имя - Синицын Курс - 3 Стипендия - 100.50 р.
ВТОРОЙ!
Фамилия - Иван Имя - Гусев 2 Курс - 1 Стипендия - 11.50 р.
Фамилия - Петр Имя - Уткин 2 Курс - 2 Стипендия - 120.50 р.
Фамилия - Олег Имя - Синицын 2 Курс - 3 Стипендия - 100.50 р.
РЕЗУЛЬТАТ: ПЕРВЫЙ + ВТОРОЙ!
Фамилия - Иван Имя - Гусев Курс - 1 Стипендия - 11.50 р.
Фамилия - Петр Имя - Уткин Курс - 2 Стипендия - 120.50 р.
Фамилия - Олег Имя - Синицын Курс - 3 Стипендия - 100.50 р.
Фамилия - Иван Имя - Гусев 2 Курс - 1 Стипендия - 11.50 р.
Фамилия - Петр Имя - Уткин 2 Курс - 2 Стипендия - 120.50 р.
Фамилия - Олег Имя - Синицын 2 Курс - 3 Стипендия - 100.50 р.

ЛР №8 Теория
Списки (МУ, DOC, Примеры, Задания) (VS –ЛР № 8) :
Понятие список
(СМ)
Назначение списков (СМ) и их разновидности (СМ). По структуре (СМ)
Списковые структуры (СМ)
Списки и их элементы. Голова и хвост списка. (СМ)
Ручная работа со списком (СМ)
Однонаправленные и двунаправленные списки (СМ).
Навигация по спискам в циклах (СМ).
Сравнение списков и массивов (СМ)
Операции со с писками: занесение, удаление, очистка (СМ)
Статические и динамические списки (СМ)
Библиотеки классов для работы со списками (СМ)
Примеры списковых программ (СМ)
Контрольные задания ЛР № 8 (СМ)

ЛР №8 Понятие список 1
Список – это структура данных, в которой данные расположены
в определенной последовательности, порядок в которой задается с помощью адресации. Для этой цели используются переменные типа указатель. Примеры списка:
Единицей хранения информации является элемент списка, он описывается с помощью специальной структурной переменной (СМ).

ЛР №8 Понятие список 2
Структура элемента списка содержит две части:
Адрес следующего элемента (для
связности списка) – pNext
Информация элемента списка – ListVal (пусть тип int )
СОГЛАШЕНИЕ: Адрес последнего элемента списка равен NULL!!! (нулю)
Тогда структуру элемента списка можно описать так:
// Структура самого простого элемента списка
struct ListElem{
ListElem * pNext; // адрес следующего элемента списка (Заметьте, указатель имеет тип (Elem *))
int ListVal; // информация, содержащаяся в списке
};
Один такой элемент может быть описан так:
// Описание и инициализация элемента Lfirst
ListElem LFirst = { NULL , 3 };
// NULL – нулевой указатель – нет ссылки на другие элементы

ЛР №8 Виды списков
Информация в списках может быть размещена по-разному:
В этом случае структура
элемента списка отличается от простейшей.

ЛР №8 4 Списки и массивы
Сравнение списков и массивов в СИ/СИ++:
И списки и
массивы используются для хранения упорядоченных данных
В массивы трудно добавлять и удалять элементы
Единицы хранения называются: элементы массива и элементы списка.
Размер массива трудно изменить (он фиксирован) в списках вообще не задается размер списка.
Списки позволяют более эффективно использовать память компьютера, за счет использования механизмов динамической памяти:
Сам список и его все его элементы могут быть динамическими.
В массивах часть памяти может не использоваться (размер с запасом)
В списке трудно получить содержание элемента по номеру , а в массиве легко, за счет индекса
Трудно определить размер списка, в массиве он задан первоначально.
Все элементы массива имеют один тип
Список можно создать с разнотипными элементами (void *)

ЛР №8 Голова и хвост списка
Понятия, связанные со списками:
ГОЛОВА СПИСКА (HEAD - первый
элемент списка, его адрес)
ХВОСТ СПИСКА (TAIL – последний элемент списка, его адрес).
Голова списка используется для хранения адреса начала списка в структурах и параметрах функций. Хвост списка – для хранения адреса конца списка (в структурах и параметрах функций).

ЛР №8 Ручная работа со списком
Описание и связывание (для структуры элементного списка (СМ)):
//
Описание и инициализация элементов списка – трех:
Elem LE3 = { NULL , 3 }; // NULL – нулевой указатель – нет ссылки на другие элементы
Elem LE2 = { &LE3 , 2 }; // &LE3 - задание адреса третьего элемента в pNext
Elem LE1 = { &LE2 , 1 }; // &LE2 - задание адреса второго элемента в pNext
Печать списка в цикле:
printf ("Печать списка в цикле: \n" );
Elem * pETemp = &LE1; // Во временную переменную - указатель задаем адрес первого элемента
while ( pETemp != NULL)
{ printf ("Элемент простого списка Elem: %d \n" , pETemp->ListVal);
pETemp = pETemp->pNext; }; // НАВИГАЦИЯ: Важнейший оператор для работы // со списком
Результат :
Печать списка в цикле:
Элемент простого списка Elem: 1
Элемент простого списка Elem: 2
Элемент простого списка Elem: 3

ЛР №8 Однонаправленные и двунаправленные списки
Возможны два способа связывания списков:
Однонаправленный (навигация в одном
направлении) и
Двунаправленный ( возможна навигация в двух направлениях)
В двунаправленном списке в элементе используется второй адрес (pPrev).

ЛР №8 Навигация в списках
Навигация в списках выполняется с помощью оператора присваивания. Для
этого используется вспомогательная переменная типа указатель на элемент списка:
Elem * pETemp = &Head; // Голова списка
Навигация в прямом направлении (однонаправленный список):
pETemp = pETemp->pNext; };
Навигация в обратном направлении (двунаправленный список):
pETemp = pETemp->pPrev;
Виды списков (СМ).

ЛР №8Списковые структуры (1)
Описания структур списков(МУ, DOC):
Список (СМ) на базе элемента структуры(Elem):
// Самый
простой элемент списка
struct Elem{
Elem * pNext; // адрес следующего элемента списка
int ListVal; }; // информация, содержащаяся в списке

ЛР №8 Операции для списков
Основные общие операции для работы со списками (МУ, DOC):
Создание
нового списка (Выделение ОП под элементы)
Добавление нового элемента в список (в голову, в хвост и по номеру).
Удаление элемента из списка (из головы, с хвоста и по номеру)
Очистка всего списка
Распечатка всего списка
Замена местами элементов по номерам (Swap)
Поиск элемента по номеру в списке
Поиск элемента по ключевому параметру
Слияние списков
Разделение списков.

ЛР №8Списковые структуры (2)
Описания структур списков(МУ, DOC):
Список на базе специальной структуры (для елемента
списка СМ):
struct EList{ // Простейшая структура список Elem - элементарный список
Elem * pHead; // Голова списка
Elem * pTail; // Хвост списка
int Count; }; // Текущий счетчик элементов

ЛР №8 Примеры
Списки (2016)(МУ, DOC, Примеры, Задания) (VS –ЛР № 8) :
Примеры для
ЛР №8 для ЛР №8 (МУ, DOC):
Создание простейшего списка вручную.
Распечатка простейшего списка в цикле (FirstList).
Простейший динамический список (pDList).
Ручная работа с однонаправленным списком на основе элементов.
Ручная работа с однонаправленным списком на основе структуры (MY_List).
Ручное добавление и удаление в голову и хвост.
Распечатка однонаправленного списка с помощью функции.
Очистка статического и динамического списков.
Работа с динамическим списком (указатель - pList).
Работа с двунаправленным списком (My_DList).

ЛР №8 Контрольные задания
Списки(2016)(МУ, DOC, Примеры)(VS –ЛР № 8) :
Контрольные задания для
ЛР №8 (МУ, DOC):
Создать однонаправленный список вручную - 5.1
Распечатать однонаправленный список - 5.2
Создать функцию для распечатки списка - 5.3
Написать программу для добавления элементов - 5.4
Создать функцию для добавления (в голову/хвост) - 5.5/6
Выполнить удаление из списка (из головы/хвост) - 5.7/8
Создать функцию очистки списка - 5.9
Поиск максимума в списке - 5.10
Выполнить сложение двух списков - 5.11

ЛР №8 Назначение списков
Теория ЛР № 8 для (МУ, DOC):
Основное назначение списков
в ОП хранение структурированной информации во время выполнения программ. Похожи на массивы.
Списки и массивы (СМ). Возможности списков:
Списки позволяют более эффективно использовать оперативную память (ОП) компьютера.
Списки позволяют более полно использовать механизмы динамической памяти: и список и его элементы могут быть динамическими.
В массивах элементы одного типа. Эти ограничения снимаются с использованием структур типа список, хотя добавляются и новые недостатки, в частности:
трудно получить доступ к элементу в списке по номеру.
Самым важным преимуществом списков является возможность хранения разнотипных структурных переменных, если использовать для адресации списков указатели типа void.

ЛР №8 Динамические списки
Теория ЛР № 8 для (МУ, DOC):
Для списков (их
структур), их элементов память может быть выделена динамически. Пусть такие структуры списков List (СМ) и их элементов ListElem(СМ):
#include
// ДИНАМИЧЕСКИЕ СПИСКИ
//Выделение памяти для списка
List * pDList = (List *) malloc (sizeof(List));
// Выделение памяти для одного элемента списка (многократно)
ListElem * pTempElem = (ListElem * )malloc (sizeof(ListElem));

ЛР №8 Списки в С++
Теория ЛР № 8 для (МУ, DOC):
В системе
классов СИ++ предусмотрено много возможностей для работы со списками: vector, map, Dlist, list, Clist, CObjList, list и многие другие.
Работу с этими классами вы будете изучать в курсе "Объектно-ориентированное программирование" или в курсе "Программирование на основе классов и шаблонов".
Знания этого семестра вам помогут разобраться с этими классами и создать новые классы!

ЛР №7 5.6 Функция Распечатки файла структур
Описание функции печати файла структур:
void StudPrintFile(
const char * FileName)
{ FILE * pF;
pF = fopen( FileName , "rb"); // Открытие файла для чтения
Student2 SBuf; // Буфер для ввода из файла
while (!feof(pF) ) // Проверка конца файла
{ fread( &SBuf, sizeof(Student2) , 1, pF); // чтение одной записи
if ( !feof(pF) )
StudentPrint (SBuf); };
fclose( pF ); }; // Закрытие файла
Вызов функции и результат:
StudPrintFile("BDStud54.bin");
Фамилия - Иван Имя - Гусев Курс - 1 Стипендия - 11,50 р.
Фамилия - Петр Имя - Уткин Курс - 2 Стипендия - 120,50 р.
Фамилия - Олег Имя - Синицын Курс - 3 Стипендия - 100,50 р.

ЛР №7 5.7 Файл на основе Массива
Программа формирования файла:
Student MasStud57 [] =
{ {"Гусев1", "Иван" , 1 , 11.5f} , {"Уткин1", "Петр" , 2 , 120.5f}
, {"Синицын1", "Олег" , 3 , 100.5f}};
FILE * pF57; // Дескриптор файла
// Открытие файла для записи
pF57 = fopen( "BDStud57.bin", "wb"); // Открытие файла для записи
Razm = sizeof(MasStud57)/sizeof(Student);
for ( int i = 0 ; i < Razm; i++)
fwrite( MasStud57 + i, sizeof(Student) , 1, pF57);
fclose(pF57);
StudPrintFile("BDStud57.bin");
Результат:
Фамилия - Иван Имя – Гусев1 Курс - 1 Стипендия - 11,50 р.
Фамилия - Петр Имя – Уткин1 Курс - 2 Стипендия - 120,50 р.
Фамилия - Олег Имя – Синицын1 Курс - 3 Стипендия - 100,50 р.

ЛР №7 5.7 Функция записи файла на основе массива
Описание функции:
void StudMasToFile( const char
* FileName , Student * pMas , int Razm)
{ FILE * pF;
pF = fopen( FileName, "w+b"); // Открытие файла для записи
for ( int i = 0 ; i < Razm; i++)
fwrite( pMas + i, sizeof(Student) , 1, pF);
fclose(pF); };
Применение функции:
Student MasStud58 [] = { {"Гусев2", "Иван" , 1 , 11.5f} , {"Уткин2", "Петр" , 2 , 120.5f}
, {"Синицын2", "Олег" , 3 , 100.5f}};
int RazmS = sizeof(MasStud58)/ sizeof(Student);
StudMasToFile( "BDStud58.bin" , MasStud58, RazmS);
printf(" Функция StudMasToFile!\n" ); //
StudPrintFile("BDStud58.bin"); // (СМ)

ЛР №7 5.8 Массив на основе файла
Программа записи массива:
FILE * pF59;
pF59 =
fopen( "BDStud57.bin" , "rb"); // Открытие файла для чтения
Razm = _filelength (pF59->_file)/ sizeof(Student); // Размер
Student * pWorkMas = (Student2 * )malloc( Razm*sizeof(Student));
for ( int i = 0 ; i < Razm; i++)
fread( pWorkMas + i, sizeof(Student2) , 1, pF59);
Fclose (pF59);
StudPrintMas(pWorkMas , Razm); (СМ)
Получим:
Фамилия - Иван Имя – Гусев1 Курс - 1 Стипендия - 11,50 р.
Фамилия - Петр Имя – Уткин1 Курс - 2 Стипендия - 120,50 р.
Фамилия - Олег Имя – Синицын1 Курс - 3 Стипендия - 100,50 р.

ЛР №7 5.10 Функция Массив на основе файла
Описание функции:
void StudFileToMas( const char *
FileName , Student ** pMas , int * pRazm)
{ FILE * pF;
pF = fopen( FileName , "rb"); // Открытие файла для чтения
*pRazm = _filelength(pF ->_file) /sizeof(Student);
Student SBuf;
*pMas = (Student * ) calloc( *pRazm , sizeof(Student)); // Выделим ДП
int i = 0;
while (!feof(pF) ) // Проверка конца файла
{ fread( &SBuf, sizeof(Student) , 1, pF); // чтение одной записи
if ( !feof(pF) )
{ memcpy( *pMas + i , &SBuf , sizeof(Student)); i++; }; };
// Закрытие файла
fclose( pF ); };
Использование функции:
Student * pMas;
StudFileToMas( "BDStud57.bin" , &pMas ,&Razm);
printf(" Функция StudFileToMas!\n" ); //
free (pMas); // Это обязательно после использования массива!!!
Получим:
Функция StudFileToMas!
Запись: Имя = Гусев1 Курс = 1 Стипендия = 11.50 …

Циклы
Если фрагмент программы повторяется многократно, то такая программа называется циклической. Для построения цикла
в Си/СИ++ предусмотрены операторы цикла (СМ). Цикл имеет следующую структуру (Предусмотрено 3 части):
Начальные условия (НУ) цикла – выполняются до цикла
Логическое условие завершения (или продолжения ) цикла
Тело цикла – повторяющаяся группа операторов

Операторы управления циклами
В СИ/СИ++ Предусмотрено три разновидности операторов цикла:
Оператор цикла for (СМ) Пример:
for (int i =1 ; i <= 5 ; i++ )
{
printf("Шаг цикла(for) - %d\n" , i); };
Оператор while (СМ) Пример:
int k = 0;
while ( k < 5)
{
printf("Шаг цикла (while) - %d\n" , k);
k++; };
Оператор do (СМ) Пример:
int i = 0;
do { printf("Шаг цикла(do) - %d\n" , i);
i++; i++;
} while ( i < 4);
Операторы прекращения циклов: (break(СМ), return((СМ),continue(СМ))

Семинары по дисциплине (ОП)
Семинары по OП – 8ЛР – 34 час
-------------------------------------------------------------------------------
УПР №1 ВЫЧИСЛЕНИЯ(
Теория, Задание, МУ, DOC)
УПР №2 ЦИКЛЫ (Теория, Задание, Примеры, МУ, DOC)
УПР № 3 МАССИВЫ(Теория, Примеры, Задание, МУ, DOC)
УПР № 4 СТРОКИ(Теория , Примеры, Задание, (МУ)(DOC)
УПР №5 ФУНКЦИИ(Теория , Примеры, Задание, (МУ, DOC)
УПР №6 СТРУКТУРЫ(Теория, Примеры, Задания, МУ, DOC)
УПР №7 ФАЙЛЫ(Теория, Примеры, Задания, МУ, DOC)
УПР № 8 СПИСКИ(Теория , Примеры, Задания, МУ, DOC)
---------------------------------------------------------------------------------
ЛР № 10 ДЗ (комплексная ЛР) (см. Теория, МУ, DOC)

УПР №1 Теория
Проекты

ДЗ Задание
Проекты

ЛК № 1
Знакомство (СМ). Списки студентов (?)
Вводная (СМ)
Сайт
Литература (СМ)
Модели (СМ)
Основные понятия

Отладка программ
Отладка это процесс выявления и исправления ошибок в программе. Ошибка проявляется при
сравнении разницы между реальной и запроектированной величины данных программы (см. рисунок - ∆ ).
Фактически нужно установить причину ошибки и ее устранить.
Для выполнения такой проверки в технологии (СМ) программирования используется
отладчик (СМ),
входящий в состав
оболочки СП (СМ).
∆

Отладчик СП VS
Отладчик позволяет выполнить следующие действия:
Запустить программу в режиме отладки без трассировки
по шагам (F5);
Выполнить программу по шагам (F10);
Выполнить программу по шагам с обращениями к вложенным функциям(F11);
Установить точку останова (BreakPoint – F9);
Выполнить программу до первой точки останова (F5);
Просмотреть любые данные в режиме отладки в специальном окне
(locals - локальные);
Просмотреть любые данные в режиме отладки при помощи мышки;
Изменить любые данные в режиме отладки в специальном окне (locals и Watch);
Установить просмотр переменных в специальном окне (Watch);
Просмотреть последовательность и вложенность вызова функций во время выполнения программыю.

Литература по ОП (1)
Д. Ритчи & Керниган Б. Язык программирования С (СМ)
Список литературы,
доступные книги и необходимые пособия для ЛР ОП размещены на сайте www.sergebolshakov.ru на страничке “2-й к СУЦ”. Пароль для доступа можно взять у преподавателя или старосты группы.
Керниган Б., Ритчи Д. К Язык программирования С, 2/3-е издание: Пер. с англ. – М. : Издательский дом “Вильямс”, 2009. – 304с.: ил. – Пар. Тит. англ.
Касюк, С.Т. Курс программирования на языке Си: конспект лекций/С.Т. Касюк. — Челябинск: Издательский центр ЮУрГУ, 2010. — 175 с.
MSDN Library for Visual Studio 2005 (Vicrosoft Document Explorer – входить в состав дистрибутива VS. Нужно обязательно развернуть при установке VS!). Или online в Интернет.
C.О.Бочков, Д.М.Субботин Язык программирования Си для персонального компьютераМ.: "Радио и связь", 1990.- 384 с.
Фридланд А.Я. Информатика и компьютерные технологии: Основные термины: Толк.слов.: Более 1000 базовых понятий и терминов. – 3-е изд., испр. и доп./ А.Я Фридланд, Л.С. Ханамирова, И.А. Фридланд – М.:ООО «Издательство Астрель»: ООО «Издательство АСТ», 2003. - 272 с.

Литература по ОП (2)
Общее методическое пособие по курсу для выполнения ЛР и ДЗ
(см. на сайте 1-й курс www.sergebolshakov.ru) – см. кнопку в конце каждого раздела сайта!!!
Керниган Б., Ритчи Д. К36 Язык программирования Си.\Пер. с англ., 3-е изд., испр. - СПб.: "Невский Диалект", 2001. - 352 с.: ил.
Другие методические материалы по дисциплине с сайта www.sergebolshakov.ru.
Конспекты лекций по дисциплине “Основы программирования”.
Подбельский В.В. Язык Си++: Учебное пособие. – М.: Финансы и статистика, 2003.
5. Подбельский В.В. Стандартный Си++: Учебное пособие. – М.: Финансы и статистика, 2008.
Г. Шилдт “С++ Базовый курс”: Пер. с англ.- М., Издательский дом “Вильямс”, 2011 г. – 672с
Г. Шилдт “С++ Руководство для начинающих” : Пер. с англ. - М., Издательский дом “Вильямс”, 2005 г. – 672с
Г. Шилдт “Полный справочник по С++”: Пер. с англ.- М., Издательский дом “Вильямс”, 2006 г. – 800с
Бьерн Страуструп "Язык программирования С++"- М., Бином, 2010 г.

РК ОП № 1(2019)
Массивы и указатеи
Циклы и ветвления
Строки и алгоритмы
ФМ и проекты
МОЖНО ПОЛЬЗОВАТЬСЯ:
МУ по ЛР ОП (1-4), Своими ЛР, лекциями, Литературой, Online Help MS
Задание выполняется на компьютере в дисплейном зале ЛР.
МОЖНО ПОЛЬЗОВАТЬСЯ: МУ по ЛР ОП (1-7), Своими ЛР, лекциями, Литературой, Online Help MSDN(F1)

РК ОП (2019) № 1 Варианты
Задание (СМ)

РК ОП № 2 (2019)
МОЖНО ПОЛЬЗОВАТЬСЯ: МУ по ЛР ОП (1-7), Своими ЛР,
лекциями, Литературой, Online Help MSDN(F1)
Структуры и массивы структур
Функции и проекты
Файлы и ФМ
МОЖНО ПОЛЬЗОВАТЬСЯ: МУ по ЛР ОП (1-7), Своими ЛР, лекциями, Литературой, Online Help MSDN(F1).

ЛК ВСЕ
ЛК №1 (СМ)
ЛК №2
ЛК №3
ЛК №4
ЛК №5
ЛК №6
ЛК №7
ЛК №8
ЛК №9
ЛК №10
ЛК
№11
ЛК №12

Пример формата
#define _USE_MATH_DEFINES
// Подключение библиотеки математических функций
#include
#include
#include
void main(void)
{
//
// п. 3.12
system(" chcp 1251 > nul");

ДЗ ОП (ЛР № 10)
Теоретические основы ДЗ (СМ), МУ Общие МУ по ОП
(МУ,ДОС)
Тема программы вариант ДЗ - 6-СМ. МУ на ДЗ – ЛР№10 (МУ, DOC)
План работы над ДЗ (СМ) Структура данных задания (СМ)
Схема функционирования программы проекта ДЗ (СМ)
Основные Задания, функции и задачи (СМ)
ТЗ ДЗ (СМ). Образец(СМ,DOC) и шаблон (СМ). МУ по ТЗ (СМ, DOC)
Сдача ДЗ (ПМИ). Образец ПМИ (DOC,МУ) и МУ по ПМИ (СМ , DOC)
Пример ДЗ из МУ (VS 2017). (МУ, DOC)
Для сильных студентов и совершенствования в программировании:
Даны дополнительные требования:А-С (МУ, DOC). Они включают расширение библиотеки для работы с файлом БД студентов.

ПМИ – Функциональная Схема проекта
Печать результата
В функциональной схеме выделены:
Программа для работы с файлом
БД (исполнимый модуль VS)
Файл, содержащий записи структур студентов.
Клавиатура: ввод данных
Консольное окно для вывода данных.
ОП – оперативная память для хранения переменных и массивов программы.

ПМИ – План работы над ДЗ
Тема ДЗ ЛР № 6-СМ.
Изучить МУ к ДЗ
(№10-СМ, с примерами МУ и DOC).
Разработать структуру(СМ) по варианту (ЛР № 6-СМ, №10-СМ). Продумать возможные задачи использования своей БД (СМ)
Разработать, согласовать и утвердить ТЗ на ДЗ (образец(СМ), шаблон(СМ)), предварительно изучив общие методические указания по разработке ТЗ (СМ).
ТЗ ДЗ (СМ).
Выполнить поэтапно все пункты ТЗ, связанные с разделом 5.1 ТЗ. (СМ) (СМ)
Разработать отчет по ЛР № 10, который оформляется по общим правилам оформления ЛР по курсу ОП в данном семестре. (СМ). Блок – схема в отчете разрабатывается для п . п. ТЗ 5.1.12 – запись файла на основе массива.
Изучить общие правила проведения Приемно-сдаточных испытаний на основе ПМИ (МУ для ПМИ). Отдельный документ ПМИ не разрабатывается, испытания проводятся но основе ТЗ (СМ). Документ ОТП (описание тестового примера не разрабатывается его содержание включается в отчет по ЛР)
Провести приемно-сдаточные испытания в присутствии преподавателя по ТЗ с предоставлением отчета по ЛР № 10. (Образец) Сдача ДЗ (ПМИ).

ТЗ ОП (ЛР № 10)
Структура документа Техническое Задание(шаблон- ТЗ/ образец - ТЗ ):
МУ по ТЗ
1. НАИМЕНОВАНИЕ
2. ОСНОВАНИЕ ДЛЯ РАЗРАБОТКИ
3. НАЗНАЧЕНИЕ РАЗРАБОТКИ
4. ИСПОЛНИТЕЛЬ
5. ТЕХНИЧЕСКИЕ ТРЕБОВАНИЯ
5.1. Требования к функциональным характеристикам
5.2. Требования к программному обеспечению
5.3. Требования к условиям эксплуатации
5.4. Требования к информационному обеспечению
5.5. Требования к надежности
5.6. Требования к составу и характеристикам технических средств
5.7. Требования к программной совместимости
6. ТРЕБОВАНИЯ К ПРОГРАММНОЙ ДОКУМЕНТАЦИИ
6.1. Разрабатываемые технические и эксплуатационные документы
6.1.1. Техническое задание (данный документ).
6.1.2. Техническое описание (в форме отчета по ЛР).
6.1.3. Программа и методика испытаний (по согласованию с преподавателем);
7. ТЕХНИКО-ЭКОНОМИЧЕСКИЕ ПОКАЗАТЕЛИ
7.1СТАДИИ И ЭТАПЫ РАЗРАБОТКИ
8.1. Сроки выполнения отдельных этапов работ
ПОРЯДОК КОНТРОЛЯ И ПРИЕМКИ ЗАДАНИЯ
9.1. Требования к сдаче и условия приемки
ДОПОЛНИТЕЛЬНЫЕ ТРЕБОВАНИЯ

ПМИ – Основные функции и задачи
В ТЗ на КЛР (СМ) определены основные функции
программы (СМ): Общая схема работы программы БД студентов имеет вид (СМ).
Проектирование и описание структуры своего варианта. ЛР №6
Описание и заполнение переменных и массивов для структуры. ЛР №6
Создание функций для печати структур и массива структур (и через указатели)
Создание и заполнение файла структурных переменных. ЛР №7
Распечатка файла структурных переменных . ЛР №7
Сортировка массива и файла структурных переменных . ЛР №7
Создание библиотеки функций (в отдельном исходном модуле и в заголовочном модуле прототипов) для выполнения перечисленных функций. ЛР № 5,6,7
Для получения наивысшей оценки желательно выполнение всех заданий (А)
и предпочтительно дополнительных требований (см. МУ ЛР №10). (см. DOC)
ЗАДАЧИ, ГДЕ ВОЗМОЖНО ИСПОЛЬЗОВАТЬ БД СТУДЕНТОВ (Предметная область):
Программа учета успеваемости студентов
Программа учета посещаемости студентов лекций и занятий
Программа распределения мест в общежитии для студентов
Программа оценки размера стипендии и ее выдачи студентам
Программы обеспечения социальной помощи студентам
…