Основы языка программирования C++. Лекция 1

1.

Основы языка
программирования C++

2.

Глава 1 Простейшие конструкции языка
1.1 Алфавит и основные лексемы языка
программирования
Алфавит языка C++ включает:
1) латинские буквы (A-Z, a-z);
2) арабские цифры: 0-9;
3) специальные символы: + - * / = < & ; и т. д.;
4) пробельные символы: пробел, символы табуляции, символы
перехода на но­вую строку
Из символов алфавита формируются лексемы.
Лексема – это единица текста программы, расположенная между
пробельными разделителями, которая имеет самостоятельный смысл
для компилятора и не содержит в себе других лексем.
Лексемами языка С++ являются:
- идентификаторы;
- ключевые (зарезервированные) слова;
- константы;
- знаки операций;
2
- разделители (знаки пунктуации).

3.

1.1.1 Идентификаторы
Идентификатор – это имя программного объекта (последовательность
из букв латинского алфавита, десятичных цифр и символов
подчеркивания, начинающаяся не с цифры).
НЕЛЬЗЯ использовать
заглавные и строчные буквы различаются
• русcкие буквы
• скобки
• знаки +, =, !, ?, …
Примеры:
ABC
abc
Abc
1ABс ABc
AbC
MY_Primer_1
Prim_123
На длину различаемой части идентификатора конкретные реализации
накладывают ограничения.
Идентификаторы используются для обозначения имен переменных,
констант, типов подпрограмм и т.д.
3

4.

1.1.2 Ключевые слова
Ключевые
(служебные)
слова
–
это
идентификаторы,
зарезервированные в языке для специального применения. Их
использование строго регламентировано.
Далее приведен список ключевых слов, предусмотренных
стандартом ANSI.
auto
do
for
return
switch
break
double
goto
short
typedef
case
else
if
signed
union
char
enum
int
sizeof
unsigned
continue
extern
long
static
void
default
float
register
struct
while
В разных реализациях есть дополнительные ключевые слова.
4

5.

1.2 Структура программы
В состав программы входят:
директивы препроцессора
операторы (инструкции)
комментарии
<Команды препроцессора>
[<Объявление типов, пер-ых и констант>]
[<Объявления (прототипы) функций>]
<Описание функции main()>
[<Описания других функций>]
• Описание функции
<Тип результата или void> <Имя функции> ([<Список параметров>])
{[ < Объявление локальных переменных и констант >]
}
<Операторы>
5

6.

Пример программы на С
#include "stdafx.h"
#include <stdio.h>
Команды
препроцессора
int a=18,
b=24,
c;
int nod(int a,int b)
{
while (a!=b)
if (a>b) a=a-b;
else b=b-a;
return a;
}
int main()
{
c=nod(a,b);
printf("nod=%d\n", c);
return 0;
}
Объявление
переменных
Описание
функции
Основная
функция
6

7.

Пример программы на С++
// программа вводит с консоли число
// и выводит его на консоль
Ещё один вариант
оператор
Комментарии
после //
директива
определение
комментария:
#include <iostream>
подключения
не
препроцессора
функции
main
/*длинный
текст
*/ обрабатываются
пространства
using namespace std;
имён
int main()
начало блока
{
определение
Вывод текста
int a;
переменной
в поток cout
a
cout << "input number\n";
вывод
в поток
Ввод
данных
в
cout
переменную a
cin >> a;
cout << "number = " << a << endl;
return 0;
завершение
функции
конец
блока и
}
возврат
результата
7

8.

1.3 Константы и переменные
Основными объектами любой программы являются данные
Данные
Переменные
Константы
Литералы
поименованные
инициализированные
неинициализированные
8

9.

1.3.1 Константы
Константы – данные, не изменяемые в процессе выполнения
программы.
Поименованные константы – константы, обращение к которым
выполняется по имени. Они описываются в разделе описаний.
Литералы
–
это
лексема,
представляющая
изображение
фиксированного числового, строкового или символьного значения,
записанная в тексте программы.
Константы делятся на пять групп:
- целые,
- вещественные,
- перечислимые,
- символьные,
- строковые.
a=b+2,5 //неименованная константа;
‘1L’ - целочисленный литерал (тип long);
“8” – целочисленный литерал (тип Int);
‘f’, – символьный литерал, ‘\n’-конец строки
Формат описания именованной константы:
[<класс памяти>]const <тип> <имя
именованной константы>=<выражение>;
const int l= - 124; const float k1=2,345, k=1/k1
Компилятор, выделив константу, относит ее к той или другой группе по
ее «внешнему виду» (по форме записи) в исходном тексте и по
числовому значению.
9

10.

Константы(2)
Целые константы
могут быть десятичными, восьмиричными и
шестнадцатиричными.
Десятичная
константа
определена
как
последовательность
десятичных цифр, начинающаяся не с нуля, если это число не нуль.
Может быть отрицательной и положительной.
Пример: 16, 56783, 0, -567, 7865.
Восьмиричная константа
определена как последовательность
последовательность десятичных цифр от 0 до 7, всегда начинающаяся с
нуля. Может быть отрицательной и положительной.
Пример: 016, 020, 0777,
Шестнадцатиричная константа определена как последовательность
шестнадцатиричных цифр, которая начинается сочетанием 0х. Может
быть отрицательной и положительной.
Пример: 0х30, 0хF, 0xe,0x56AD.
В зависимости от значения целой константы компилятор представляет
ее в памяти в соответствии с типом. Для явного указания способа
представления программист может использовать суффиксы L,l или U,u
(64L, 067u, 0x56L).
10

11.

Константы(3)
Вещественные константы представлены в формате с плавающей
точкой.
Константа с плавающей точкой может включать семь частей:
- целая часть (десятичная целая константа);
-десятичная точка ;
-дробная часть (десятичная целая константа) ;
-признак экспоненты (символ e или E);
-показатель десятичной
возможно со знаком) ;
степени
(десятичная
целая
константа,
-суффикс F(или f) либо L(или l).
В записи вещественного числа могут опускаться целая или дробная
часть (но не одновременно), десятичная точка или признак экспоненты
с показателем степени, суффикс.
Пример: 66. .045 .0
3.1459F 1.34e-12 45E+6L
56.891
Без суффиксов F или L под вещественную константу отводится 8 байт.
11

12.

Константы (4)
Символьные константы – это один или два символа, заключенные в
апострофы.
Примеры:
‘Z’
‘*’ ’$’ ‘\012’ ‘\0’ ‘\n’ – односимвольные константы.
‘db’
‘\x07\x07’
‘\n\t’
- двухсимвольные константы.
Символ ‘\’ используется для
-записи кодов , не имеющих графического изображения
-символов (‘),(\),(?),(“)
-Задания символьных констант, указывая их коды в 8-ричном или 16 ричном виде.
Последовательность символов, начинающаяся с символа ‘\’
называется эскейп-последовательностью.
-
12

13.

Константы (5)
Строка или строковая константа определяется как последовательность
символов, заключенная в кавычки.
Пример:
“Это пример строки, называемой строковой константой”
Среди символов строки могут быть эскейп-последовательности, то есть
сочетания, соответствующие неизображаемым символьным константам
или символам, задаваемых их внутренними кодами. В этом случае они
начинаются с символа ‘\’ .
“\nЭто строка,\nиначе -\”стринг\”,\nиначе - \”строковый литерал\”.”
Во внутреннем представлении строковая константа – массив символов,
завершающийся символом с кодом 0 (‘\0’)
13

14.

1.3.2. Переменные
Переменные – поименованные данные, которые могут изменяться в
процессе выполнения программы.
Переменные характеризуются именем и значением.
Именем служит идентификатор.
Переменная – это частный случай объекта как поименованной области
памяти. Отличительной чертой переменной является возможность
связывать с ее именем различные значения, совокупность которых
определяется типом переменной.
При определении значения переменной в соответствующую ей область
памяти помещается некоторый код.
Это может происходить:
-во
время
компиляции,
инициализированной (int s=56);
тогда
переменная
называется
-во время выполнения программы, тогда переменная называется
неинициализированной (char C ).
Переменная типизируется с помощью определений и описаний.
14

15.

1.4 Типы данных
Тип – описатель данных, который определяет:
а) диапазон изменения значения, задавая размер ее внутреннего
представления;
б) множество операций, которые могут выполняться над этой
переменной
в) требуемое для переменной количество памяти при ее
начальном распределении
г) интерпретацию двоичного кода значений при последующих
обращениях к переменным.
Кроме того, тип используется для контроля типов с целью
обнаружения возможных случаев недопустимого присваивания.
В С++ стандартно определено большое количество типов, которые
программист может использовать без предварительного описания.
15

16.

1.4.1 Фундаментальные типы данных
1. Интегральные типы
Имя типа
Размер ,
байт
Интервал
значений
[signed] char
unsigned char
1
-128..127
0..255
short или _int[16] [signed] short
unsigned short
2
-32768..32767
0..65535
[int] или long или [signed] [int]
_int[32]
unsigned [int]
[signed] long
unsigned long
4
-231.. 231-1
0.. 232-1
long long или
_int[64]
8
-263.. 263-1
0.. 264-1
1
false (0), true(1)
char или _int[8]
bool
Подтипы
[signed] long long
Unsigned long long
16

17.

Фундаментальные типы данных (2)
2. Вещественные типы
Тип
Размер,
байт
Значащих
цифр
Минимальное
положительное
число
Максимальное
положительное
число
float
4
6
1.175494351е-38
3.402823466е38
double
(long
double)
8
15
2.2250738585072014
е-308
1.797693134862318
e308
3. Неопределенный тип void
Нельзя объявлять значения типа void, он используется только при
объявлении
• нетипизированных указателей;
• функций, не возвращающих значений (процедур).
17

18.

1.5 Объявление переменных и поименованных
констант
[класс памяти] [const] <Тип> <Список идентификаторов>
[=<Значение>];
где необязательный класс памяти может принимать одно из значений
auto, extern, static и register;
const – поименованная константа,
<Тип> – описатель типа: int, char, float, double и т.д.;
<Список идентификаторов> – список имен переменных или констант;
<Значение> – начальное значение переменной или значение
константы.
18

19.

Примеры объявлений переменных и констант
Неинициализированные переменные:
int f,c,d; float r;
I,j;unsigned int max,min;
сhar c1,c2; unsigned char c5;
Инициализированные переменные
double k=89.34; char ch=‘G’;
Поименованные константы
const long a=6; const float pp=6.6e-34;
На практике все объявления могут быть перемешаны в описаниях
программы:
const char simt=‘T’;float max=100,min=-100;
double f,s,eps=0.001;
Переменные и поименованные константы могут быть объявлены в
любом месте программы:
вне всех функций, внутри функций, в любом месте функции.
Основное условие – объявление должно стоять до обращения к
переменной или константе.
19

20.

Управление форматом вещественных типов данных
Аспекты оформления значения с плавающей запятой которыми можно
управлять:
- точность, которая изменяется с помощью манипулятора setprecision;
- форма записи (десятичная или экспоненциальная);
- указание десятичной точки для значения с плавающей запятой, являющихся
целыми числами.
Результат работы программы:
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
6 значащих цифр
12345.7
double i=12345.6789;
cout.width(10); cout << setprecision(3)<<i<<endl;
cout.width(10); cout << setprecision(6)<<i<<endl;
cout << setprecision(9)<<i<<endl;
cout << fixed<< setprecision(9)<<i<<endl;
cout << scientific << setprecision(9)<<i<<endl;
return 0;}
всего 10 знаков
1.23e+004
1,23 104

21.

Управление размещение данных на экране
Используются манипуляторы:
1. left – выравнивает вывод по левому краю;
2. right – выравнивает вывод по правому краю;
3. internal – контролирует размещение отрицательного значения: выравнивает знак по левому
краю, а значение по правому, заполняя пространство между ними пробелами;
4. setprecision(int w) – устанавливает max количество цифр в дробной части для вещественных
чисел;
5. setw(int w) – устанавливает max ширину поля вывода;
Пример:
Получим:
#include <iostream>;
#include <iomanip>
using namespace std;
int main()
{ cout <<“1” <<setw(10) <<“Ivanov” <<endl;
cout <<“2” <<setw(10) <<left<<“Ivanov” <<endl;
cout <<“3” <<setw(10) <<right<<“Ivanov” <<endl;
return 0;}

22.

Класс памяти
Класс памяти определяет время жизни и область видимости
программного объекта (в частности, переменной). Если класс
памяти не указан явным образом, он определяется компилятором
исходя из контекста объявления.
Время жизни может быть постоянным (в течение выполнения
программы) и временным (в течение выполнения блока).
Областью видимости идентификатора называется часть текста
программы, из которой допустим обычный доступ к связанной с
идентификатором областью памяти. Чаще всего область
видимости совпадает с областью действия. Исключением является
ситуация, когда во вложенном блоке описана переменная с таким
же именем. В этом случае внешняя переменная во вложенном
блоке невидима, хотя он и входит в ее область действия. Тем не
менее к этой переменной, если она глобальная, можно обратиться,
используя операцию доступа к области видимости.
Для задания класса памяти используются следующие
спецификаторы:
22

23.

Класс памяти (2)
auto — автоматическая переменная. Память под нее выделяется в
стеке и при необходимости инициализируется каждый раз при
выполнении оператора, содержащего ее определение.
Освобождение памяти происходит при выходе из блока, в котором
описана переменная. Время ее жизни — с момента описания до
конца блока. Для глобальных переменных этот спецификатор не
используется, а для локальных он принимается по умолчанию,
поэтому задавать его явным образом большого смысла не имеет.
extern — означает, что переменная определяется в другом месте
программы (в другом файле или дальше по тексту). Используется
для создания переменных, доступных во всех модулях программы,
в которых они объявлены.
static — статическая переменная. Время жизни — постоянное.
Инициализируется один раз при первом выполнении оператора,
содержащего определение переменной. В зависимости от
расположения оператора описания статические переменные могут
быть глобальными и локальными. Глобальные статические
переменные видны только в том модуле, в котором они описаны.
register — аналогично auto, но память выделяется по возможности
в регистрах процессора. Если такой возможности у компилятора 23
нет, переменные обрабатываются как auto.

24.

Пример использования спецификаторов
int а; //1 глобальная переменная а
int main(){
int b; // 2 локальная переменная b
extern int X; //3 переменная x определена в другом месте
static int с; // 4 локальная статическая переменная с
а = 1; //5 присваивание глобальной переменной
int а; // 6 локальная переменная а
а = 2; //7 присваивание локальной переменной
::а = 3: //8 присваивание глобальной переменной
return 0;
}
int X = 4; // 9 определение и инициализация х
24

25.

1.5.1. Перечисляемый тип
Используется для объявления набора поименованных целых констант.
Формат:
enum {<Ид>[=<Целое>] [,<Ид>[<>]…]}
<Список переменных>;
Пример:
enum {SUN, MON, TUES, FRI=5, SAT} day;
Имя
переменной
SUN =0, MON = 1, TUES = 2, FRI=5, SAT=6
Константы присваиваются, начиная с нуля или с указанного значения.
25

26.

Пример использования перечислимых типов
#include <iostream>
enum WeekDay
{
Создание
MONDAY = 1,
перечисления
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY,
Инициализация
SUNDAY,
переменной
};
данного типа
int main()
{
int day; std::cin>>day;
WeekDay d = WeekDay(day);
switch (d) {
case SUNDAY: std::cout << "Today is SUNDAY";
break;
case MONDAY: std::cout << "Today is MONDAY";
break;
Вывод значения
26
...
}
return 0;

27.

1.6 Объявление типа пользователя
typedef <Описание типа> <Имя объявляемого типа>;
Примеры:
Имя
нового типа
1) typedef unsigned int word;
2) typedef enum {false, true} boolean;
3) typedef struct{
char fio[30];
int date, code;
Имя
нового типа
Имя
double salary;} Worker;
нового типа
27

28.

1.7 Выражения
Выражение – это последовательность операндов, разделителей и
знаков операций, задающая вычисление
Выражение есть правило для получения значения.
В качестве операндов могут выступать константы, переменные,
стандартные функции, определенные в языке.
Порядок операций определяется рангами (приоритетами) и правилами их
группирования (ассоциативностью).
Для изменения порядка выполнения операций используются круглые
скобки.
Операции делятся на
- унарные;
- бинарные.
Бинарные могут быть:
- аддитивные;
- поразрядные;
- мультипликативные;
- операции отношения
- сдвиговые;
- логические
28
- операции присваивания

29.

1.8 Операции
Унарные операции
Выполняются над одним операндом
- унарный минус - меняет знак арифметического операнда;
+ унарный плюс - введен для симметрии с унарным минусом;
! логическое отрицание;
if (!valid)
эквивалентно
& операция получения адреса операнда
if (valid == 0)
* обращение по адресу (операция разыменования)
Порядковые:
++<идентификатор>, <идентификатор>++ (следующее);
- -<идентификатор>, <идентификатор> - - (предыдущее).
Эти операции, называемые также инкрементом и декрементом, имеют
две формы записи — префиксную, когда операция записывается
перед операндом, и постфиксную. В префиксной форме сначала
изменяется операнд, а затем его значение становится результирующим
значением выражения, а в постфиксной форме значением выражения
является исходное значение операнда, после чего он изменяется.
29

30.

Пример операций декремента и инкремента
на языке С
#include <stdio.h>
int main(){
int X = 3, y = 3;
printf("Значение префиксного выражения: %d\n", ++х);
printf("Значение постфиксного выражения: %d\n ", у++);
printf("Значение х после приращения: %d\n ", х);
printf("Значение у после приращения: %d\n ", у);
int i = 0;
return 0; }
int j = i--;
на языке С++
#include <iostream>
using namespace std;
Можно применять только
int main()
к переменным, иначе:
{setlocale(LC_ALL, "Russian");
int i = (j + y)++; /* ошибка */
int x = 3, y = 3;
cout << " Значение префиксного выражения: "<< ++x <<endl;
cout << " Значение постфиксного выражения: "<< y++ <<endl;
cout << " Значение х после приращения: "<< x <<endl;
31
cout << " Значение у после приращения: "<< y;
return 0;}

31.

Унарная операция sizeof
Операция определения размера sizeof предназначена для
вычисления размера объекта или типа в байтах, и имеет две формы:
sizeof выражение
sizeof ( тип )
Пример:
#include <iostream>
using namespace std;
int main(){
float x = 1;
cout << "sizeof (float) :" << sizeof (float);
cout << "\nsizeof x :" << sizeof x;
cout << "\nsizeof (x + 1.0) :" << sizeof (x +1.0);
return 0;
}
32

32.

Операции(2)
БИНАРНЫЕ
Аддитивные:
+, -,
Мультипликативные:
* - умножение, если операнды целые, то результат целый;
/ - если оба операнда целочисленные, результат операции
округляется до целого числа,
% - остаток от деления целых чисел.
Пример:
int a=5;int b = 3; float c=9.3
…
a+b
8
a / b
1
a % b
2
a*b
c / b
15
2
3.1
33

33.

Операции (3)
Операции отношения – применяют к числам, символам– в
результате получают логическое значение:
<, <=, >, >, ==, !== результат – это истина или ложь
В С++ истина – это не 0 (true)
ложь – это 0 (false)
Пример:
int a = 5; int b = 3;
…
a > b
не 0
a == b
0
34

34.

Операции(4)
Логические
&& - конъюнкция (и) арифметических операндов или операций
отношений. Результат целочисленный 0 (ложь) или не 0 (истина).
|| - дизъюнкция (или) арифметических операндов или отношений.
Результат целочисленный 0 (ложь) или не 0 (истина).
(к логическим операциям относится и унарная операция ! -отрицание).
Чаще всего операндами логических операций являются условные
выражения.
Логические выражения:
выражение1&&выражение2 – истинно только тогда, когда оба
выражения истинны;
выражение1||выражение2 – истинно, хотя бы одно из выражений
истинно;
!выражение - истинно, если выражение ложно, и наоборот.
x !=0 && 20/x<5 - второе выражение вычисляется, если х!=0.
Вычисления операторов && и || прекращаются как только станет
известна истинность или ложность результата
35

35.

Операции (5)
Логические поразрядные
& (и) - поразрядная конъюнкция (и) битовых представлений
значений целочисленных выражений,
| (или) поразрядная дизъюнкция (или) битовых представлений
значений целочисленных выражений,
^ (исключающее или) поразрядная исключающая или битовых
представлений значений целочисленных выражений.
Примеры:
#inclucle <iostream>
using namespace std;
int main(){
00000110 & 00000101 00000100
cout << "\n 6 & 5 = " << (6 & 5);
cout << "\n 6 | 5 = " << (6 | 5);
00000110 | 00000101 --> 00000111
cout << "\n 6 ^ 5 = " << (6 ^ 5);
return 0;
00000110 ^ 00000101 00000011
}
36

36.

Операции (6)
Операции сдвига
>> сдвиг вправо битового представления значения левого
целочисленного операнда на количество разрядов, равное
значению правого целочисленного операнда,
<< сдвиг влево битового представления значения левого
целочисленного операнда на количество разрядов, равное
значению правого целочисленного операнда.
Примеры:
4<<2 16
00000100 << 00010000
4
5>>1
2
00000101 >>
5
16
00000010
2
37

37.

Операции(7)
Операции присваивания
В С++ присваивание относится к операциям и используется для
формирования бинарных выражений. Поэтому в С++ отсутствует
отдельный оператор присваивания.
В качестве левого операнда в операциях присваивания может
использоваться только переменная.
= += -= *= /= %= &= ^= |= <<= >>=
= - присваивает левому операнду значение выражения правой части;
Остальные операции присваивают левому операнду результат
выполнения операции, указанной слева от операции равно, левого
операнда и правого.
Примеры:
Int k;
k=35/4;
k*=5-2;
k+=21/3;
8
24
31
38

38.

Операции(8)
Условная операция
Единственная операция, которая выполняется над тремя
операндами и является тернарной операцией
выражение_1 ? Выражение_2 : выражение_3
Сначала вычисляется выражение 1
Если оно истинно (не равно нулю), то вычисляется выражение 2 и
его значение становится значением всего условного выражения
В противном случае вычисляется выражение 3 и становится
значением всего условного выражения
Пример:
#include <iostream>
using namespace std;
int main(){ setlocale(LC_ALL, "Russian");
int a = 11, b = 4, max; max = (b > a)? b : a;
cout << "Наибольшее число: " << max;
return 0; }
39

39.

Операции (9)
Запятая, как разновидность операции
В С++ несколько выражений могут быть записаны через запятую.
Выражения, разделенные запятой выполняются последовательно
слева направо.
<Выражение1>,<Выражение2>,...<Выражение n>
В качестве результата сохраняется тип и значение самого правого
выражения.
Примеры:
int m=5,z;
m=25, z=75
z=(m=m*5,m*3);
int d,k;
k=(d=4,d*8);
d=4, Результат k=32
В С++ круглые и квадратные скобки также играют роль бинарных
операций (обращение к функциям, обращение к элементам массива и
т.д.)
40

40.

Приоритет операций
1. ( ) [ ] -> :: .
2. ! (не) + - ++ -- &(адрес) *(указатель) sizeof new delete
3. .* ->*
4. * / %
5. + - (бинарные)
6. << >>
7. < <= > >=
8. = = ! =
9. &(поразрядное и)
10. ^(исключающее или)
11. | (поразрядное или)
12. &&
13. ||
14. ?:
15. = *= /= %= += -= &= ^= |= <<= >>=
16. ,
41

41.

Математические функции
В выражениях можно использовать следующие математические
функции из библиотеки <math.h> или <сmath> :
Функция
Описание
Пример
Тригонометрические функции*
sin(a)
a задаётся в радианах
sin(30.*M_PI/180)=0.5
cos(a)
tan(a)
a задаётся в радианах
a задаётся в радианах
cos(60.*M_PI/180)=0.5
tan(45.*M_PI/180)=1.0
atan(a)
арктангенс значения a
аsin(a)
аcos(a)
atan (1.) * 180.0 / M_PI=45
арксинус a, где -1.0 < а < 1.0 asin(1.)=1.5708
арккосинус a, где -1.0 < а < 1.0 acos(0.5)=1.0472
Дополнительные функции: cosh, sinh и tanh.
*В С++ для использования числа PI нужно подключить директиву
#define _USE_MATH_DEFINES,
а затем использовать константу M_PI=3.14159265358979323846. 42

42.

Математические функции
В выражениях можно использовать следующие математические
функции из библиотеки <math.h> или <сmath> :
Функция
Описание
Пример
Экспоненциальные и логарифмические функции
exp(a)
вычисление экспоненты еа
exp(0)=1
log(a)
натуральный логарифм a
log(1.0)=0.0
log10(a)
десятичный логарифм а
log10(100)=2
Функции степени
pow(a, b) возведение а в степень b
pow(2,3)=8
sqrt(a)
sqrt(9.0)=3.0
корень квадратный из а (a>0)
cbrt(a)
вычисление кубического корня из а cbrt(8.0)=2.0
hypot(a,b) вычисление гипотенузы
hypot(3.,4.)=5
43

43.

Математические функции
В выражениях можно использовать следующие математические
функции из библиотеки <math.h> или <сmath> :
Функция
Описание
Пример
Округление, модуль и другие функции
ceil(a)
округление а до наименьшего
целого, но не меньше чем а
ceil(2.3)=3.0
ceil(-2.3)=-2.0
floor(a)
округление а до наибольшего
целого, но не больше чем а
floor(12.4)=12
floor(-2.9)=-3
fmod(a, b) вычисление остатка от a/b
fmod(4.4, 7.5) = 4.4
fmod(7.5, 4.4) = 3.1
abs( a )
модуль или абсолютное значение
от а
abs(-5)= 5
abs(100)= 100
fabs( a )
модуль или абсолютное значение
от а для веществ. чисел
fabs(-3.0)= 3.0
fabs(5.0)= 5.0
44

44.

Генератор случайных чисел
Для использования случайных чисел необходимо подключение
библиотеки <conio.h> или <cstdlib>.
rand () – функция генерации случайного числа на отрезке [0,RAND_MAX].
Пример:
int X, Y;
Результат:
X = rand(); // псевдослучайное число
Y = rand(); // это уже другое число!
Задача: Сгенерировать целые числа x и y на отрезке [a,b]:
int X, Y;
X = a + rand() % (b - a + 1);
[0,b-a]
Y = a + rand() % (b - a + 1);
/
srand() – функция рандомизации от аргумента
#include <ctime>
srand( (unsigned)time(NULL)); // автоматическая рандомизация
cout << "rand_value = " << 1 + rand() % 100 << endl;
45