Функции. Funktsioonid. Lektor Inna Dokutšajeva

Содержание Sisukord: Введение Параметры и аргументы функций –Объявление функцииОбъявление функции –Определение функцииОпределение функции –Вызов функцииВызов функции Аргументы функции main() Примеры объявления, вызова и определения функций Пример вычисления квадрата числа с использованием функции Аргументы по умолчанию Области видимости. Локальные и глобальные переменные Операция : Классы памяти и модификаторы переменных Автоматические переменные Регистровые переменные Внешние переменные и функции Статические переменные Пример реализации счетчика вызовов функции Переменные класса volatile Новый стиль заголовков Пространства имен Встраиваемые (inline- функции) Рекурсивные функции Математические функции Тригонометрические функции Функции округления

Содержание Sisukord Разработка программного обеспечения на практике является довольно непростым процессом. Программисту требуется учесть все тонкости и нюансы как всего программного комплекса в целом, так и отдельных его частей. Системный подход к программированию основывается на том, что поставленная перед разработчиком задача предварительно разбивается на несколько менее крупных вопросов, которые, в свою очередь, делятся еще на несколько менее сложных задач, и так до тех пор, пока самые мелкие задачи не будут решены с помощью стандартных процедур. Ключевым элементом данной модели для решения конкретной задачи в С++ выступает функция. Функцию можно представить как подпрограмму или некую процедуру, несущую законченную смысловую нагрузку. Введение

Каждая функция, которую предполагается использовать в программе, должна быть в ней объявлена. Обычно объявления функций размещают в заголовочных файлах, которые затем подключаются к исходному тексту программы с помощью директивы #include. Объявление функции описывает ее прототип. ( ); Параметры и аргументы функций: oбъявление функции. возвращаемый функцией тип данных тип и имя каждого параметра функции, разделенные запятыми.

тип - возвращаемый функцией тип данных. Если возвращаемый тип данных не указан, то по умолчанию компилятор считает, что возвращаемый функцией тип есть int. cписок параметров - задает тип и имя каждого параметра функции, разделенные запятыми. Допускается опускать имя параметра. Список объявляемых параметров функции может быть пустым. Примеры прототипов функций: intswap ( int, int ) ; double max (double par1, double par2); void func();

Содержание Sisukord Прототип функции может быть пропущен, если определение функции следует до первого ее вызова из любой другой функции. NB!!! Последний вариант считается плохим стилем программирования, так как бывают случаи перекрестных вызовов, то есть когда две или несколько функций вызывают друг друга, в результате чего невозможно вызвать одну функцию без предварительного определения другой.

Содержание Sisukord Определение функции состоит из ее заголовка и собственно тела, заключенного в фигурные скобки и несущего смысловую нагрузку. ( ) { ……тело функции………. [return ;] } Если функция возвращает значение, отличное от типа void, в теле функции обязательно должен присутствовать оператор return с параметром того же типа, что и возвращаемое значение.

Вызов функции представляет собой указание идентификатора функции (ее имени), за которым в круглых скобках следует список аргументов, разделенных запятыми: имя_функции ( аргумент1, аргумент2, , аргументN) ; Каждый аргумент функции представляет собой переменную, выражение или константу, передаваемые в тело функции для дальнейшего использования в вычислительном процессе. Список аргументов функции может быть пустым. Для того чтобы функция выполнила определенные действия, она должна быть вызвана в программе. При обращении к функции она выполняет поставленную задачу, а по окончании работы возвращает в качестве результата некоторое значение.

Функция может вызывать другие функции (одну или несколько), а те, в свою очередь, производить вызов третьих и т.д. Кроме того, функция может вызывать сама себя. Это явление в программировании называется рекурсией. Как уже было отмечено ранее, любая программа на С++ обязательно включает в себя главную функцию main (). Именно с этой функции начинается выполнение программы. void main() { //Вызов первой //функции: Func1(x,y); ……………………… //Вызов второй //функции: Func2(a,b,c); ……………………… } int Func1(int Radius, char Symbol) { …………………………… return ….; } bool Func2(bool YesNo, int Count, short Key) { …………………………… return ….; }

Программа начинает выполняться с функции main() до вызова функции Func1 (х, у). void main() { //Вызов первой функции: Func1(x,y); С этого момента управление программой передается в функцию Func1 (х, у), причем в качестве значения переменной Radius данная функция использует величину переменной х, а в качестве переменной Symbol передается значение у. Func1( x, y); int Func1(int Radius, char Symbol) { return ….; }

Далее до оператора return выполняется тело функции Func1 (х, у), после чего управление возвращается в тело функции main(), а именно, следующему за вызовом Func1 (х, у) оператору. После этого продолжается выполнение функции main() до вызова функции Func2 (a,b,с) void main() { //Вызов первой функции: Func1(x,y); ……………………… int Func1(int Radius, char Symbol) { …………………………… return.....; } ……………………… //Вызов второй функции: Func2(a,b,c); ………………………

Содержание Sisukord При вызове второй функции переменная а передает значение логической переменной YesNo, переменная b - целочисленной переменной Count, а переменная с - короткому целому Key. Func2(a,b,с); bool Func2(bool YesNo, int Count, short Key) { …………………………… return ….; }

Содержание Sisukord Функция main () часто не имеет аргументов, однако, если требуется при вызове программы передать ей какие-нибудь параметры, синтаксис функции main () меняется: int main(arge, argv) указывает количество передаваемых параметров указатель на массив символьных строк, содержащих эти аргументы

Примеры объявления, вызова и определения функций // Объявления функций: int MyFunction (int Number, float Point); //2 аргумента char InputSymbol (); //аргументы отсутствуют void SetBit (short Num); //1 аргумент void EmptySample (int, char); //2 аргумента

Содержание Sisukord // Определения функций: int MyFunction(int Number, float Point) { int myX; return myX; // возвращает значение целого типа }; //************************************************* char InputSymbol() { char symbol; cin >> symbol; return symbol; }; //************************************************* void SetBit(short number) { GlobalBit = GlobalBit | number; }; //************************************************* void EmptySample(int x, char ch) { };

Пример вычисления квадрата числа с использованием функции: В заголовочном файле header. h разместим прототип функции MySquare(): // header.h long MySquare(int); Тогда главный модуль программы будет подключать заголовочный файл, содержать описание и вызов функции MySquare () из функции main (). #include "header.h" int main() { int Variable = 5; //целочисленная переменная, равная 5 cout

Содержание Sisukord Тот же пример может выглядеть несколько иначе, если вместо подключения заголовочного файла поместить прототип функции MySquare () прямо в файл исходного текста программы: // Прототип функции: long MySquare (int); int main() { int Variable = 5; cout

С++ допускает при вызове функций опускать некоторые ее параметры. Достигается это указанием в прототипе функции значений аргументов по умолчанию. Например, функция, прототип которой приведен ниже, может при вызове иметь различный вид в зависимости от ситуации. // Прототип функции: void Showint ( int i, bool Flag = true, char symbol = '\n'); // Вызовы функции Showint: Showint (1, false, 'a'); //все три аргумента заданы явно Showint (2, false); // в функцию передается два параметра из трех, //причем вместо последнего аргумента подставляется значение по //умолчанию, а именно символ \n. Showint (3); //функции сообщается только один целочисленный параметр, а в качестве остальных аргументов используются значения по умолчанию: логическая переменная со значением true и символьная переменная со значением '\n'. Аргументы по умолчанию

Для используемых параметров по умолчанию существует обязательное правило: все параметры справа от аргумента по умолчанию должны также иметь значение по умолчанию. void Showint ( int i, bool Flag = true, char symbol = '\n'); В приведенном выше прототипе нельзя было бы, указав значение параметра по умолчанию для целочисленной переменной i, пропустить определение любого из остальных аргументов по умолчанию.

Пример: вывод знакового числа двойной точности с указанием количества значащих символов. Определим функцию, принимающую в качестве одного из параметров число выводимых знаков. void Out (double Numb, double Sig =1, bool Flg =true); Для решения поставленной задачи можно воспользоваться функцией возведения числа в степень pow () и функцией взятия модуля от длинного числа с плавающей точкой fabsl (), прототипы которых содержатся в заголовочном файле math. H #include int main() {double pi = ; Out(pi, 4, false); // вызов одной и той же функции Out(pi, 2); //Out () с различным числом Out(pi); //параметров для вывода значения //переменной двойной точности pi. return 0;}

void Out (double numb, double sig, bool flg) { if ( !flg ) numb = fabsl (numb); //абсолютное значение numb = (int)(numb * pow(10, sig)); numb = numb / pow(10,sig); cout

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

Области видимости. Локальные и глобальные переменные. Переменные могут быть объявлены как внутри тела какой-либо функции, так и за пределами любой из них. Переменные, объявленные внутри тела функции, называются локальными. Такие переменные размещаются в стеке программы и действуют только внутри той функции, в которой объявлены. Как только управление возвращается вызывающей функции, память, отводимая под локальные переменные, освобождается. Каждая переменная характеризуется областью действия, областью видимости и временем жизни. Под областью действия переменной понимают область программы, в которой переменная доступна для использования.

Область действия переменной связано с понятием области видимости переменной. Если переменная выходит из области действия, она становится невидимой. С другой стороны, переменная может находиться в области действия, но быть невидимой. Переменная находится в области видимости, если к ней можно получить доступ (с помощью операции разрешения видимости, в том случае, если она непосредственно не видима). Временем жизни переменной называется интервал выполнения программы, в течение которого она существует. Локальные переменные имеют своей областью видимости функцию или блок, в которых они объявлены. В то же время область действия локальной переменной может исключать внутренний блок, если в нем объявлена переменная с тем же именем. Время жизни локальной переменной определяется временем выполнения блока или функции, в которой она объявлена. Это означает, например, что в разных функциях могут использоваться переменные с одинаковыми именами совершенно независимо друг от друга.

В рассматриваемом ниже примере переменные с именем х определены сразу в двух функциях - в main() и в Sum(), что, однако, не мешает компилятору различать их между собой: #include // Прототип функции: int Sum(int a, int b); int main() { // Локальные переменные: int х = 2; int у = 4; cout

В программе осуществляется вычисление суммы двул малочисленных переменных посредством вызова функции Sum(). Глобальные переменные, как указывалось ранее, объявляются вне тела какой-либо из функций и действуют на протяжении выполнения всей программы. Такие переменные доступны в любой из функций программы, которая описана после объявления глобальной переменной. Отсюда следует вывод, что имена локальных и глобальных переменных не должны совпадать. Если глобальная переменная не проинициализирована явным образом, она инициализируется значением 0. Область действия глобальной переменной совпадает с областью видимости и простирается от точки ее описания до конца файла, в котором она объявлена. Время жизни глобальной переменной - постоянное, то есть совпадает с временем выполнения программы. Вообще говоря, на практике программисты стараются избегать использования глобальных переменных и применяют их только в случае крайней необходимости, так как содержимое таких переменных может быть изменено внутри тела любой функции, что чревато серьезными ошибками при работе программы.

Пример: #include // Объявляем глобальную переменную Test: int Test = 200; // объявляется глобальная переменная Test, которой присваивается //значение 200 void PrintTest(void); //************************************************* int main() { // Объявляем локальную переменную Test: int Test =10; // объявляется локальная переменная с тем же именем Test, но со значением 10. // Вызов функции печати глобальной переменной: PrintTest(); // Вызов функции PrintTest () из main() фактически осуществляет временный //выход из тела главной функции. При этом все локальные переменные //становятся недоступны и PrintTest () выводит на печать глобальную //переменную Test. cout

Содержание Sisukord В С++ допускается объявлять локальную переменную не только в начале функции, а вообще в любом месте программы. Если объявление происходит внутри какого-либо блока, переменная с таким же именем, объявленная вне тела блока, "прячется". Видоизменим предыдущий пример с тем, чтобы продемонстрировать процесс сокрытия локальной переменной: #include // Объявляем глобальную переменную Test: int Test = 200; void PrintTest(void); int main() { // Объявляем локальную переменную Test: int Test =10; // Вызов функции печати глобальной переменной: PrintTest(); cout

Содержание Sisukord Объявление локальной переменной скрывает глобальную переменную с таким же именем. Таким образом, все обращения к имени глобальной переменной в пределах области действия локального объявления вызывают обращение к локальной переменной. Однако С++ позволяет обращаться к глобальной переменной из любого места программы с помощью использования операции разрешения области видимости. Для этого перед именем переменной ставится префикс в виде двойного двоеточия (: :) #include // Объявление глобальной переменной int Turn = 5; int main() { // Объявление локальной переменной int Turn =70; // Вывод локального значения: cout

Содержание Sisukord Важным свойством переменной является её время жизни. Существует четыре модификатора переменных, определяющих область видимости и время действия переменных. Классы памяти и модификаторы переменных. МодификаторПрименениеОбласть действия Время жизни autoлокальноеБлоквременное registerлокальноеБлоквременное extern глобальноеБлоквременное statiс локальноеБлок постоянное глобальноеФайл volatileглобальноеФайлпостоянное

Содержание Sisukord Модификатор auto используется при описании локальных переменных. Поскольку для локальных переменных данный модификатор используется по умолчанию, на практике его чаще всего опускают. #include int main() { auto int MyVar =2; // то же что int MyVar =2; cout

Содержание Sisukord Модификатор register предписывает компилятору попытаться разместить указанную переменную в регистрах процессора (если такая попытка оканчивается неудачно, переменная ведет себя как локальная переменная типа auto). Размещение переменных в регистрах, оптимизирует программный код по скорости, так как процессор оперирует с переменными, находящимися в регистрах, гораздо быстрее, чем с памятью. Но в связи с тем, что число регистров процессора ограничено, количество таких переменных может быть очень небольшим. #include int main() { register int REG; return 0; } Модификатор register применяют только к локальным переменным. Попытка употребления данного модификатора (так же как и модификатора auto) к глобальным переменным вызовет сообщение об ошибке. Переменная существует только в пределах блока, содержащего ее объявление. Регистровые переменные

Содержание Sisukord Если программа состоит из нескольких модулей, некоторые переменные могут использоваться для передачи значений из одного файла в другой. При этом некоторая переменная объявляется глобальной в одном модуле, а в других файлах, в которых она должна быть видима, производится ее объявление с использованием модификатора extern. Если объявление внешней переменной производится в блоке, она является локальной. Этот модификатор сообщает, что первоначальное объявление переменной производится в каком-то другом файле. // файл myheader.h void ChangeFlag(void); //объявляется функция ChangeFlag() // файл myfunction.cpp extern bool Flag; //объявление глобальной логической переменной Flag //********************************************************** void ChangeFlag(void) //определяется реализация тела функции ChangeFlag() { Flag = !Flag; } //*********************************************************** #include #include "myheader.h" //подключается заголовочный файл myheader.h extern bool Flag; // переменная Flag описывается как внешняя (extern) int main() {ChangeFlag(); if(Flag) cout

Содержание Sisukord Статические переменные Статические переменные во многом похожи на глобальные переменные. Для описания статических переменных используется модификатор static. Если такая переменная объявлена глобально, то она инициализируется при запуске программы, а ее область видимости совпадает с областью действия и простирается от точки объявления до конца файла. Если же статическая переменная объявлена внутри функции или блока, то она инициализируется при первом входе в соответствующую функцию или блок. Значение переменной сохраняется от одного вызова функции до другого. Таким образом, статические переменные можно использовать для хранения значений переменных на протяжении времени работы программы. Статические переменные не могут быть объявлены в других файлах как внешние. Если статическая переменная не проинициализирована явным образом, то, как и глобальная переменная, она инициализируется значением 0.

Содержание Sisukord Пример реализации счетчика вызовов функции: #include int Count(void); int main() {int result; for(int i=0; i

Содержание Sisukord Когда необходимо предусмотреть возможность модификации переменной периферийным устройством или другой программой, используют модификатор volatile. В связи с этим компилятор не пытается оптимизировать программу путем размещения переменной в регистрах. Пример объявления таких переменных: volatile short sTest; volatile const int vciT Переменная vciTest с модификатором volatile в то же время может быть объявлена как константа. В этом случае ее значение не сможет меняться в разрабатываемой программе, но может модифицироваться в зависимости от внешних факторов. Переменные класса volatile

Содержание Sisukord Исторически так сложилось, что в языке С++ при подключении заголовочных файлов использовался тот же синтаксис, что и в языке С для совместимости с разработанным на тот момент программным обеспечением. Однако при стандартизации языка этот стиль был изменен и теперь вместо заголовочных файлов (как это было в С) указываются некоторые стандартные идентификаторы, по которым компилятор сам находит необходимые файлы. Предопределенные идентификаторы представляют собой имя заголовка в угловых скобках без указания расширения (. h). Ниже приводится пример включения заголовков в стиле С++: #include Помимо этого, для включения в программу библиотек функций языка С в соответствии с новым стандартом заголовок преобразуется следующим образом: отбрасывается расширение.h и к имени заголовка добавляется префикс с. Таким образом, например, заголовок заменяется заголовком. Если же используемый компилятор не поддерживает объявления заголовков в новом стиле, можно попрежнему использовать заголовки в стиле языка С, хотя это и не рекомендуется стандартом С++. Новый стиль заголовков

Определения функций и переменных в заголовочных файлах неразрывно связаны с понятием пространства имен. До введения понятия пространства все объявления идентификаторов и констант, сделанные в заголовочном файле, помещались компилятором в глобальное пространство имен. Такое положение вещей приводило к возникновению массы конфликтов, связанных с использованием различными объектами одинаковых имен. Чаще всего недоразумения возникали, когда в одной программе использовались библиотеки, разработанные различными производителями. Введение понятия пространства имен позволило значительно снизить количество подобных конфликтов имен. Когда в программу включается заголовок нового стиля, его содержимое помещается не в глобальное пространство имен, а в пространство имен std. Если в программе требуется определить некоторые идентификаторы, которые могут переопределить уже имеющиеся, просто заведите свое собственное, новое пространство имен. Это достигается путем использования ключевого слова namespace: namespace { // объявления } Объявления внутри нового пространства имен будут находиться только внутри видимости определенного, предотвращая тем самым возникновение конфликтов. Примера пространства имен: namespace NewNameSpace { int х, у, z; void SomeFunction(char smb); } Пространства имен

Для того, чтобы указать компилятору, что следует использовать имена из конкретного именного пространства (в данном случае из NewNameSpace), можно воспользоваться операцией разрешения видимости: NewNameSpace::х = 5 ; Однако, если в программе обращения к собственному пространству имен производятся довольно часто, такой синтаксис вызывает определенные неудобства. В качестве альтернативы можно воспользоваться инструкцией using, синтаксис которой имеет две формы: using namespace ; или using ::идентификатор; При использовании первой формы компилятору сообщается, что в дальнейшем необходимо использовать идентификаторы из указанного именного пространства вплоть до того момента, пока не встретится следующая инструкция using. Например, указав в теле программы using namespace NewNameSpace; можно напрямую работать с соответствующими идентификаторами: х=0; y=z=4; SomeFunction('А'); На практике часто после включения в программу заголовков явно указывается использование идентификаторов стандартного пространства имен: using namespace std;

Вторая форма записи предписывает компилятору использовать указанное пространство имен лишь для конкретного идентификатора. Таким образом, определив using namespace std; using NewNameSpace::z; можно использовать идентификаторы стандартной библиотеки С++ и целочисленную переменную z из пространства имен NewNameSpace без использования операции разрешения видимости: z=12; Следует понимать, что указание нового пространства имен инструкцией using namespace отменяет видимость стандартного пространства std, поэтому для получения доступа к соответствующим идентификаторам из std потребуется каждый раз использовать операцию разрешения видимости std::. Пространства имен не могут быть объявлены внутри тела какой-либо функции, однако могут объявляться внутри других пространств. При этом для доступа к идентификатору внутреннего пространства необходимо указать имена всех вышестоящих именованных пространств. Например, объявлено следующее пространство имен: namespace Highest { namespace Middle { namespace Lowest { int nAttr; } Использование объявленной переменной nAttr будет выглядеть: Highest::Middle::Lowest::nAttr = 0;

Допускается объявление нескольких именованных пространств с одним и тем же именем, что позволяет разделить его на несколько файлов. Несмотря на это, содержимое всех частей будет храниться в одном и том же пространстве имен. Чтобы объявления переменных и функций в некотором пространстве имен были более упорядоченными, рекомендуется в пределах описания пространства имен объявлять только прототипы функций, помещая определение тела функции отдельно. При этом следует явно указывать, к какому пространству имен относится функция: namespace Nspace { char с; int i; void Fund (char Flag); } void Nspace::Fund (char Flag) { // тело функции } Кроме вышесказанного, допускается объявление неименованных пространств имен. В этом случае просто опускается имя пространства после ключевого слова namespace. Например: namespace { char cByte; long lvalue; }

Содержание Sisukord Обращение к объявленным элементам производится по их имени, без какого-либо префикса. Неименованные пространства имен могут быть использованы только в том файле, в котором они объявлены. Стандарт языка С++ предусматривает определение псевдонимов пространства имен, которые ссылаются на конкретное пространство имен. Чаще всего псевдонимы используются для упрощения работы с длинными именами пространств. Следующий пример иллюстрирует создание более короткого псевдонима и его использование для доступа к переменной. namespace A_Very_Long_Name_Of_NameSpace { float у; } A_Very_Long_Name_Of_NameSpace::у = 0.0; namespace Neo = A_Very_Long_Name_Of_NameSpace; Neo::y = 13.4;

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

Содержание Sisukord #include // Прототип встраиваемой функции: inline int Sum(int, int); int main() { int A=2, B=6, C=3; char eol = '\n '; // Вызовы встраиваемой функции генерируют все тело функции cout

Функция может вызывать сама себя. При этом говорят, что возник рекурсивный вызов. Рекурсия бывает: простой - если функция в теле содержит вызов самой себя; косвенной - если функция вызывает другую функцию, а та в свою очередь вызывает первую. При выполнении рекурсии программа сохраняет в стеке значения всех локальных переменных функции и ее аргументов, с тем чтобы в дальнейшем по возвращении из рекурсивного вызова восстановить их сохраненные значения. Рисунок иллюстрирует поведение рекурсивной функции. Рекурсивные функции

Поведение рекурсивной функции Применять рекурсию следует с осторожностью, так как ее использование для функций, содержащих большое количество переменных или слишком большое число рекурсивных вызовов, может вызвать переполнение стека. Следует также помнить, что при использовании рекурсивного вызова разработчик обязан предусмотреть механизм возврата в вызывающую процедуру, чтобы не произошло образования бесконечного цикла.

Некоторые задачи на практике могут быть проще и нагляднее решены именно с использованием рекурсивных функций. Например, решение тривиальной задачи нахождения факториала без обращения к рекурсии могло бы выглядеть следующим образом: #include int main() { int count = 1; long int result =1; while (count && count count; for (int i=count; i>1; i--) { result *= i; } cout

Содержание Sisukord Ту же задачу можно решить более элегантно, применив рекурсию: #include long int fact(long); int main() { int count = 1; while (count && count count; cout

Прототипы стандартных математических функций определены в заголовочном файле math.h. Функция pow () позволяет возводить число в степень. Синтаксис данной функции выглядит следующим образом: double pow (double х, double у); Таким образом, компилятору сообщается, что необходимо число двойной точности х возвести в степень числа двойной точности у. К данной категории также относятся логарифмические функции и функция извлечения корня числа: double log (double); // натуральные float logf ( float ); long double logl (long double); double log10(double); // десятичные float log10f (float); long double log10l(long double); double sqrt (double); // корень числа float sqrtf (float); long double sqrtl(long double); Математические функции

Содержание Sisukord Другая большая группа - функции получения абсолютной величины числа, int abs(int); // целые double fabs(double); // двойной точности long labs(long); // длинные float fabsf(float); // с плавающей точкой long double fabsl(long double); // длинные двойной точности воспринимают в качестве параметра аргумент некоторого типа (свой для каждой из функций) и возвращают его беззнаковую форму. Для вычисления остатка от деления числа х на у используется функция fmod(), которая имеет следующий синтаксис: double fmod(double х, double у);

Стандартная библиотека располагает широким набором тригонометрических функций и их модификаций для различных типов аргументов: // Арккосинус: double acos (double); float acosf (float); // Арксинус: double asin (double); float asinf (float); // Арктангенс: double atan (double); float atanf (float); // Арктангенс отношения y/x: double atan2 (double x, double y); float atan2f (float, float); // Косинус: double cos (double); float cosf (float); // Гиперболический косинус: double cosh (double); float coshf (float); // Синус: double sin (double); float sinf (float); // Гиперболический синус: double sinh (double); float sinhf (float); // Тангенс: double tan (double); float tanf (float); // Гиперболический тангенс: double tanh (double); float tanhf (float); NB!!! Углы тригонометрических функций указываются в радианах.

Содержание Sisukord Пример. Перевод градусов в радианы и вывод значения синуса для введенного в градусах числа. #include int main () { double Angle; double PI = ; cout > Angle; cout

Функции округления Зачастую требуется воспользоваться округленным значением той или иной переменной. С++ предлагает набор функций для решения этой задачи. В зависимости от конкретной ситуации может понадобиться функция, округляющая значение аргумента в большую или меньшую сторону. Для округления числа в меньшую сторону используется функция f loor () и ее разновидности для различных типов аргументов и возвращаемых параметров. Данная функция имеет следующий синтаксис: double floor (double х); long double floorl (long double x); Округление в большую сторону производится с помощью функции ceil(): double ceil (double х); long double ceil (long double x); Однако в реальности проблема выбора в какую же сторону производить округление, возлагается на разрабатываемую программу. Ниже предлагается два варианта решения этой задачи.

Содержание Sisukord Вариант I: inline double Round (double x) {return floor(x +.5);} Вариант II: double round (double num) { double frac; double val; frac = modf (num, aval); if(frac < 0.5) num = val; else num = val + 1.0; return num; } Для работы обоих вариантов функции необходимо задействовать заголовочный файл math.h, содержащий прототип функций floor() и modf(). К сожалению, в С++ нет готовой реализации функции возведения аргумента в квадрат. Эту функцию можно рализовать, например, следующим образом: inline double sqr (double x) {return pow (x, 2);} Заметим, что для работы данной функции необходимо задействовать заголовочный файл math.h, содержащий прототип функции pow ().