Алгоритмические языки и программирование
Автор работы: Пользователь скрыл имя, 21 Октября 2013 в 02:21, курс лекций
Описание работы
• Программа – последовательность инструкций,
предназначенная для исполнения компьютером. Программа
загружается в оперативную память при своем запуске и
выполняется процессором.
• Программное обеспечение (ПО) состоит из нескольких
совместно работающих программ, и документов, необходимых
для сопровождения и эксплуатации программ
Файлы: 1 файл
Алгоритмические языки и
программирование
Московский государственный
университет путей сообщения
(МИИТ)
программирование
Варфоломеев
Алексей Викторович
Москва 2011
1. Введение в программирование
1.1. Устройство компьютера
• Процессор
– Производит вычисления и отдает команды
остальным компонентам компьютера
2
• Оперативная память
– Хранит программу и данные
• Внешние устройства
1.2. Программное обеспечение
• Программа – последовательность инструкций,
предназначенная для исполнения компьютером. Программа
загружается в оперативную память при своем запуске и
выполняется процессором.
• Программное обеспечение (ПО) состоит из нескольких
совместно работающих программ, и документов, необходимых
для сопровождения и эксплуатации программ
3
• Системное ПО – предназначено для управления
вычислительной машиной и ее ресурсами
– Операционные системы
– Драйверы
– Утилиты
• Прикладное ПО – ориентировано на решение пользовательских
задач
1.3. Алгоритмы
• Алгоритм – точный набор
инструкций, описывающих
порядок действий некоторого
исполнителя для достижения
определенного результата за
конечное время
• Дискретность
• Понятность
• Детерминированность
• Результативность
• Конечность
• Массовость
4
• Массовость
• Способы записи алгоритма:
– при помощи естественного языка (словесное описание
алгоритма)
– при помощи алгоритмического языка (язык программирования,
псевдокод)
– графическое описание алгоритма (блок-схема)
1.3.1. Блок-схемы алгоритмов
Терминатор. Вход из внешней среды или выход из
алгоритма
Процесс. Выполнение одной или нескольких операций,
обработка данных любого вида
Решение. Разветвление алгоритма в зависимости от
результата вычисления условия
Предопределенный процесс. Выполнение внешнего
5
Предопределенный процесс. Выполнение внешнего
процесса, состоящего из одной или нескольких операций,
Данные. Выполнение операций ввода-вывода
Модификатор. Повторное выполнение операций (цикл)
Соединитель. Объединяет несколько блок-схем
Комментарий. Обозначает комментарии к элементам
блок-схемы
1.3.2. Базовые алгоритмические
структуры (1)
1. Следование
2. Ветвление
а) если-то
в) выбор
6
б) если-то-иначе
1.3.2. Базовые алгоритмические
структуры (2)
3. Цикл
а) с предусловием
в) арифметический
7
б) с постусловием
1.3.3. Примеры алгоритмов
1) Посчитать
значение
выражения:
2
2
b
a
y
+
=
2) Решить уравнение:
0
2
=
+
+
с
bx
ax
1
,
2
0
1
=
=
+
b
b
b
n
n
3) Вывести первые
10 элементов
прогрессии
8
1.4. Языки программирования
• Язык программирования — формальная
знаковая система, предназначенная для
записи компьютерных программ
– Алфавит – набор символов, пользуясь
которыми составляют инструкции, принятые в
языке.
– Синтаксис – набор правил, в соответствии с
которым записываются конструкции языка.
– Семантика – набор правил, в соответствии с
• Фортран
• Кобол
• Паскаль
• Бейсик
• С
• С++
• Java
9
– Семантика – набор правил, в соответствии с
которым осуществляется интерпретация и
выполнение конструкций языка.
• ЯП:
– Языки высокого уровня
– Языки низкого уровня
• ЯП:
– Алгоритмические
– Неалгоритмические
• Java
• С#
• Ассемблер
1.5. Среды разработки
• Среда разработки
(интегрированная среда
разработки, IDE, Integrated
development environment) –
совокупность программных
средств, используемая для
разработки программного
• Eclipse
• NetBeans
• Visual Studio
– Visual C++
– Visual C#
– Visual Basic
• Delphi
10
разработки программного
обеспечения
• Среда разработки включает в
себя:
– Текстовый редактор
– Транслятор
– Компоновщик (сборщик)
– Отладчик
• Delphi
• C++ Builder
1.6. Подготовка программы к выполнению
1.6.1. Компиляторы
• Компилятор – транслятор, преобразующий код
программы на языке высокого уровня в
эквивалентный код на машинном языке (либо, на
языке виртуальной машины)
11
____________
____________
____________
____________
____________
Исходный код
программы
Компилятор
Сообщения об
ошибках в коде
____________
____________
____________
____________
____________
Obj
Obj
Объектные
модули
Компоновщик
Exe
Исполнимый
файл
1.6.2. Интерпретаторы
• Интерпретатор – транслятор, осуществляющий
пооператорную (покомандную) обработку и выполнение
исходной программы
– Простой
– Компилирующего типа
Исходный код
программы
Оператор
12
____________
____________
____________
____________
____________
Интерпретатор
Оператор
программы
Выполнение
Сообщения об
ошибках в коде
1.7. Технологии программирования
• Технология программирования – это совокупность методов и
средств разработки (написания) программ и порядок применения этих
методов и средств
– Структурное программирование – методология разработки
программного обеспечения, в основе которой лежит представление
программы в виде иерархической структуры блоков – модулей.
– Объектно-ориентированное программирование – программирование,
основанное на представлении предметной области в виде системы
взаимосвязанных классов и их реализаций – объектов.
13
взаимосвязанных классов и их реализаций – объектов.
– Визуальное программирование – реализация методологии ООП с
применением графических средств, обеспечивающих построение
пользовательских интерфейсов.
– Логическое программирование – программирование, основанное на
автоматическом доказательстве теорем. Логическое программирование
исходит из того, что компьютер должен уметь работать по логическим
построениям, присущим человеку.
– Функциональное программирование – методология программирования,
основанная на создании совокупностей функций. Вычисления начинаются с
вызова некоторой функции, которая в свою очередь вызывает функции,
входящие в ее определение и т. д. в соответствии с иерархией
определений и структурой условных предложений.
1.7.1. Структурное программирование
• функция (процедура) должна иметь
один вход и один выход
• функция должна решать
самостоятельную задачу
• функция может вызывать другую
функцию
• модульность
• иерархическое
строение
• нисходящая
разработка
14
• работа функции не должна зависеть
– от входных данных;
– от того, какой функции предназначены
ее выходные данные;
– от предыстории вызовов функции;
• функция должна возвращать
управление той функции, которая ее
вызывала;
1.7.2. Пример структурной программы
2
2
b)
f(a,
b
a
b
a
+
+
=
a
b
1
3
2
8
7
-3
15
Главный алгоритм
Алгоритм расчета значения функции
a)
(b,
f
b)
(a,
f
b)
f(a,
2
2
2
2
=
+
+
=
b
a
b
a
Алгоритм расчета значения функции
y
x +
=
2
2
y)
(x,
f
2. Язык С/С++. Основные понятия
• Язык С
– язык
программирования
общего назначения
– является
алгоритмическим
• Язык С++
– создан Бьерном Страуструпом в
начале 80-х годов
– расширяет возможности языка С:
• поддержка объектно-
ориентированного
16
алгоритмическим
языком высокого
уровня
– создан во второй
половине 70-х
годов Брайаном
Керниганом и
Деннисом Ритчи
ориентированного
программирования
• новые типы данных
• механизм обработки
исключительных ситуаций
• операторы управления
свободной памятью
• дополнения к стандартной
библиотеке
• пространства имен
2.1. Алфавит языка С++
2.2. Лексемы языка С++
• Алфавит:
– прописные и строчные
латинские буквы
– знак подчеркивания
– арабские цифры от 0 до 9
– пробельные символы (пробел,
табуляция, переход на новую
строку)
– специальные символы
• Лексемы языка:
– идентификаторы
– ключевые слова
– константы
– знаки операций
– комментарии
17
– специальные символы
"
{ } ,
|
[ ] ( )
'
:
?
<
=
>
+
-
/ \ %
*
.
!
&
#
;
^
2.2.1 Идентификаторы
2.2.2. Ключевые слова
2.2.3. Комментарии
• Идентификаторы – имена
программных объектов
– могут содержать латинские
буквы, цифры и знак
подчеркивания
– могут начинаться с латинской
буквы или знака
• Ключевые слова –
зарезервированные
идентификаторы, имеющие
специальное значение для
компилятора
asm auto bool break case catch
18
буквы или знака
подчеркивания
– чувствительны к регистру
• Комментарии – примечания к
тексту программы,
игнорируемые компилятором
1. Строчные – начинаются с
символов \\ и заканчиваются
переходом на новую строку
2. Блочные – заключены между
символами /* и */. Могут
распространяться на несколько
строк
asm auto bool break case catch
char class const const_cast
continue
default
delete
do
double dynamic_cast else enum
explicit export extern false
float
for
friend
goto
if
inline
int
long
mutable
namespace new operator private
protected
public
register
reinterpret_cast return short
signed
sizeof
static
static_cast
struct
switch
template this throw true try
typedef typeid typename union
unsigned using virtual void
volatile wchar_t while
2.2.4. Знаки операций
2.2.5. Константы
• Знаки операций – последовательность символов,
определяющих действия над операндами
• Константы – неизменяемые величины, представленные
своим значением
Константа
Формат
Пример
Целая
Десятичная: последовательность десятичных цифр, 8, 0, 199226
19
Целая
Десятичная: последовательность десятичных цифр,
начинающаяся не с нуля, если это не число ноль.
Восьмеричная:
ноль,
за
которым
следуют
восьмеричные цифры (0,1,2,3,4,5,6,7)
Шестнадцатеричная: 0х или 0Х,
за которым следуют шестнадцатеричные
цифры (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F)
8, 0, 199226
01, 020, 07155
0хА, 0x1В8, 0X00FF
Вещественная Десятичная: [цифры].[цифры]
Экспоненциальная:
[цифры][.][цифры]{Е|е}[+|-][цифры]
5.7, .001, 35.
0.2Е6, .11е-З, 5Е10
Символьная
Один или два символа, заключенных в апострофы
'А', 'ю', '*', '\0'
Строковая
Последовательность символов, заключенная в кавычки "Hello, world"
2.3. Типы данных
• Тип данных
определяет:
– внутреннее
представление
данных в памяти
компьютера
– множество
• Типы данных:
– int (целый)
– char (символьный)
– wchar_t (расширенный символьный)
– bool (логический)
– float (вещественный)
20
– множество
значений, которые
могут принимать
величины этого
типа
– операции и
функции, которые
можно применять
к данным этого
типа
– double (вещественный с двойной
точностью)
– void («пустой» тип)
• Спецификаторы типов:
– short (короткий)
– long (длинный)
– signed (знаковый)
– unsigned (беззнаковый)
2.4. Структура программы C++
• Программа на языке
С++ может состоять из
одного или нескольких
модулей
• Каждый модуль может
21
• Каждый модуль может
включать в себя:
– функции
– операторы
– описания
идентификаторов
– директивы
препроцессора
2.4.1. Функции
• Функция – это подпрограмма, реализующая некоторый алгоритм
– Принимает на вход набор параметров
– Возвращает значение заданного типа
тип_возвращаемого_значения имя_функции (тип1 параметр1, тип2 параметр2, ...)
{
...
// Описания и операторы
...
22
...
}
int sum(int a, int b)
{
return a+b;
}
void HelloWorld()
{
printf("Hello World!!\n");
}
• Выполнение программы начинается с главной функции main
int main()
{
...
}
void main()
{
...
}
2.4.2. Описание переменных
• Переменная – это именованная область памяти, в
которой хранятся данные определенного типа
• Значение переменной может изменяться в процессе
выполнения программы
23
[const] тип_переменной имя_переменной [= значение];
int a;
double b;
int a,b,c,d;
float a=2.3;
int b=10,c=20;
char A='Z';
const int x=125;
2.4.2.1 Область видимости переменных (1)
• Под областью видимости
переменной понимается
область программы, в которой
данная переменная доступна
для использования
• Локальные переменные
– Объявляются внутри функции
или оператора
– Доступны для использования
только в рамках той области,
где они объявлены
• Глобальные переменные
– Объявляются вне тела какой-
либо функции
– Доступны в любом месте
1)
24
– Доступны в любом месте
программы
1)
2.4.2.2. Область видимости переменных (2)
2)
3)
5)
25
3)
int x=5;
void main()
{
cout << x;
int x = 10;
cout << x;
}
4)
6)
2.4.3. Директивы препроцессора
2.4.4. Операторы
•
Директивы препроцессора – служебные инструкции, адресованные
компилятору
– управляют преобразованием текста программы перед ее компиляцией
– начинаются с символа #
•
Оператор – наименьшая автономная единица языка программирования,
обеспечивающая выполнение некоторой операции или последовательности
#include <stdio.h>
26
обеспечивающая выполнение некоторой операции или последовательности
операций
•
Основные операторы:
– Оператор присваивания
– Операторы передачи управления
– Операторы цикла
– Условные операторы
– Составной оператор
int sum(int a, int b)
{
int res;
res = a+b; // Оператор присваивает значение переменной res
return res; // Оператор возвращает значение функции sum
}
void HelloWorld()
{
// Оператор вызывает функцию printf
printf("Hello World!!!\n");
}
2.5. Программа “Hello world”
/*
Программа Hello, world
*/
#include <stdio.h> // Библиотека ввода/вывода. Содержит функцию printf
#include <conio.h> // Библиотека ввода/вывода. Содержит функцию getch
// Главная функция main
void main()
27
void main()
{
printf("Hello World!!!\n"); // Вывожу на экран сообщение
getch();
// Ожидаю нажатия на клавишу
}
3. Выражения и операции
• Выражение – языковая
конструкция, определяющая
последовательность
выполнения операций над
данными
• Результатом вычисления
выражения является
единственное значение,
• Операции:
– арифметические операции
– операции сравнения
– логические операции
– побитовые логические
операции
– операции сдвига
28
единственное значение,
относящееся к определенному
типу данных
• Выражение состоит из
операндов и операций
– операции сдвига
• Операции:
– унарные
– бинарные
• Операнды:
– переменная
– константа
– функция
– выражение
int a = 100-35*2;
bool b = a<50;
if (a<30) a = a+10;
3.1. Арифметические операции
• Арифметические операции выполняются над целочисленными и
вещественными операндами
• Тип результата арифметического выражения соответствует типу
операндов
Операция
Описание
Пример выражения
–
Унарный минус
–a
29
–
Унарный минус
–(10*a+b)
+
Унарный плюс
+a
*
Умножение
a*10
10*20
(3+a)*(4+b)
/
Деление
10/3
10.0/3
%
Получение остатка от деления
10%3
+
Сложение
a+b
–
Вычитание
A–a
3.2. Операции сравнения
• Выполняются над целочисленными и вещественными
операндами
• Возвращают булевское значение: «истина» (1, true) или
«ложь» (0, false)
Операция
Описание
Пример
30
выражения
<
Меньше
2<5
A<(10*b)
<=
Меньше или равно 5<=5
a<=b
>
Больше
a>b
>=
Больше или равно a>=b
==
Равно
a==b
a==b+c+d
!=
Не равно
a!=b+c+d
3.3. Логические операции
• Выполняются над булевскими операндами
• Возвращают булевское значение
Операция
Описание
Пример
выражения
&&
Логическое «И»
A && B
31
&&
Логическое «И»
A && B
x<=2 && y>3
| |
Логическое «ИЛИ» x<=2 | | y>3
!
Логическое «НЕ»
!A && B
!(x<=2)
A
B
!A
A&&B
A| |B
Ложь
Ложь
Истина
Ложь
Ложь
Ложь
Истина Истина
Ложь
Истина
Истина
Ложь
Ложь
Ложь
Истина
Истина Истина
Ложь
Истина Истина
3.3. Побитовые
логические операции (1)
• Возвращают целочисленное значение
• Выполняются над целочисленными операндами
Операция
Описание
Пример
выражения
&
Побитовое «И»
A & B
32
&
Побитовое «И»
A & B
|
Побитовое «ИЛИ»
A | B
^
Побитовое исключающее «ИЛИ» A ^ B
Побитовое «НЕ»
Ã
A
BA A&B A|B A^B
0
0
1
0
0
0
0
1
1
0
1
1
1
0
0
0
1
1
1
1
0
1
1
0
3.3. Побитовые
логические операции (2)
// Установить значение 0 для 3 бита
SW = SW & (0x04);
// 00000100 - SW
// 11111011 -0x04
// -----------------
// 00000000 - SW
unsigned char SW = 0; // 00000000
// Установить значение 1 для 1 бита
SW = SW | 0x01;
// 00000000 - SW
// 00000001 - 0x01
// -----------------
// 00000001 - SW
33
// Изменить значение 4 бита на противоположное
SW = SW ^ 0x08;
// 00000000 - SW
// 00001000 - 0x08
// -----------------
// 00001000 - SW
// Изменить значение 4 бита на противоположное
SW = SW ^ 0x08;
// 00001000 - SW
// 00001000 - 0x08
// -----------------
// 00000000 - SW
// 00000001 - SW
// Установить значение 1 для 3 бита
SW = SW | 0x04;
// 00000001 - SW
// 00000100 - 0x04
// -----------------
// 00000101 - SW
// Установить значение 0 для 1 бита
SW = SW & (0x01);
// 00000101 - SW
// 11111110 -0x01
// -----------------
// 00000100 - SW
3.4. Операции сдвига
• Возвращают целочисленное значение
• Выполняются над целочисленными операндами
Операция
Описание
Пример
выражения
>>
Сдвиг вправо
A >> 2
34
>>
Сдвиг вправо
A >> 2
<<
Сдвиг влево
A << 3
unsigned char A = 12; // 00001100 (12)
A = A << 2;
// 00110000 (48)
A = A >> 3;
// 00000110 (6)
3.5. Приоритет операций
Операция
Описание
Приоритет
!
Логическое «НЕ»
1
Побитовое «НЕ»
1
–
Унарный минус
1
*
Умножение
2
/
Деление
2
%
Получение остатка от
деления
2
Операция
Описание
Приоритет
<
Меньше
5
<=
Меньше или равно
5
>
Больше
5
>=
Больше или равно
5
==
Равно
6
!=
Не равно
6
&
Побитовое «И»
7
35
деления
+
Сложение
3
–
Вычитание
3
>>
Сдвиг вправо
4
<<
Сдвиг влево
4
&
Побитовое «И»
7
^
Побитовое
исключающее «ИЛИ»
8
|
Побитовое «ИЛИ»
9
&&
Логическое «И»
10
| |
Логическое «ИЛИ»
11
a +
2
b *
1
c >=
3
d &&
4
d < e –
2
5
false &&
1
false ||
2
true
a + b * c >= d && d < e – 5
( ( a + (b * c) ) >= d ) && ( d < (e – 5) )
(a + b) * c
3.6. Математические функции (1)
• Основные математические функции определены в
заголовочном файле math.h
#include <math.h>
• Функция возведения в степень
double pow(double x, double y);
double x = pow(2,4); // x = 16;
• Функции взятия числа по модулю
36
int
abs(int x);
double fabs(double x);
double z = fabs(-1.4); // z = 1.4;
• Функции округления
double ceil(double x);
double floor(double x);
double a = floor(9.9); // a = 9;
double b = floor(9.1); // b = 9;
double c = floor(-1.4); // c = -2;
double a = ceil(9.9); // a = 10;
double b = ceil(9.1); // b = 10;
double c = ceil(-1.4); // c = -1;
3.6. Математические функции (2)
double log(double x);
Натуральный логарифм
double log10(double x); Десятичный логарифм
double sqrt(double x)
Квадратный корень числа
double sin(double x);
Синус
double cos(double x);
Косинус
37
double tan(double x);
Тангенс
double sinh(double x);
Гиперболический синус
double cosh(double x);
Гиперболический косинус
double tanh(double x);
Гиперболический тангенс
double asin(double x);
Арксинус
double acos(double x);
Арккосинус
double atan(double x);
Арктангенс
double exp(double x);
Вычисление экспоненты
4. Операторы языка С++
4.1. Оператор присваивания
• Оператор присваивания позволяет установить
новое значение для переменной
переменная = выражение
Оператор
присваивания
Пример
использования
Эквивалентный
оператор
+=
a += b
a = a + b
38
X = a + b * c >= d && d < e – 5;
D = 2 * a;
A = A + 10;
+=
a += b
a = a + b
-=
a -= b
a = a – b
*=
a *= b
a = a * b
/=
a /= b
a = a / b
%=
a %= b
a = a % b
<<=
a <<= b
a = a << b
>>=
a >>= b
a = a >> b
&=
a &= b
a = a & b
|=
a |= b
a = a | b
^=
a ^= b
a = a ^ b
4.2. Инкремент и декремент
• Оператор инкремента (++) увеличивает значение
переменной на единицу
• Оператор декремента (--) уменьшает значение
переменной на единицу
++c; // префиксный инкремент
c++; // постфиксный инкремент
39
c++; // постфиксный инкремент
Оператор
Последовательность
действий
x = c++;
x = c;
c = c + 1;
x = ++c;
c = c + 1;
x = c;
x = c--;
x = c;
c = c - 1;
x = --c;
c = c - 1;
x = c;
double sum (double a, double b)
4.3. Операторы передачи управления
• Вызов функции
a = F(b) + F(c);
имя_функции(параметр1,
параметр2, ...)
function1();
function2(1,2,3);
function3(a,b,c);
• Безусловный переход
// ...
goto label1;
// ...
// ...
label1: a = 5;
// ...
40
double sum (double a, double b)
{
return a+b;
}
void main()
{
int a = 5;
int b = 10;
int c = sum(a,b);
cout << "c = a + b = " << c;
getch();
}
• Возврат значения функции
void function1()
{
//...
return;
}
int function2()
{
//...
return 10;
}
4.4. Составной оператор
• Составной оператор используется в тех случаях,
когда необходимо выполнить несколько различных
команд, но семантика языковой конструкции
предполагает наличие единственного оператора
// Составной оператор
41
// Составной оператор
{
оператор1;
оператор2;
оператор3;
}
4.5. Условные операторы
4.5.1 Условный оператор if (1)
• Оператор if позволяет реализовать конструкцию ветвления в
программе и обеспечить выбор одного из альтернативных путей
работы алгоритма в зависимости от результата проверки некоторого
условия
if (условное_выражение) оператор;
if (a!=0)
{
x1 = x2/a;
y1 = y2/a;
z1 = z2/a;
1)
42
if (a<0)
a=0;
if (a!=0 && b!=0)
x = c/(a*b);
z1 = z2/a;
}
if (a!=0)
{
x = x/a;
if (b!=0) y = y/(a*b);
}
2)
3)
4)
4.5.1 Условный оператор if (2)
if (условное_выражение)
оператор1;
else
оператор2;
// Определение максимального значения (a, b)
if (a>b)
max = a;
else
max = b;
// Определение максимального значения (a, b, c)
if (a>b && a>c)
max = a;
else
1)
2)
43
else
{
if (b>a && b>c)
max = b;
else
max = c;
}
// Определение максимального значения (a, b, c)
if (a>b && a>c)
max = a;
else if (b>a && b>c)
max = b;
else
max = c;
3)
4.5.2 Условный оператор switch (1)
• Оператор switch позволяет реализовать алгоритмическую
конструкцию «выбор»
switch (выражение)
{
case значение1:
оператор1.1;
оператор1.2;
...
case значение2:
switch (a)
{
case 1:
cout << "Block 1\n";
case 2:
cout << "Block 2\n";
default:
cout << "Block Default\n";
1)
44
case значение2:
оператор2.1;
оператор2.2;
...
...
case значениеN:
операторN.1;
операторN.2;
...
default:
операторD.1;
операторD.2;
...
}
cout << "Block Default\n";
}
a == 1
a == 2
нет
нет
Вывод сообщения:
«Block 1»
да
да
Вывод сообщения:
«Block 2»
Вывод сообщения:
«Block Default»
4.5.2 Условный оператор switch (2)
switch (a)
{
case 1:
cout << "Block 1\n";
break;
case 2:
cout << "Block 2\n";
break;
default:
cout << "Block Default\n";
3)
45
switch (a)
{
case 1:
case 2:
cout << "Block 1 or 2\n";
break;
case 3:
cout << "Block 3\n";
}
}
2)
4.5.3 Условная операция
• Условная операция ? используется для определения
альтернативных значений внутри выражения
(условное_выражение)?значение1:значение2
// Определение максимального значения (a, b)
// Используем оператор if
46
// Используем оператор if
if (a>b)
max = a;
else
max = b;
// Определение максимального значения (a, b)
// Используем условную операцию
max = (a>b)? a : b;
4.5.4. Пример программы
с условным оператором
0
2
=
+
+
с
bx
ax
#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;
void main()
{
double a, b, c;
cout << "Введите a:\n";
cin >> a;
cout << "Введите b:\n";
cin >> b;
47
cin >> b;
cout << "Введите c:\n";
cin >> c;
float D = b*b - 4*a*c;
if (D<0)
cout << "Корней нет\n";
else if (D==0)
{
double x1 = -b/(2*a);
cout << "x = " << x1;
}
else
{
double d = sqrt(D);
double x1 = (-b+d)/(2*a);
double x2 = (-b-d)/(2*a);
cout << "x1 = " << x1 << "\nx2 = " << x2;
}
getch();
}
4.6. Операторы цикла
4.6.1. Оператор цикла for (1)
• Оператор for позволяет реализовать
арифметический цикл
48
0
1
2
3
4
Результат работы:
4.6.1. Оператор цикла for (2)
for (int i 2
i<10
i++)
1)
2)
3)
49
for (int i=2 ; i<10 ; i++)
{
int i2 = i*i;
cout << i << " x " << i << " = " << i2 << "\n";
}
Результат работы:
2 x 2 = 4
3 x 3 = 9
4 x 4 = 16
5 x 5 = 25
6 x 6 = 36
7 x 7 = 49
8 x 8 = 64
9 x 9 = 81
3)
4.6.2. Вложенные циклы
• Цикл, содержащийся внутри другого цикла, принято
называть вложенным циклом
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
3 x 2 = 6
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
3 x 3 = 9
for (int i=2; i<=5 ; i++)
{
for (int j=2; j<=5; j++)
{
int prv = i*j;
1)
1)
2)
50
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
4 x 4 = 16
4 x 5 = 20
5 x 5 = 25
prv
j;
cout << i << " x " << j
<< " = " << prv << "\n";
}
}
2)
4.6.3. Оператор цикла while
• Цикл с предусловием
• Цикл с постусловием
51
int i = 1;
int sum = 0;
while (i<=100)
{
sum += i;
i++;
}
char answer;
do
{
cout << "\nВыйти из цикла? ";
cin >> answer;
} while (answer != 'y');
4.6.4. Операторы break и continue
• Оператор break используется для
принудительного выхода из цикла
• Оператор continue предписывает
программе перейти к следующей
итерации цикла
52
4.7. Пустой оператор
• Пустой оператор используется в том случае, если синтаксис
языковой конструкции предполагает наличие какого-либо
оператора, а логика программы не требует выполнения каких-
либо действий
for (int i=1; i<1000; i++);
53
(
;
; ++);
if (a>b) ; else b=a;
5. Массивы.
5.1. Объявление и инициализация
• Массив – именованная последовательность
однотипных элементов
54
5.2. Обращение к элементам массив
• Обращение к элементам массива осуществляется по
их порядковому номеру
• Нумерация элементов массива начинается с нуля
1)
3)
55
1)
2)
3)
4)
5.3. Пример программы,
работающей с массивом (1)
56
5.3. Пример программы,
работающей с массивом (2)
57
5.4. Многомерные массивы
• Многомерный массив – это массив, элементами
которого являются массивы
1)
2)
58
int A[3][5] = { {1,2,3,4,5},
{6,7,8,9,10},
{11,12,13,14,15} };
cout << A[2][1]; // 12
cout << A[1][2]; // 8
cout << A[0][4]; // 5
3)
4)
5.5. Представление
массива в памяти
• Элементы массива располагаются в памяти неразрывно,
непосредственно один за другим, в порядке своего следования
в массиве
• Под каждый элемент массива отводится память в соответствии
с заданным для массива типом данных
59
5.6. Упорядочивание массива
5.6.1. Метод выбора
60
5.6.2. Метод «пузырька»
61
6. Пользовательские типы данных
6.1. Перечисления
• Перечисление – конструкция, позволяющая определить
множество целочисленных констант
• Перечисление может иметь имя
• Идентификатор, обозначающий имя перечисления, становится
62
• Идентификатор, обозначающий имя перечисления, становится
новым пользовательским типом данных
6.2. Структуры (1)
• Структура – совокупность элементов произвольных типов
1)
2)
3)
63
3)
4)
5)
6)
6.2. Структуры (2)
struct circle
{
7)
8)
64
{
point center;
int radius;
};
6.3. Объединения
• Объединение – конструкция, позволяющая размещать в одной
области памяти различные данные
65
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
value
byte[0]
byte[1]
=1
=0
=1
6.4. Объявление пользовательского типа
данных при помощи typedef
• Для определения нового пользовательского типа
может использоваться ключевое слово typedef
1)
66
typedef struct
{
double x;
double y;
double z;
} COORD;
COORD myPoint;
2)
3)
6.5. Оператор sizeof
• Оператор sizeof позволяет определить размер памяти,
требуемый для хранения значений заданного типа данных
• Оператор sizeof может применяться как к переменным, так и к
типам данных.
struct test
{
char h;
int b;
1)
67
int b;
double f;
};
test str;
int a1 = sizeof(str); // 16
int a2 = sizeof(char) + sizeof(int) + sizeof(double); // 13
cout << a1 << " " << a2;
2)
6.6 Преобразование стандартных типов
данных
• Неявное
преобразование типов
– происходит автоматически
при расчете значений
выражений, а также при
выполнении операции
присваивания (если
• Явное преобразование
типов
– выполняется при помощи
специальной операции
преобразования
68
операнды имеют
различные и совместимые
типы данных)
7. Указатели
7.1. Адрес переменной
• Местоположение переменной в памяти определяется
ее адресом
• Чтобы узнать адрес конкретной переменной,
используется унарная операция взятия адреса (&)
69
Результат:
7.2. Понятие указателя
• Указатель – переменная, значение которой
является адресом ячейки памяти
70
7.3. Разыменование указателей
• Операция разыменования (*) позволяет обратиться к значению,
записанному в области памяти, на которую ссылается указатель
int
a = 1;
double b = 7.6;
void* ptr;
ptr = &a;
cout << *( (int*)ptr ) << "\n";
1)
2)
4)
71
ptr = &b;
*( (double*)ptr ) /= 5;
cout << b << "\n";
• Специальное значение NULL говорит о том, что указатель никуда не
ссылается
3)
5)
7.4. Операции над указателями (1)
Операция
Выражение
Результат
Описание
Равно (==)
указатель1
==
указатель2
true/false Сравнивает два указателя на равенство адресов
Не равно (!=)
указатель1
!=
указатель2
true/false Сравнивает два указателя на неравенство адресов
Меньше (<)
указатель1
<
указатель2
true/false Возвращает истину, если адрес, на который ссылается
указатель1 меньше адреса, на который ссылается
указатель2
Меньше или
равно (<=)
указатель1
<= true/false Возвращает истину, если адрес, на который ссылается
указатель1 меньше или равен адресу, на который
72
равно (<=)
указатель2
указатель1 меньше или равен адресу, на который
ссылается указатель2
Больше (>)
указатель1
>
указатель2
true/false Возвращает истину, если адрес, на который ссылается
указатель1 больше адреса, на который ссылается
указатель2
Больше
или
равно (>=)
указатель1
>=
указатель2
true/false Возвращает истину, если адрес, на который ссылается
указатель1 больше или равен адресу, на который
ссылается указатель2
Вычитание (–) указатель1
–
указатель2
целое
число
Вычисляет количество элементов заданного типа
между указателями
Вычитание (–) указатель
–
целое_число
указатель
Вычисляет указатель, отстоящий от заданного на
определенное количество элементов (в соответствии с
типом указателя)
Сложение (+)
указатель
+
целое_число
указатель
7.4. Операции над указателями (2)
1)
2)
73
int a
= 1;
int b
= 1;
int* ptr1 = &a;
int* ptr2 = &b;
cout << ptr1 << "\n";
cout << ptr2 << "\n";
if (ptr1 < ptr2)
cout << "ptr1 < ptr2";
3)
7.4. Операции над указателями (3)
0012FEA8
0012FEB0
0012FEC0
4)
74
int Y[10];
int* ptr1 = &(Y[2]);
int* ptr2 = &(Y[5]);
cout << ptr1 << endl;
cout << ptr2 << endl;
int x = ptr2 - ptr1;
cout << x;
0012FE90
0012FE9C
3
5)
7.5. Указатели и массивы
• Имя объявляемого массива всегда ассоциируется
компилятором с адресом его самого первого элемента
1)
2)
75
const int N=10;
int A[N];
for (int i=0; i<N; i++)
{
int* ptr = A+i;
*ptr = i*i;
}
for (int i=0; i<N; i++)
cout << A[i] << " ";
3)
4)
7.6. Применение sizeof к указателям
7.7. Указатели на указатели
• К указателям можно применять оператор sizeof
1)
76
• Указатель может ссылаться на переменную, которая,
в свою очередь, также является указателем
2)
7.8. Ссылки
• Ссылка – особая переменная, являющаяся скрытой
формой указателя, который при использовании
автоматически разыменовывается
• Ссылка, используется как псевдоним для другого
объекта
77
7.9. Динамическое выделение памяти
7.9.1. Области памяти
• Области памяти:
– область кода
• машинный код
программы
– область данных
• глобальные переменные
• строковые константы
• Динамические
переменные:
– Размещаются в области
памяти «куча»
– Создаются с помощью
специальных
функций/операторов
78
• строковые константы
– стек
• локальные
переменные
• параметры вызова
функций
– куча
• динамические
переменные
функций/операторов
– Не имеют имени
– Доступ к переменным
осуществляется по
указателю
7.9.2. Функции malloc, calloc, free
• Функции malloc и calloc выделяют в памяти область
заданного размера
• Функция free освобождает заданную область памяти
79
7.9.2.1 Пример динамического выделения
памяти (1)
80
7.9.2.1 Пример динамического выделения
памяти (2)
81
7.9.3. Операторы new и delete
• Оператор new выделяет в области память, необходимую для хранения
заданного объекта, и возвращает типизированный указатель
• Оператор delete освобождает память, выделенную при помощи
оператор new
82
struct MyStruct
{
int a;
int b;
int c;
int d;
};
1)
2)
7.9.3.1. Пример динамического
выделения памяти (1)
83
7.9.3.1. Пример динамического
выделения памяти (2)
84
8. Функции.
8.1. Прототипы функций
• Прототип функции – это объявление функции,
содержащее только ее заголовочную часть
или
85
или
8.2. Параметры функции
• Параметры функции:
– Переменные
– Константы
– Выражения
86
8.2.1. Передача параметров
по значению
• Функция работает с временной копией объекта в
стековой памяти
• Изменение объекта внутри функции не окажет
влияния на оригинал объекта вне функции
87
8.2.2. Передача параметров
по ссылке (1)
• В функцию передается адрес переменной
• Изменение объекта внутри функции отразится на его
значении вне функции
1) При помощи ссылки
2) При помощи указателя
88
void test(int &var)
{
var = var+5;
}
void main()
{
int z = 10;
test(z);
cout << z;
}
void test(int* var)
{
*var = *var+5;
}
void main()
{
int z = 10;
test(&z);
cout << z;
}
8.2.2. Передача параметров
по ссылке (2)
3)
89
4)
8.2.3. Массивы как параметры функций
• Массивы всегда передаются в функцию по ссылке:
изменение элемента массива внутри функции
отразится и за ее пределами
void PrintArray(int*, int);
void PrintArray(int[], int);
1)
2)
90
void main()
{
int Array[] = {1,3,5,7,9};
PrintArray(Array, 5);
getch();
}
void PrintArray(int* A, int n)
{
for (int i=0; i<n; i++)
cout << A[i] << " ";
}
void main()
{
int Array[] = {1,3,5,7,9};
PrintArray(Array, 5);
getch();
}
void PrintArray(int A[], int n)
{
for (int i=0; i<n; i++)
cout << A[i] << " ";
}
8.2.4. Структуры как
параметры функций (1)
• Структуры могут передаваться по значению и по
ссылке
struct FIO
{
char Name[15];
char Surname[15];
};
1)
91
void modify(FIO);
void main()
{
FIO person;
strcpy(person.Name, "Ivan");
strcpy(person.Surname, "Ivanov");
modify(person);
cout << person.Name << " " << person.Surname;
getch();
}
void modify(FIO x)
{
strcpy(x.Name, "Peter");
strcpy(x.Surname, "Petrov");
}
8.2.4. Структуры как
параметры функций (2)
struct FIO
{
char Name[15];
char Surname[15];
};
void modify(FIO&);
void main()
struct FIO
{
char Name[15];
char Surname[15];
};
void modify(FIO*);
void main()
2)
3)
92
{
FIO person;
strcpy(person.Name, "Ivan");
strcpy(person.Surname, "Ivanov");
modify(person);
cout << person.Name << " "
<< person.Surname;
getch();
}
void modify(FIO& x)
{
strcpy(x.Name, "Peter");
strcpy(x.Surname, "Petrov");
}
{
FIO person;
strcpy(person.Name, "Ivan");
strcpy(person.Surname, "Ivanov");
modify(&person);
cout << person.Name << " "
<< person.Surname;
getch();
}
void modify(FIO* x)
{
strcpy(x->Name, "Peter");
strcpy(x->Surname, "Petrov");
}
8.2.5. Значение параметров
по умолчанию
1.23
1 234
93
1.234
1.23456
8.3. Перегрузка функций (1)
• Перегрузка функций – технология, при которой нескольким
функциям присваиваются одинаковые названия
1)
94
8.3. Перегрузка функций (2)
int Max(int, int);
int Max(int, int, int);
int Max(int*, int);
void main()
2)
95
void main()
{
cout << Max(10,20);
// 20
cout << Max(10,50,20); // 50
int A[] = {10, 4, 8, 88, 13, 45};
cout << Max(A, 6);
// 88
}
8.4. Указатели на функции (1)
• Функция располагается в памяти по определенному
адресу, который можно присвоить указателю в
качестве его значения
int sum(int a, int b)
{
void f1(char*);
int f2(char*)
1)
2)
96
{
return a+b;
}
void main()
{
int (*ptr)(int,int);
ptr = ∑
int z = (*ptr)(20,30);
cout << z;
getch();
}
int f2(char*);
void f3(int*);
void (*pf)(char*); // указатель на void(char*)
void f()
{
pf = &f1; // нормально
pf = &f2; // ошибка
pf = &f3; // ошибка
}
8.4. Указатели на функции (2)
int sum(int a, int b) { return a+b; };
int mult(int a, int b) { return a*b; };
typedef int (*CNT)(int, int);
void main()
{
CNT ptr[2] = {&sum, &mult};
int a = (*ptr[0])(10,20);
int b = (*ptr[1])(10 20)
3)
4)
97
int b = (*ptr[1])(10,20);
cout << a << " " << b;
getch();
}
8.5. Рекурсивные алгоритмы
• Рекурсия – способ определения объекта через ранее заданные
частные определения этого объекта
• Рекурсивный алгоритм – это алгоритм, который в процессе
своей работы вызывает самого себя
=
=
0
,1
!
при
n
n
int f(int x)
{
98
>
⋅
−
=
=
0
,
)!1
(
0
,1
!
при
при
n
n
n
n
n
{
if (x==0)
return 1;
else
return x*f(x-1);
}
void main()
{
cout << f(2) << " " << f(5);
getch();
}
9. Строки
9.1. Представление строк в памяти
• Текстовые строки представляются как массивы элементов типа
char
• Любая строка заканчивается служебным символом с нулевым
кодом – терминатором строки
99
9.2. Служебные символы
\\
Вывод обратной черты
\'
Вывод апострофа
\” Вывод кавычки
\a Подача звукового сигнала
\b Возврат курсора на один символ назад
\n Перевод строки
• Для обозначения в строке
некоторых служебных
символов используются
специальные
последовательности
символов – escape-
последовательности
100
\n Перевод строки
\r Возврат курсора на начало текущей строки
\t
Горизонтальная табуляция
\0 Терминатор строки
cout << "12345\n67890"; 12345
67890
cout << "Кавычка - \""; Кавычка - "
cout << "1\t2\t3";
1
2
3
cout << "abcdefg\r123"; 123defg
9.3. Работа со строками
9.3.1. Копирование строк
• Копирование строк осуществляется при помощи функций strcpy и
strncpy
1)
2)
101
2)
3)
4)
5)
9.3.2. Определение длины строки
• Фактическая длина строки, хранящейся в массиве char, может не
совпадать с размером самого массива
• Длина строки может быть определена при помощи функции strlen
102
1)
2)
9.3.3. Конкатенация строк
• Конкатенация строк – операция добавления
подстроки в конец исходной строки
1)
#include <string.h>
103
1)
2)
3)
9.3.4. Сравнение строк (1)
• strcmp – стандартное сравнение строк
• stricmp – сравнение строк без учета регистра
• strncmp – сравнение части строки
• strnicmp – сравнение части строки без учета регистра
104
1)
2)
9.3.4. Сравнение строк (2)
3)
4)
105
4)
5)
6)
9.3.5. Изменение регистра символов
• strlwr – приведение символов к нижнему регистру
• strupr – приведение символов к верхнему регистру
#include <string.h>
106
9.3.6. Дополнительные
строковые функции
strrev
Переворачивает
строку
задом
наперед
char str[] = "abcdefg";
strrev(str);
cout << str; // "gfedcba"
strset
Инициализирует строку заданным
символом
char str[10] = "abcdef";
strset(str,'?');
cout << str; // "??????"
strchr
Возвращает указатель на первое
вхождение заданного символа в
строку. Если заданный символ не
char str[] = "abcd!xyz!qwerty";
cout << strchr(str,'!'); // "!xyz!qwerty"
if (strchr(str,'$')==NULL)
107
строку. Если заданный символ не
найден, возвращает NULL
cout << "Символ $ не найден ";
strrchr
Возвращает указатель на последнее
вхождение заданного символа в
строку. Если заданный символ не
найден, возвращает NULL
char str[] = "abcd!xyz!qwerty";
cout << strrchr(str,'!'); // "!qwerty"
strstr
Возвращает указатель на первое
вхождение заданной подстроки в
исходную строку. Если подстрока
не найдена возвращает NULL
char str[] =
"tennis hockey voleyball pool football";
cout << strstr(str,"ball"); // "ball pool football"
strtok
Разбивает
строку
на
слова,
разделенные
через
заданный
символ
На самостоятельное изучение
#include <string.h>
9.4. Преобразование строк и чисел
1)
2)
108
3)
4)
5)
6)
9.5. Работа с символами
2)
109
1)
9.6. Работа с датой и временем
110
10. Ввод-вывод
• Обмен данными между
программой и
внешними устройствами
осуществляется с
помощью операций
ввода-вывода
• Поток – это логический
• Потоки:
– Текстовые
– Двоичные
• Стандартные потоки:
– stdin
– stdout
111
• Поток – это логический
канал,
предназначенный для
обмена информаций с
устройством ввода-
вывода
– stdout
– stderr
• Основные операции с
потоком:
– открытие
– позиционирование
– ввод
– вывод
– закрытие
10.1. Библиотека iostream
• cin – объект, предназначенный для работы
со стандартным потоком ввода
• cout – объект, предназначенный для
работы со стандартным потоком вывода
• cerr – объект, предназначенный для работы
со стандартным потоком вывода ошибок
• операция >> –
ввод данных
• операция << –
вывод данных
112
10.2. Библиотека stdio.h
10.2.1. Неформатированный
ввод-вывод строк
• Функция puts выводит строку в стандартный потое вывода,
добавляя к ней символ перевода строки '\n'
• Функция gets считывает из стандартного потока ввода строку
символов
113
1)
2)
10.2.2 Форматированный ввод (1)
• Функция scanf используется для форматированного ввода данных из
стандартного потока ввода:
– сканирует последовательность входных символов
– форматирует данные в соответствии с заданным спецификатором формата
format. записывает результаты по указанным адресам
• Функция sscanf используется для форматированного ввода данных из
заданной строки
114
% [*] [width] type_char
Спецификатор формата:
d – десятичное целое число
u – беззнаковое целое число
f – число с плавающей точкой
c – символ
s – строка
1)
2)
10.2.2. Форматированный ввод (2)
3)
4)
5)
115
5)
6)
7)
10.2.3. Форматированный вывод (1)
• Функция printf помещает заданную строку в стандартный поток
вывода, предварительно отформатировав ее в соответствии с
указанным правилом
Спецификатор формата:
116
–
Выравнивает результат влево, дополняя его справа
пробелами. Без указания данного флага результат
выравнивается по правому краю и дополняется
слева нулями или пробелами
+
Если значение аргумента имеет знак, то этот знак
всегда выводится (для положительных чисел
выводится знак +)
(пробел
)
Если значение неотрицательно, вывод начинается
с пробела. Отрицательные числа выводятся со
знаком минус.
0
дополнять поле до заданной ширины символом 0
d – десятичное целое число
u – беззнаковое целое число
f – число с плавающей точкой
c – символ
s – строка
1)
10.2.3. Форматированный вывод (2)
2)
117
3)
4)
10.2.3. Форматированный вывод (3)
5)
118
6)
10.2.3. Форматированный вывод (4)
7)
119
8)
10.3. Библиотека conio.h (1)
• Библиотека conio.h содержит функции консольного ввода-
вывода
int cprintf(const char *str, ...);
Аналог функции printf
int cscanf(const char *str, ...);
Аналог функции scanf
char* cgets(char *str);
Читает строку символов прямо с консоли и запоминает строку
и ее длину в местоположении, указанном str.
120
и ее длину в местоположении, указанном str.
int cputs(const char *str);
Выводит строку символов на экран без перевода на новую
строку. Возвращает последний выведенный символ.
int getch();
Ожидает ввода символа, после чего возвращает его код (без
вывода символа на экран)
int getche();
Ожидает ввода символа, после чего возвращает его код (с
выводом символа на экран)
int kbhit();
Проверяет нажатие клавиши на клавиатуре. Возвращает не
ноль в случае нажатия клавиши клавиатуры и ноль в
противном случае.
10.3. Библиотека conio.h (2)
puts("Выберите необходимое действие:");
puts("
1 - Решить линейное уравнение");
puts("
2 - Решить квадратное уравнение");
puts("
3 - Решить систему линейных уравнений");
puts("
ESC - Выход");
while (true)
{
int decision = getch();
switch (decision)
{
1)
2)
121
{
case '1':
solve1();
break;
case '2':
solve2();
break;
case '3':
solve3();
break;
case 27:
return;
}
}
2)
3)
11. Файловый ввод-вывод
11.1. Файловые потоки
• Работа с файлами осуществляется через
специальный потоковый указатель (FILE*)
• Функция fopen открывает файловый поток
• Функция fclose закрывает файловый поток
• Файлы:
– Текстовые
файлы
– Двоичные файлы
122
r
Чтение
w
Запись в новый файл
a
Добавление данных в файл
11.2. Ввод-вывод символов и строк (1)
• fputc – запись символа в файл
• fgetc – чтение символа из файла
• fputs – запись строки в файл
• fgets – чтение строки из файла
• fscanf – форматированный ввод из файла
• fprintf – форматированный вывод в файл
• feof – проверка достижения конца файла
123
• feof – проверка достижения конца файла
11.2. Ввод-вывод символов и строк (2)
1)
2)
124
3)
11.2. Ввод-вывод символов и строк (3)
4)
struct FIO
{
char name[25];
char patronymic[25];
char surname[25];
short age;
} A[3];
strcpy(A[0].name, "Иван");
strcpy(A[0].patronymic, "Иванович");
125
strcpy( [0].patronymic, Иванович");
strcpy(A[0].surname, "Иванов");
A[0].age = 25;
strcpy(A[1].name, "Петр");
strcpy(A[1].patronymic, "Петрович");
strcpy(A[1].surname, "Петров");
A[1].age = 32;
strcpy(A[2].name, "Андрей");
strcpy(A[2].patronymic, "Андреевич");
strcpy(A[2].surname, "Андреев");
A[2].age = 41;
11.2. Ввод-вывод символов и строк (4)
5)
126
11.3. Ввод-вывод двоичных данных (1)
• fread – чтение данных из потока
• fwrite – запись данных в поток
struct FIO
{
char name[25];
char patronymic[25];
1)
127
char patronymic[25];
char surname[25];
short age;
} A[3];
strcpy(A[0].name, "Иван");
strcpy(A[0].patronymic, "Иванович");
strcpy(A[0].surname, "Иванов");
A[0].age = 25;
strcpy(A[1].name, "Петр");
strcpy(A[1].patronymic, "Петрович");
strcpy(A[1].surname, "Петров");
A[1].age = 32;
11.3. Ввод-вывод двоичных данных (2)
2)
128
11.4. Позиционирование (1)
• ftell – узнать позицию текущей записи в файле
• fseek – перейти на заданную позицию в файле
• rewind – перейти к началу файла
129
SEEK_SET (=0) – начало файла
SEEK_CUR (=1) – текущая позиция в файле
SEEK_END (=2) – конец файла
11.4. Позиционирование (2)
1)
130
11.4. Позиционирование (3)
2)
131
12. Модульная программа
• Исходные файлы
проекта:
– заголовочные файлы (.h)
– файлы реализации (.cpp)
#include "array.h"
void sort(int* A, int n)
{
for (int i=0; i<n-1; i++)
{
int min_ind = i;
int min_val = A[i];
for (int j=i+1;
j<n; j++)
if (A[j]<min val)
lab.cpp
array.cpp
132
j
_
{
min_ind = j;
min_val = A[j];
}
A[min_ind] = A[i];
A[i] = min_val;
}
}
void print(int* A, int n)
{
for (int i=0; i<n; i++)
std::cout << A[i] << " ";
}
array.h
12.1. Спецификатор extern
• Спецификатор extern указывает, что идентификатор
уже был определен в другом месте программы
lab.cpp
133
unit.h
unit.cpp
12.2. Спецификатор static
• Спецификатор static используется для
объявления статических переменных
#include "unit.h"
void main()
{
f();
lab.cpp
unit.cpp
134
f();
f();
f();
getch();
}
unit.h
12.3. Этапы создания
исполнимой программы
135
13. Параметры командной строки
• Интерфейс командной строки позволяет передать в
вызываемую программу набор параметров
136
1)
2)
13.1. Переадресация
стандартного ввода-вывода
• (>) переадресация стандартного вывода на заданный файл
• (<) переадресация стандартного ввода на заданный файл
c:\>myapp < in.txt
Hello, world
Hello, world
Hello world
3)
137
c:\>myapp
5
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
Hello, world
1)
2)
4)
14. Директивы препроцессора
14.1. Директива #include
• Директива #include позволяет включить в исходный
модуль программный код, находящийся в другом
файле
• Имя включаемого файла должно соответствовать
соглашениям операционной системы и может
состоять либо только из имени файла, либо из имени
файла с предшествующим ему маршрутом
138
состоять либо только из имени файла, либо из имени
файла с предшествующим ему маршрутом
• Если имя файла указано в кавычках (“файл”), то
поиск файла осуществляется в соответствии с
заданным маршрутом, а при его отсутствии в
текущем каталоге
• Если имя файла задано в угловых скобках (<файл>),
то поиск файла производится в стандартных для
среды разработки директориях
14.2. Директива #define (1)
• Директива #define служит для замены часто использующихся констант,
ключевых слов, операторов или выражений некоторыми
идентификаторами
• Конструкции, определенные при помощи директивы #define,
подставляются в код программы препроцессором до основной
компиляции программы
• Для отмены действия директивы #define используется директива
#undef
139
#undef
Предкомпиляция
1)
14.2. Директива #define (2)
2)
140
#define MAX(x,y) ((x)>(y))?(x):(y)
t=MAX(i,s[i]);
t=((i)>(s[i])?(i):(s[i]);
3)
void main()
{
int a = (10+3)*(1.2+1.8);
printf("%d", a);
getch();
}
4)
14.3. Директива #ifdef
• Директива #ifdef позволяет добавлять код в программу, в
зависимости от того была ли определена некоторая константа
141
1)
2)
15. Форматирование кода
1)
void main(int argc, _TCHAR* argv[])
{
const int n=10;
int A[n] = {1 5 8 10 11 23 0 2 3 80};
2)
3)
142
int A[n] = {1,5,8,10,11,23,0,2,3,80};
for (int i=0; i<n-1; i++)
{
int min_ind = i;
int min_val = A[i];
for (int j=i+1;
j<n; j++)
if (A[j]<min_val)
{
min_ind = j;
min_val = A[j];
}
A[min_ind] = A[i];
A[i] = min_val;
}
}
15.1. Better simpler than clever
143
15.2. Использование комментариев
// ---------------------------------
// Выводит на экран массив A
// размером n элементов
// ---------------------------------
void print(int* A, int n)
{
for (int i=0; i<n; i++)
cout << A[i] << " ";
}
// ---------------------------------
// ГЛАВНАЯ ФУНКЦИЯ
144
// ГЛАВНАЯ ФУНКЦИЯ
// ---------------------------------
void main()
{
// Определяю размер массива
const int n=10;
// Объявляю и инициализирую массив
int A[n] = {1,5,8,10,11,23,0,2,3,80};
// Упорядочиваю массив
sort(A,n);
// Вывожу массив на экран
print(A,n);
// Ожидаю нажатия клавиши
getch();
}
15.3. Венгерская нотация
• Венгерская нотация — соглашение об именовании
переменных, констант и прочих идентификаторов в коде
программы
Префикс
Что обозначает
Пример
s
string
строка
sClientName
n, i
int
целочисленная переменная
nSize, iSize
l
long
длинное целое
lAmount
b
boolean
булева переменная
bIsEmpty
145
a
array
массив
aDimensions
t, dt
time,
datetime
время, дата и время
tDelivery,
dtDelivery
p
pointer
указатель
pBox
lp
long
pointer
дальний указатель
lpBox
r
reference
ссылка
rBoxes
h
handle
дескриптор
hWindow
g_
global
глобальная переменная
g_nSpeed
T
type
тип
TObject
Информация о работе Алгоритмические языки и программирование