Линейные алгоритмы

1. Линейные алгоритмы

2. Комментарии

//это однострочный комментарий
//каждый раз надо ставить символ //
//в начале строки, работает только в C++
/*а это многострочный комментарий, можно писать сколько
угодно строчек текста, главное не забыть закрыть его,
использовался в С, доступен в C++ */
2

3. Составной оператор {}

• позволяет объединить несколько инструкций в одно целое, открывающаяся
скобка ставится перед первой объединяемой инструкцией, закрывающаяся –
после последней объединяемой;
• тело функции main (как и любой другой функции) обязательно заключается в
составной оператор.
int main(){//это начало внешнего составного оператора
//здесь может быть какой-то код
{//это начало внутреннего составного оператора
int a = 3; //локальная переменная "a"
int b = a + 2; //5
}//это конец внутреннего составного оператора
float c = 5.5;
}//это конец внешнего составного оператора
3

4. Алфавит языка C++

• A..Z, a..z, _
• 0..9
• "{},| [] () +-/%*. \ ' : ? <=>! & # ~ ; ^
• пробел, табуляция, переход на новую строку
4

5. Программный объект

Объект - место в памяти, имеющее тип, определяющий вид информации,
разрешенной для хранения.
Переменная - именованный объект.
5

6. Идентификатор

Идентификатор — это имя программного объекта.
Правила задания идентификаторов:
• используются латинские буквы, цифры и знак подчеркивания (в
современных стандартах допустимо использование кириллицы, но обычно
не рекомендуется к использованию);
• прописные и строчные буквы различаются;
• первым символом может быть буква или знак подчеркивания, но не цифра;
• пробелы внутри имен не допускаются;
• не должен совпадать с ключевыми словами языка;
• длина идентификатора обычно ограничена 1 байтом (255 символов).
6

7. Определение переменной

• инструкция, вводящая новое имя в программе и выделяющая память для
переменной, называется определением (definition), не путать с объявлением
(declaration);
• в языке C++ определение переменной обычно происходить одновременно с
объявлением;
• C++ поддерживает возможность определения переменных в коде
программы по мере необходимости.
Синтаксис определения переменной:
тип_переменной имя_переменной;
7

8. Типы данных

int
2 байта
4 байта
float
4 байта
215..215 1
231..231 1
1.1 10 38..3.4 1038
double
8 байт
2.2 10 308..1.7 10308
long double 10, 12 или 16 байт (минимум 8 байт)
bool
1 байт
char
1 байт
void
2 или 4 байта
string
Определяется количеством символов
3.3 10 4932..1.1 104932
true или false
8 1
0
..
2
-
-
* сведения о диапазонах значений переменных стандартных типов хранятся в limits.h
** полная информация о базовых типах C++
https://en.cppreference.com/w/cpp/language/types#cite_note-1
8

9. Пример определения переменной

int Name;
double object_name;
9

10. Модификаторы порядковых типов

• short – короткий (только для типа int);
• long – длинный (для типов int, long int и double);
• signed – знаковый (для типов int и char);
• unsigned – беззнаковый (для типов int и char).
10

11. Влияние модификаторов на размер типа и диапазон значений

Тип
Размер в
байтах
Число бит
signed
unsigned
char
1
8
27..27 1
0..28 1
short int
2
16
215..215 1
0..216 1
long int
4
32
231..231 1
0..232 1
long long int
8
64
263..263 1
0..264 1
11

12. Функция sizeof()

Функция sizeof() позволяет определить размер типа (или программного
объекта) данных в байтах:
sizeof (char);
sizeof (float);
short var;
sizeof(var);
// 1
// 4
// 2

13. Заголовочный файл float.h

Содержит информацию о значениях типов с плавающей точкой:
• FLT_MIN, FLT_MAX – минимальное и максимальное значение типа float;
• DBL_MIN, DBL_MAX – минимальное и максимальное значение типа double;
• LDBL_MIN, LDBL_MAX – минимальное и максимальное значение типа long
double;

14. Диапазоны действительных типов в разных средах разработки

#include <iostream>
#include <float.h>
using namespace std;
int main() {
cout << sizeof(long double) << endl Code::Blocks
<< LDBL_MIN << endl
<< LDBL_MAX << endl;
cout << sizeof(double) << endl
<< DBL_MIN << endl
<< DBL_MAX << endl;
cout << sizeof(float) << endl
<< FLT_MIN << endl
<< FLT_MAX << endl;
}
Qt
Visual Studio

15. Присваивание

Оператор присваивания (=) записывает значение из правого операнда в ячейку
памяти, на которую ссылается левый операнд.
Инициализация – присваивание переменной начального значения при
одновременном ее определении в памяти
unsigned int Name = 15;
// инициализация
double object_name;
object_name = 3.5;
Name = Name + 3;
// определение в памяти
// присваивание
// присваивание
15

16. Оператор запятая и альтернативный способ инициализации переменной

int x, y; // определяем переменные x и y типа int
// переменные x и y содержат "случайный мусор"
float z(0); // определяем и инициализируем переменную z
// значением 0 при помощи
// конструктора типа float
// альтернатива float z = 0;
double d = double(); // определяем и инициализируем
// переменную d используя конструктор по
// умолчанию, который записывает в d значение 0
16

17. Цепочка операторов присваивания

int i, j, k; // определение переменных i, j и k
i = j = 0; // сначала в j записывается 0,
// затем в i записывается значение j
int y = k = 10; // сначала в k записывается значение 10,
// затем определяется в памяти переменная y
//и в нее записывается значение k
17

18. Именованные константы и литералы

Значения базовых типов данных представлены литералами:
• символьные: 'g', 'к', '=';
• строковые: "Это строковая константа";
• целые: 123, 3456;
• вещественные: 1.23, 123.0, 0.1234 (тоже, что .1234);
Возможно создание именованных констант:
const тип имя = значение;
Например:
const int someСonst = 123; //определяется именованная
// константа someConst, проинициализированная
// целочисленным литералом 123
18

19. Иерархия типов данных

От высокого к низкому:
• long double
• double
• float
• long
• int
• short
• char
* в выражении операнд с более «низким» типом будет преобразован к более «высокому»
типу.
19

20. Безопасные неявные преобразования

bool в char
bool в int
bool в double
char в int
char в double
int в double
20

21. Небезопасные неявные преобразования

double
double
double
int
int
char
в
в
в
в
в
в
int
char
bool
char
bool
bool
21

22. Примеры неявного преобразования типов

char c = 'x';
int i = c;
// i = 120
int j = 'x';
// j = 120
int a = 300;
char b = a;
// b = ',' – символ с кодом 44
double x = 1.5;
a = x;
// a = 1
22

23. Явное преобразование типов

• функция static_cast<новый тип>(имя) – для С++;
• операция (). Новый тип переменной записывается в круглых скобках перед
ее именем или имя записывается в круглых скобках после нового типа (язык
С).
float a, b;
cin >> a >> b;
int c = static_cast<int>(a);
int d = (int) b;
// или так d = int (b);
// например, 10.1 12.6
// c = 10
// d = 12
23

24. Выражение

Выражение – последовательность операторов, операндов и знаков
пунктуации,
воспринимаемую
компилятором
как
руководство
к
определенному действию над данными.
Инструкции – выражения, завершающиеся точкой с запятой (;)
Пример:
int a, b(1);
a = b - 5;
//a = b ++ b;
// верно, но
// синтаксическая ошибка, следует
// писать так:
a = b++; b;
// или так:
a = b; ++b;
24

25. Пустой оператор

Точка с запятой (;) является самостоятельным пустым оператором.
int a, b;
cin >> b;
a = b++;
; // ничего не значащая инструкция
;; // две пустых инструкции
if (a < 10)
; // оператор ";" составляет тело условного оператора
b--; // действие выполняется вне зависимости от
// истинности условия "a < 10"
25

26. Арифметические операции

Сложение
Вычитание
Умножение
Деление
Остаток от целочисленного деления
+
*
/
%
*оператор / ведет себя как целочисленное деление для двух целочисленных операндов
**оператор % применяется только к целочисленным операндам
26

27. Примеры использования арифметических операций

int a = 5 / 3;
int b = 5 % 3;
int c = 5 / 2;
int d = 5 % 2;
double e = 5 / 2.0;
double g = a / b;
double f = 5. / b;
int h = 5. / b;
double i = (double) a / b;
double j = a / static_cast<double>(b);
// a = 1
// b = 2
// c = 2
// d = 1
// e = 2.5
// g = 0.0
// f = 2.5
// h = 2
// i = 0.5
// j = 0.5
27

28. Значения вне диапазона типа (переполнение)

signed int si = 1500000000;
unsigned int ui = 1500000000;
si = si * 2 / 3;
si = si / 3 * 2;
ui = ui * 2 / 3;
ui = (ui * 10) / 10;
ui = (ui / 10) * 10;
ui = (static_cast<double>(ui) * 10) / 10;
// неверно
// верно
// верно
// неверно
// верно
// верно
28

29. Операции инкремента и декремента

префиксные (сначала операция применяется к операнду, затем его значение
используется в выражении):
++a, --a
постфиксные (сначала значение операнда используется в выражении, затем к
операнду применяется операция):
a++, a-Пример:
int a = 2, b = 4;
int c = b * a++;
int d = b * ++a;
// c = 8, a = 3;
// d = 16, a = 4;
29

30. Модификации оператора присваивания

+=
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;
30

31. Операторы сравнения (отношения)

• возвращают результат типа bool
<
<=
bool x = a < b;
bool x = a <= b;
>
>=
==
bool x = a > b;
bool x = a >= b;
bool x = a == b;
!=
bool x = a != b;
31

32. Приоритет операций

Приоритет Оператор
2
3
Описание
a++ a--
Суффиксный/постфиксный инкремент и декремент
a()
Вызов функции
++a --a
Префиксный инкремент и декремент
+a -a
Унарные плюс и минус
(тип)
Приведение типов в стиле C
5
a*b a/b a%b Умножение, деление и остаток от деления
6
a+b a-b
Сложение и вычитание
< <=
Операторы сравнения < и ≤ соответственно
> >=
Операторы сравнения > и ≥ соответственно
== !=
Операторы равенства = и ≠ соответственно
=
Прямое присваивание (предоставляется по умолчанию для классов C++)
+= -=
Составное присваивание с сложением и вычитанием
*= /= %=
Составное присваивание с умножением, делением и остатком от деления
,
Запятая
9
10
16
17
Ассоциативность
Слева направо
Справа налево
Слева направо
Справа налево
Слева направо
*полная таблица приоритетов https://ru.cppreference.com/w/cpp/language/operator_precedence

33. Математические функции

язык С++
заголовочный файл cmath:
double abs (double) - модуль числа
double pow (double, double) - возведения числа в степень
язык С
заголовочный файл math.h, используются те же функции, но:
int abs (int) – модуль числа типа int
double fabs (double) - модуль числа типа double
long labs (long) - модуль числа типа long
float fabsf (float) - модуль числа типа float
long double fabsl (long double) - модуль числа типа long double
33

34. Математические функции

язык С++
double log (double) – натуральный логарифм
double log10 (double) – десятичный логарифм
double exp(double) – возведение числа Эйлера e в степень
double sqrt (double) – квадратный корень
язык С
float logf(float) - натуральный логарифм типа float
long double logl(long double) - натуральный логарифм типа long double
float log10f (float) - десятичный логарифм типа float
long double log10l(long double) - десятичный логарифм типа long double
long double expl(long double) - возведение числа e в степень для long double
float sqrtf(float) – квадратный корень для типа float
long double sqrtl(long double) - квадратный корень для типа long double
34

35. Прочие функции

язык С++
double hypot (double, double) – гипотенуза по катетам
double min (double, double) – наименьшее из двух
double max (double, double) – наибольшее из двух
void swap (double, double) – обмен двух значений
int div (int, int) – целочисленное деление
35

36. Подключение заголовочных файлов

#include <имя_заголовочного_файла>
#include "имя_заголовочного_файла"
здесь:
• <имя_заголовочного_файла> - файл находится в папках, о которых знает
компилятор (обычно папка "include", можно изменить в настройках IDE);
• "имя_заголовочного_файла" – файл находится в локальной папке (обычно в
папке с текущим проектом, если задано только имя файла).
В языке С++ допустимо подключать заголовочные файлы – обертки над
заголовками C, для этого к имени заголовка C дописывается префикс "c", а
расширение файла не указывается. Например, вместо
#include <math.h>
используем
#include <cmath>

37. Функции fmod и modf

• double fmod(double, double) – вычисление остатка от деления при работе с
дробными числами;
• double modf(double, double*) – разделение дробного числа на целую и
дробную части.
37

38. Пример работы с функциями fmod и modf

Определить остаток от деления дробного числа а на дробное число b.
Вычислить целую и дробную часть дробного числа c.
double a(3.1), b(3);
double f = fmod(a, b); // f = 0.1
double c, fracPart, intPart;
c = 3.5;
fracPart = modf(c, &intPart);
// после исполнения этой строки в fracPart хранится
// дробная часть c, в intPart – целая часть
// fracPart = 0.5
// intPart = 3.0
38

39. Основные математические константы

• M_PI – значение числа