7 Структурное программирование 2012
.pdf11
7.6 Рекурсивные подпрограммы
В операторной части подпрограммы доступны все идентификаторы, описанные во внешнем блоке программы, в том числе и собственное имя. Это означает, что подпрограмма может вызвать сама себя. Такая ситуация получила название рекурсия. Рекурсивной называется подпрограмма, которая внутри своей операторной части вызывает саму себя.
Рекурсия находит широкое применение в ряде алгоритмов математических вычислений. В этом случае она позволяет упростить тексты программы. Примером может служить функция определения факториала числа:
int fac(int n) {return (n>1) ? n*fac(n-1) : 1; }
Что может быть переписано в виде: int fac(int n)
{ |
if (n > 1) |
return n*fac(n-1); |
|
else |
return 1; |
} |
|
|
Отрицательным |
моментом использования рекурсивных подпрограмм является то, |
|
что при каждом новом вызове подпрограммы самой себя в стеке создается новая копия подпрограммы и может возникнуть ситуация, когда в стеке не останется свободного объема памяти для организации новой копии подпрограммы, что приведет к аварийному прекращению выполнения программы с ошибкой "Переполнение стека". Пример подпрограммы иллюстрирующей описанную ситуацию приводится ниже
void fool() { fool();
}
Может иметь место случай косвенной рекурсии, когда подпрограмма вызывает другую подпрограмму, которая внутри себя вызовет первую. Пример
int |
f1() |
{ |
f2; |
… |
; |
return |
0}; |
// |
В |
теле |
имеет вызов rf2 |
int |
f2() |
{ |
f1; |
… |
; |
return |
0} |
// |
В |
теле |
функция имеет вызов rf1 |
7.7 Пример использования подпрограмм
Ниже приводится пример программы расчета значений матрицы результата путем возведения в квадратную степень значений исходной матрицы, вводимой с клавиатуры.
#include <iostream.h> |
|
|
|
|
||
int entry(float |
M[4][4]); |
// прототип функции ввода данных |
||||
int |
count(float |
M1[4][4], float M2[4][4]);// |
прототип |
функции |
расчета |
|
int |
outdata(float M[4][4]); |
// |
прототип |
функции |
вывода результатов |
|
double degree(double x, unsigned |
int n=2);// прототип функции возведения в степень |
|||
int main(void) |
// |
определение головной функции |
||
{ float A[4][4], B[4][4]; |
// |
локальные матрицы исходных данных и результата |
||
entry(A); |
// |
вызов |
функции для ввода данных в матрицу А |
|
count(A,B); |
// |
расчет матрицы В результата вызовом функции |
||
cout << “\nИсходная матрица |
\n”; // |
сообщение на экране |
||
outdata(A); |
// |
вывод |
элементов исходной матрицы А на экран |
|
cout << “\nМатрица результата \n”; |
// сообщение на экране |
|||
outdata(B); |
// |
вывод |
элементов матрицы результата В на экран |
|
return 0; |
// |
код успешного завершения программы |
||
} // main ---------------------------------------------------------- |
||||
int entry(float M[4][4]) |
|
// |
определение функции ввода матрицы |
|
{ for(int i=0; i<4; i++){ |
|
// |
цикл изменения индексов строк |
|
for(int j=0; j<4; j++) |
|
// |
цикл изменения индексов столбцов |
|
{ cout << "\nM[" << i << |
"." << j |
<< "]="; |
// экранный запрос |
|
cin >> M[i][j]; |
|
// |
ввод элемента с клавиатуры |
|
} |
|
|
|
|
} return 0; |
|
// |
код успешного завершения entry |
|
} // entry ---------------------------------------------------------- |
||||
int count(float M1[4][4], float M2[4][4]) |
// определение функции расчета |
|||
{ for(int i=0; i<4; i++) |
|
|
|
// цикл изменения индексов строк |
for(int j=0; j<4; j++) |
|
|
|
// цикл индексов столбцов |
|
|
|
|
|
|
|
12 |
|
|
|
|
|
M2[i][j]=degree(M1[i][j]); |
|
|
|
|
|
// расчет элемента результата |
||||||
return 0; |
// код успешного завершения count |
|||||||||||
} // count ---------------------------------------------------------------- |
|
|
|
|
|
|
|
|||||
int outdata(float M[4][4]) |
// определение функции вывода матрицы на экран |
|||||||||||
{ for(int i=0; i<4; i++){ |
// цикл изменения |
вывода строки |
||||||||||
for(int j=0; j<4; j++) cout << M[i][j] << " |
"; |
// цикл вывода в строке |
||||||||||
cout << endl; |
|
|
|
|
|
|
// переход на новую строку |
|||||
} |
|
|
|
|
|
|
|
|
|
|
|
|
return 0; |
// код успешного завершения outdata |
|||||||||||
} // outdata --------------------------------------------------------------- |
|
|
|
|
|
|
|
|||||
double degree(double x, unsigned int n) |
|
// определение функции степени |
||||||||||
{ double res=1; |
|
|
// локальная переменная результата |
|||||||||
for(int i=1; i<=n; i++) res=res*x; |
|
|
// цикл расчета степени |
|||||||||
return res; |
// возврат результата в точку вызова |
|||||||||||
} // degree ---------------------------------------------------------------- |
|
|
|
|
|
|
|
|||||
|
|
Начало |
|
|
|
|
|
|
|
|||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
entry(A) |
|
|
|
|
Ввод исходных данных с клавиатуры |
|||||
|
|
|
|
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
|||
|
|
count(A,B) |
|
|
|
|
Расчет матрицы результата |
|||||
|
|
|
|
|
|
|
|
|
|
|
||
|
|
‘Исходная |
|
|
|
|
||||||
|
|
|
|
Вывод строки сообщения на экран |
||||||||
|
|
матрица’ |
|
|
|
|
|
|
|
|||
|
|
|
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
outdata(A) |
|
|
|
|
Вывод исходной матрицы на экран |
|||||
|
|
|
|
|
|
|
|
|
|
|
||
|
|
‘Матрица - |
|
|
|
Вывод строки сообщения на экран |
||||||
|
|
|
|
|
||||||||
|
|
результат’ |
|
|
|
|
|
|
|
|||
|
|
|
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
outdata(B) |
|
|
|
|
Вывод матрицы результата на экран |
|||||
|
|
|
|
|
|
|
|
|
|
|
|
|
Конец
Рисунок 7.3 – Схема головной программы entry
i |
от |
1 |
до |
4 |
j |
от |
1 |
до |
4 |
|
M[i][j] |
|||
М
Циклическая модификация индексов элементов массива
Ввод по запросу значения элемента с клавиатуры
Передача массива в программу через параметр-переменную
Выход
Рисунок 7.4 – Схема подпрограммы ввода матрицы
13
count
|
|
M1 |
|
|
i |
от |
1 |
до |
4 |
j |
от |
1 |
до |
4 |
M2[i][j]=degree
(M1[i][j])
M2
Выход
Получение исходной матрицы из программы через параметры
Циклическая модификация индексов элементов массива
Расчет элементов матрицы М2
Передача M2 в программу через параметр-переменную
Рисунок 7.5 – Схема подпрограммы расчета массива результата
OutMatrix
|
|
|
|
|
|
|
|
|
|
|
|
М |
|
|
|
|
|
Получение матрицы |
|
|
|
|
|
|
|
|
|
|
из программы |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
i от 1 |
до 4 |
|
|
|
|
|
Цикл номера строки |
|
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Перевод курсора |
|||||
|
|
|
|
|
|
|
|
|
|
|
j от 1 |
до 4 |
|
|
|
Цикл номера столбца |
|||
|
|
||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
M[i][j] |
|
|
|
|
|
||
|
|
|
|
|
Вывод в троке значения |
||||
|
|
|
|
|
|
|
элемента матрицы |
||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Выход
Рисунок 7.6 – Схема подпрограммы вывода матрицы на экран
14
7.9 Модульность языков программирования С и С++
Модули являются в языках C и C++ основой модульного программирования. Они используются для создания библиотек, которые могут включаться в различные программы (при этом становится необязательным иметь в наличии исходный код), а большие программы могут подразделяться на логически связанные модули.
Модульность программ дает следующие преимущества:
а) сокращает общий объем программ за счет того, что наиболее часто использующиеся программные ресурсы помещаются вне программы, и они могут использоваться другими программами;
б) повышается наглядность программ; в) улучшается процесс отладки программ, так как в модуль помещаются откомпи-
лированные верифицированные программные ресурсы; г) защищаются авторские права программиста, так как при продаже или про-
граммном обмене можно поставлять откомпилированные tpu-файлы модулей с описанием интерфейса, а не исходные тексты программ.
Недостатками модулей являются а) проблемы связанные с совместным использованием программной нескольких мо-
дулей (доступа к компонентам, имеющим одинаковые имена, или несовместимость некоторых модулей);
б) увеличение числа файлов, необходимых для работы над программой. В языках С и С++ модули представлены тремя видами:
1) одиночные заголовочные файлы, имеющие расширение .h;
2) файлы программных модулей, состоящие из одноименных заголовочного и cppфайлов файлов;
3) динамически подключаемые библиотеки (DLL-модули)
В простейшем случае модульность языка С и С++ может быть представлена, как возможность подключения с помощью директивы препроцессора include в других программах фрагментов кода из других cpp-файлов. Однако при этом следует следить за тем, чтобы переменные и функции имели различные имена, а также за тем, чтобы в объединенном коде было единственно определение функции main.
Директива #include "имя файла"
замещает строку, в которой встретилось #include, содержимым исходного текста на C++ файла указанного файла.
Для отдельных программных модулей проекта можно объявить часть переменных и функций как внешние с помощью директивы extern, которая означает, что переменная получает значение во внешней к рассматриваемой программе части или имеется внешнее определение функции. При описании функции с помощью директивы extern указывается только ее заголовок.
Если необходимо использовать одноименную переменную только локально, внутри модуля, тогда ее можно определить как static
7.10 Заголовочные файлы
|
Для использования программных ресурсов созданных ранее файлов исходных тек- |
||
стов, необходимо в начале программы с помощью директивы препроцессора |
#include |
||
подключить к программе файл в формате |
|
|
|
|
#include <имя заголовочного файла> |
// из стандартного каталога |
INCLUDE |
или |
#include "имя заголовочного файла" |
// из текущего каталога |
|
замещает строку, в которой встретилось #include, содержимым исходного |
текста на |
||
C++файла указанного файла. |
|
|
|
|
Следующее эмпирическое правило является не требованием языка, а |
просто пред- |
|
ложением по разумному использованию аппарата #include. |
|
||
|
В заголовочном файле могут содержаться: |
|
|
|
1) Определения типов, например: |
struct point { int x, |
y; }; |
|
2) прототипы функций, например: |
extern int strlen(const char*); |
|
3)определения inline-функций, например: inline char get() { return *p++;}:
4)описания внешних переменных, например: extern int a;
5) |
определения констант, например: |
const float |
pi = 3.141593; |
6) |
перечисления, например: |
enum bool { |
false, true }; |
7) |
директивы include, например: |
#include |
|
|
15 |
|
8) |
определения макросов, например: |
#define Case break;case |
9) |
комментарии, например: |
/* проверка на конец файла */ |
Запрещается использование |
|
|
1) |
Определения обычных функций, например: |
char get() { return *p++; } |
2) |
Определения переменных, например: |
int a; |
3) Определения сложных констант, например: const tbl[] = { /* ... */ } Заголовочные файлы имеют расширение h.
Для того, чтобы при использовании заголовочных файлов исключить их двойное подключение к вызывающей программе используется следующая структура определения заголовочных файлов:
#ifendef кодовое_слово #define кодовое_слово
текст_заголовочного файла
#endif--------- конец h-файла
Первая строка содержит директиву ifendef, которая проверяет не было ли ранее определено указанное кодовое слово. Если нет, тогда производится определение этого ключевого слова с помощью директивы define, которое может быть любым (рекомендуется, чтобы оно отражало наименование h-файла). В конце файла закрывается блок проверки директивой endif.
|
Пример |
заголовочного файла со структурой, описывающей комплексное число в |
алгебраической форме с полями: Re – действительной части и Im – мнимой. Имя файла |
||
– re_im.h. |
|
|
#ifndef reim_h |
||
#define reim_h |
||
struct compl |
// Описание структуры комплексного числа |
|
{ double Re; |
// действительная часть |
|
|
double Im; |
// мнимая часть |
}; |
// конец структуры |
|
#endif |
|
|
Пример программы сложения двух комплексных чисел в алгебраической форме, использующей ресурсы описанного заголовочного файла. В программе содержатся три функции для ввода, вывода и сложения комплексных чисел.
#include <iostream.h> |
// подключения потоков для работы с консолью |
|
#include "re_im.h" |
// подключения типа комплексного числа |
|
compl cadd(compl X, compl Y); |
// функция сложения двух комплексных чисел |
|
void incomplex(char *st, compl *x); |
// функция ввода комплексного числа |
|
void outcomplex(char *s, compl y); |
// функция вывода комплексного числа на экран |
|
int main() // головная программа -------------------------------------------- |
|
|
{ compl A, B, C; |
// три локальных комплексных числа |
|
incomplex("A",&A); |
// ввод числа А с клавиатуры |
|
incomplex("B",&B); |
// ввод числа B с клавиатуры |
|
C=cadd(A,B); |
// сложение комплексных чисел в п6еременной С |
|
outcomplex("C",C); |
// вывод результата на экран |
|
return 0; |
// код успешного завершения программа |
|
}//------------------------------- |
конец main |
|
compl cadd(compl X, compl Y) |
// Описание функции сложения комплесных чисел |
|
{ compl Z; |
// локальная переменная |
|
Z.Re=X.Re+Y.Re; |
// Сумма действительных частей |
|
Z.Im=X.Im+Y.Im; |
// сумма мнимых частей |
|
return Z; |
// возврат результата |
|
}//------------------------------------------ |
|
|
void incomplex(char *st,compl *x) |
// Описание функции ввода комплексного числа |
|
{ cout << *st << ".re="; |
// вывод комментария и запроса |
|
cin >> x->Re; |
// ввод действительной части |
|
cout << *st << ".im=" ; |
// вывод комментария и запроса |
|
cin >> x->Im; |
// ввод мнимой части |
|
}//------------------------------------------------ |
|
|
void outcomplex(char *s, compl y) |
// вывод комплексного числа на экран |
|
{ cout << "\n" << *s << ".re=" << y.Re << " |
" << *s << ".im" << y.Im; |
|
} // ---------------------------------------------- |
|
|
16
7.11 Статические модули
Статические модули в языке С представляют собой откомпилированный набор программных ресурсов: типов данных, подпрограмм, переменных.
Статический модуль в языках С и С++ образуется из двух файлов:
1)заголовочного h-файла, который является интерфейсом модуля,
2)одноименного cpp-файла реализации, который при компиляции преобразуется в
объектный obj-файл, где задается реализация функций и объявляются переменные и структурированные константы, используемые для собственных нужд модуля. Структура заголовочного файла расписана выше, а состав файла реализации сле-
дующий:
1)директива #include “заголовочный файл модуля”, подключает h-файл;
2)список include-подключения внешних ресурсов других модулей;
3)объявление собственных глобальных переменных и констант, которые могут использоваться как для обмена между функциями модуля, так и для обмена данными между модулями;
4)описание внешних (extern) переменных, объявленных в других модулях проекта, которые не подключены с помощью include;
5)собственные внутренние функции модуля, используемые только внутри модуля;
6)описание функций, прототипы которых объявлены в h-файле модуля; Статические откомпилированные модули в последствии могут использоваться без
исходного текста cpp-файлов, что позволяет защитить авторские права на программную реализацию подпрограмм.
Возможно компоновка статического модуля в виде библиотечного файла, который имеет одинаковое имя с модулем, но расширение обозначается как lib.
Библиотечные подпрограммы C++ объявляются со своими прототипами в одном или более файлов заголовка.
Пример модуля со структурой комплексного числа в алгебраической форме и тре-
мя функциями: ввода, вывода и сложения |
комплексных чисел в алгебраической форме. |
|||
Заголовочный файл re_im.h модуля |
|
|||
#ifndef reim_h |
// ------------------ |
|
проверка наличия ключа модуля |
|
#define reim_h |
// ------------------ |
|
определение блокирующего ключа |
|
struct compl |
|
// структура мнимого |
типа данных в алгебраической форме |
|
{ double Re; |
|
// действительная часть числа |
||
double Im; |
|
// мнимая часть числа |
||
}// ---------------- |
|
конец описания |
структуры |
|
compl cadd(compl X, compl Y); |
// |
функция сложения двух комплексных чисел |
||
void incomplex(char *st, compl *x); |
// |
функция ввода комплексного числа |
||
void outcomplex(char *s, compl y); |
// |
функция вывода комплексного числа на экран |
||
#endif |
//---------------- |
конец h-файла модуля --------------------------- |
||
Файл реализации модуля re_im.cpp |
|
|||
#include “re_im.h” |
|
// |
подключение заголовочного файла модуля |
|
#include <iostrea.h> |
// |
подключение требуемых ресурсов ввода-вывода |
||
compl cadd(compl X, compl Y) |
// |
Описание функции сложения комплексных чисел |
||
{ compl Z; |
|
|
// |
локальная переменная |
Z.Re=X.Re+Y.Re; |
|
// |
Сумма действительных частей |
|
Z.Im=X.Im+Y.Im; |
|
// |
сумма мнимых частей |
|
return Z; |
|
|
// |
возврат результата |
}//------------------------------------------------------------- |
|
|
|
|
void incomplex(char *st,compl *x) |
// |
Описание функции ввода комплексного числа |
||
{ cout << *st << ".re="; |
// |
вывод комментария и запроса |
||
cin >> x->Re; |
|
// |
ввод действительной части |
|
cout << *st << ".im=" ; |
// |
вывод комментария и запроса |
||
cin >> x->Im; |
|
// |
ввод мнимой части |
|
} // ------------------------------ |
|
|
|
|
void outcomplex(char *s, compl y) |
// |
вывод комплексного числа на экран |
||
{cout << "\n" << *s << ".re=" << y.Re << " " << *s << ".im" << y.Im;
} // ----------------- |
конец текса файла реализации ---------------------- |
|
Пример программы, использующей ресурсы модуля |
||
#include "re_im.h" |
// |
подключения типа комплексного числа |
int main() |
// |
головная программа |
|
17 |
{ compl A, B, C; |
// три локальных комплексных числа |
incomplex("A",&A); |
// ввод числа А с клавиатуры |
incomplex("B",&B); |
// ввод числа B с клавиатуры |
C=cadd(A,B); |
// сложение комплексных чисел в переменной С |
outcomplex("C",C); |
// вывод результата на экран |
return 0; |
// код успешного завершения программа |
}// конец программы |
------------------------------------------------------- |
7.12 Назначение и состав стандартных модулей языков C и C++
Языки С и C++ предоставляют огромное количество стандартных функций, которые в совокупности составляют стандартную библиотеку, поставляемую в комплекте с конкретной версией среды программирования языка. Классическая библиотека модулей языка C++ состоит из большого количества отдельных тематических библиотек. Под стандартной библиотекой, часто понимаю стандартную библиотеку шаблонов (Standart Template Library, STL), но STL фактически является только большой частью стандартной библиотеки. В языке C++ входят следующие составляющие библиотек модулей:
1)стандартные библиотеки языка С;
2)стандартные библиотеки C++, составляющие STL;
3)дополнительные библиотеки интегрированной среды программирования, которые обычно представлены в виде заголовочных файлов. Для языка С версии ANSI их состав указан в таблице 7.1, а для С++ - в таблице 7.2.
4)объектно-ориентированные библиотеки интегрированной среды (MFC, ATL, WTL,
OWL, VCL и многие другие), которые используются при программировании приложений для операционных систем Windows или Linux;
5)интерфейс прикладного программирования (или интерфейс программирования приложений) — набор готовых классов, функций, структур и констант, предоставляемых приложением (библиотекой, сервисом) для использования во внешних программных продуктах; сокращенно API от англ. Application Programming Interface, предоставляемых операционной системой (например, Windows API или Linux Kernel API);
6)нестандартные библиотеки, например, API графических интерфейсов (OpenGL, GTK, GDI, Direct3D и другие).
Таблица 7.1 - Описание заголовочных файлов языка ANSI С
h-файл |
Описание |
assert |
Содержит макрос утверждений, используемый для обнаружения логических |
|
и некоторых других типов ошибок в отлаживаемой версии программы. |
complex |
Набор функций для работы с комплексными числами. (Появилось в C99) |
ctype |
Содержит функции, используемые для классификации символов по их типам |
|
или для конвертации между верхним и нижним регистрами независимо от |
|
используемой кодировки. |
errno |
Для проверки кодов ошибок, возвращаемых библиотечными функциями. |
fenv |
Для управления средой, использующей числа с плавающей запятой. |
float |
Содержит заранее определенные константы, описывающие специфику реали- |
|
зации свойств библиотеки для работы с числами с плавающей запятой, |
|
как, например, минимальная разница между двумя различными числами с |
|
плавающей точкой (_EPSILON), максимальное число цифр точности (_DIG) |
|
и область допустимых чисел (_MIN, _MAX). |
inttypes |
Для точной конвертации целых типов. (Появилось в C99) |
iso646 |
Для программирования в кодировке ISO 646. (Появилось в NA1) |
limits |
Содержит заранее заданные константы, определяющие специфику реализа- |
|
ции свойств целых типов, как, например, область допустимых значений |
locale |
Для setlocale() и связанных констант. Используется для выбора соот- |
|
ветствующего языка. |
math |
Для вычисления основных математических функций |
setjmp |
Объявляет макросы setjmp и longjmp, используемые для переходов |
signal |
Для управления различными исключительными условиями |
stdarg |
Для доступа к различному числу аргументов, переданных функциям. |
stdbool |
Для булевых типов данных. (Появилось в C99) |
stdint |
Для определения различных типов целых чисел. (Появилось в C99) |
|
|
|
|
|
18 |
|
|
|
|
|
|
|
|
h-файл |
|
|
|
|
Описание |
|
stddef |
|
Для определения нескольких полезных типов и макросов. |
|
|||
stdio |
|
Реализует основные возможности ввода и вывода в языке С |
||||
stdlib |
|
Для выполнения множества операций, включая конвертацию, генерацию |
||||
|
|
псевдослучайных чисел, выделение памяти, контроль процессов, окруже- |
||||
|
|
ния, сигналов, поиска и сортировки. |
|
|||
string |
|
Для работы с различными видами строк. |
|
|||
tgmath |
|
Для типовых математических функций. (Появилось в C99) |
|
|||
time |
|
Для конвертации между различными форматами времени и |
даты. |
|||
wchar |
|
Для |
обработки «широких» потоков и нескольких видов |
строк при помощи |
||
|
|
«широких» символов (поддержка набора языков). |
|
|||
wctype |
|
Для классификации «широких» символов. (Появилось в NA1) |
||||
Таблица |
7.2 – Стандартные заголовочные файлы языка C++ |
|
||||
|
|
|
|
|
|
|
Файл |
|
|
|
Назначение |
|
|
<bitset> |
|
|
Реализует |
специализированный класс контейнеров std::bitset — бито- |
||
|
|
|
|
вый массив. |
|
|
<deque> |
|
|
Реализует |
шаблон класса контейнера std::deque — очередь с двусто- |
||
|
|
|
|
ронним доступом. |
|
|
<list> |
|
|
Реализует |
шаблон класса контейнера std::list — двусвязный список. |
||
<map> |
|
|
Реализует |
шаблоны классов контейнеров std::map и std::multimap — |
||
|
|
|
|
Ассоциативный массив и мультиотображение. |
|
|
<queue> |
|
|
Реализует |
класс адаптер-контейнера std::queue — односторонняя оче- |
||
|
|
|
|
редь. |
|
|
<set> |
|
|
Реализует |
шаблоны классов контейнеров std::set и std::multiset — |
||
|
|
|
|
сортированные ассоциативные контейнеры или множества. |
||
<stack> |
|
|
Реализует |
класс адаптер-контейнера std::stack — стек. |
||
<vector> |
|
|
Реализует |
шаблон класса контейнеров std::vector — динамический |
||
|
|
|
|
массив. |
|
|
<algorithm> |
|
Реализует |
определения многих алгоритмов для работы с контейнерами. |
|||
<functional> |
|
Реализует |
несколько объект-функций, разработанных для работы со |
|||
|
|
|
|
стандартными алгоритмами. |
|
|
<iterator> |
|
|
Реализует классы и шаблоны для работы с итераторами. |
|||
<locale> |
|
|
Реализует |
классы и шаблоны для работы с локалями. |
|
|
<memory> |
|
|
Реализует |
инструменты управления памятью в C++, включая шаблон |
||
|
|
|
|
класса std::auto_ptr. |
|
|
<stdexcept> |
|
Содержит стандартную обработку ошибок классов, например, |
||||
|
|
|
|
std::logic_error и std::runtime_error, причем оба происходит из |
||
|
|
|
|
std::exception. |
|
|
<utility> |
|
|
реализует |
шаблон класса std::pair для работы с парами (двучленными |
||
|
|
|
|
кортежами) объектов. |
|
|
<string> |
|
|
Реализует стандартные строковые классы и шаблоны. |
|||
<fstream> |
|
|
Реализует |
инструменты для файлового ввода и вывода. |
||
<ios> |
|
|
Реализует несколько типов и функций, составляющих основу операций |
|||
|
|
|
|
с iostreams. |
|
|
<iostream> |
|
|
Реализует основы ввода и вывода языка C++. |
|
||
<iosfwd> |
|
|
Реализует предварительные объявления нескольких шаблонов классов, |
|||
|
|
|
|
связанных |
с вводом-выводом. |
|
<iomanip> |
|
|
Реализует |
инструменты для работы с форматированием вывода, напри- |
||
|
|
|
|
мер базу, |
используемую при форматировании целых и точных значений |
|
|
|
|
|
чисел с плавающей запятой. |
|
|
<istream> |
|
|
Реализует |
шаблон класса std::istream и других необходимых классов |
||
|
|
|
|
для ввода. |
|
|
<ostream> |
|
|
Реализует |
шаблон класса std::ostream и других необходимых классов |
||
|
|
|
|
для вывода. |
|
|
<sstream> |
|
|
Реализует |
шаблон класса std::sstream и других необходимых классов |
||
|
|
|
|
для работы со строками. |
|
|
<complex> |
|
|
Реализует шаблон класса std::complex и связанные функции для ра- |
|||
|
|
|
|
боты с комплексными числами. |
|
|
|
|
19 |
|
|
|
Файл |
|
Назначение |
<numeric> |
Реализует |
алгоритмы для числовой обработки |
<valarray> |
Реализует |
шаблон класса std::valarray — класс массивов, оптимизи- |
|
рованный для числовой обработки. |
|
<exception> |
Реализует |
несколько типов и функций, связанных с обработкой исклю- |
|
чений, включая std::exception — базовый класс всех перехватов ис- |
|
|
ключений в Стандартной Библиотеке. |
|
<limits> |
реализует шаблон класса std::numeric_limits, используемый для |
|
|
описания свойств базовых числовых типов. |
|
<new> |
Реализует операторы new и delete, а также другие функции и типы, |
|
|
составляющие основу управления памятью в C++. |
|
<typeinfo> |
Реализует |
инструменты для работы с динамической идентификацией ти- |
|
па данных |
в C++. |
7.12.1 Состав стандартных функций модуля math
Модуль стандартной библиотеки math.h разработан для выполнения простых математических операций. Функции модуля используют числа с плавающей точкой (как правило, типа double). В языке C++ данные функции для обеспечения совместимости сформированы в заголовочный файл cmath.
Всостав модуля входят:
1)базовые функции (таблица 7.2);
2)дополнительные функции стандарта C99, приведенные в таблице 7.3;
3)функции расширения XSI, которые не описаны в стандартах ANSI или ISO C, но могут присутствовать в системах в качестве расширений X/Open (таблица 7.4).
Все функции, принимающие или возвращающие угловые значения, используют в качестве единиц радианы.
Таблица 7.3 - Базовые функции модуля math
Имя |
|
Описание |
acos |
арккосинус |
|
asin |
арксинус |
|
atan |
арктангенс |
|
atan2 |
арктангенс с двумя параметрами |
|
ceil |
округление до ближайшего большего целого числа |
|
cos |
косинус |
|
cosh |
гиперболический косинус |
|
exp |
вычисление экспоненты |
|
fabs |
абсолютная величина (числа с плавающей точкой) |
|
floor |
округление до ближайшего меньшего целого числа |
|
fmod |
вычисление остатка от деления нацело для чисел с плавающей точкой |
|
frexp |
разбивает число с плавающей точкой на мантиссу и показатель степени. |
|
ldexp |
умножение числа с плавающей точкой на целую степень двух |
|
log |
натуральный логарифм |
|
log10 |
логарифм по основанию 10 |
|
modf(x,p) |
извлекает целую и дробную части (с учетом знака) из числа с плаваю- |
|
|
щей точкой |
|
pow(x,y) |
результат возведения x в степень y, xy |
|
sin |
синус |
|
sinh |
гиперболический синус |
|
sqrt |
квадратный корень |
|
tan |
тангенс |
|
tanh |
гиперболический тангенс |
|
Таблица 7.4 - Дополнительные функции стандарта C99 |
||
|
|
|
Имя |
|
Описание |
|
|
|
acosh |
|
гиперболический арккосинус |
asinh |
|
гиперболический арксинус |
atanh |
|
гиперболический арктангенс |
cbrt |
|
кубический корень |
|
20 |
|
|
|
|
copysign(x,y |
возвращает величину, абсолютное значение которой равно x, но знак |
|
) |
которой соответствует знаку y |
|
erf |
функция ошибок |
|
erfc |
Дополнительная функция ошибок |
|
exp2(x) |
значение числа 2, возведённого в степень x, 2x |
|
expm1(x) |
значение функции ex − 1 |
|
fdim(x,y) |
вычисление положительной разницы между x и y, fmax(x−y, 0) |
|
fma(x,y,z) |
значение функции (x * y) + z (см. FMA) |
|
fmax(x,y) |
наибольшее значение среди x и y |
|
fmin(x,y) |
наименьшее значение среди x и y |
|
hypot(x,y) |
гипотенуза, sqrt(x² + y²) |
|
ilogb |
экспонента числа с плавающей точкой, конвертированная в int |
|
lgamma |
натуральный логарифм абсолютного значения гамма-функции |
|
llrint |
округление до ближайшего целого (возвращает long long) |
|
lrint |
округление до ближайшего целого (возвращает long) |
|
llround |
округление до ближайшего целого в направлении от нуля (возвращает |
|
|
long long) |
|
lround |
округление до ближайшего целого в направлении от нуля (возвращает |
|
|
long) |
|
log1p(x) |
натуральный логарифм 1 + x |
|
log2 |
логарифм по основанию 2 |
|
logb |
целочисленная часть логарифма x по основанию 2 |
|
nan(s) |
возвращает нечисловое значение 'Not a Number' |
|
nearbyint |
округление аргумента до целого значения в формате числа с плаваю- |
|
|
щей точкой |
|
nextafter(x, |
следующий ближайшее представимое для x (по направлению к y) |
|
y) |
|
|
nexttoward(x |
то же, что и nextafter, но y имеет тип long double |
|
,y) |
|
|
remain- |
вычисляет остаток от деления согласно стандарту IEC 60559 |
|
der(x,y) |
|
|
remquo(x,y,p |
то же, что и remainder, но сохраняет коэффициент по указателю p |
|
) |
(как int) |
|
rint |
округление до целого (возвращает int) с вызовом ошибку inexact, |
|
|
если результат отличается от аргумента. |
|
round |
округление до целого (возвращает int) |
|
scalbln(x,n) |
x * FLT_RADIXn (n is long) |
|
scalbn(x,n) |
x * FLT_RADIXn (n is int) |
|
tgamma |
гамма-функция |
|
trunc |
округление до ближайшего целого числа в направлении к нулю |
|
Таблица |
7.5 - Функции расширения XSI |
|
|
|
|
Имя |
|
Описание |
j0(x) |
|
значение функций Бесселя первого рода порядков 0 для аргумента x |
j1(x) |
|
значение функций Бесселя первого рода порядков 1 для аргумента x |
jn(n,x) |
|
значение функций Бесселя первого рода порядка n |
y0(x) |
|
значение функций Бесселя второго рода порядков 0 для аргумента x |
y1(x) |
|
значение функций Бесселя второго рода порядков 1 для аргумента x |
yn(n,x) |
|
значение функций Бесселя второго рода порядка n |
7.12.2 Стандартные функции модуля complex
Модуль complex.h из стандартной библиотеки языка программирования С содержит функции для комплексной арифметики, использующие встроенный тип complex, который появился в стандарте C99. Функции complex.h используют параметры трёх типов — double, float и long double, угловые значения представляются в радианах.
Таблица 7.6 - Функции модуля complex для работы с комплексными числами
Функции |
Описание |
cabs, cabsf, cabsl |
Абсолютное значение комплексного числа |