|
|
Функция, выделяющая целую и дробную части вещественного числаСтр 1 из 3Следующая ⇒
int main() { void intfrac(float, float&, float&); //прототип функции, передача параметров по ссылке float number, intpart, fracpart; //переменные intpart, fracpart можно не инициализировать, //т.к. они предназначены для возврата значения из функции do { cout << "\nEnter a real number: \n "; cin >> number; //ввод вещественного числа intfrac (number, intpart, fracpart); //вызов функции, // intpart, fracpart передаются для возврата результата cout << "Integer part is " << intpart << endl; cout << ", fraction part is " << fracpart << endl; } while (number!= 0.0); //завершение работы, если введено 0.0 _getch(); return 0; } //-------------------------------------------------------------- void intfrac(float n, float& intp, float& fracp) // определение функции { long temp = static_cast<long>(n); intp = static_cast<float>(temp); fracp = n - intp; //нахождение дробной части числа }
Функция, возвращающая ссылку как результат своей работы
int x; // глобальная переменная int& setx(); // прототип функции int main() { cout << "x=" << x << endl; // вывод значения глобальной переменной
setx() = 92; // функция вызывается из левой части оператора присваивания cout << "x=" << x << endl; // вывод нового значения глобальной переменной _getch(); return 0; } //-------------------------------------------------------------- int& setx() { return x; // возвращается ссылка на х }
Результат работы: x=0 x=92 Демонстрация inline-функций
inline double lbstokg (float pounds) // функция конвертирует фунты в килограммы { return 0.453592 * pounds; } //-------------------------------------------------------------- int main() { float lbs;
cout << "\n Enter your weight in pounds: "; cin >> lbs; cout << "Your weight in kilograms is " << lbstokg (lbs) << endl; _getch(); return 0; }
Результаты работы Enter your weight in pounds: 3.5 Your weight in kilograms is 1.58757 Демонстрация функции с параметрами по умолчанию void repchar(char='*', int=45); //прототип функции с параметрами по умолчанию int main() { repchar(); //вызов функции с двумя аргументами по умолчанию //печать 45 символов «звездочка» repchar('='); //вызов функции с заданным первым аргументом //печать 45 знаков «равно» repchar('+', 30); //вызов функции с двумя заданными аргументами //печать 30 знаков «плюс» _getch(); return 0; } //-------------------------------------------------------------- void repchar(char ch, int n) { for(int j=0; j<n; j++) cout << ch; cout << endl; }
Результаты работы:
********************************************* ============================================= ++++++++++++++++++++++++++++++ Перегрузка функций В С++ можно определить с одним и тем же именем несколько функций, которые отличаются типами параметров и реже их количеством. Тогда говорят, что функции перегружены. Под перегрузкой понимается создание нескольких прототипов и определений функций, имеющих одинаковое имя.
Перегрузка функций с равным числом аргументов Рассмотрим пример программы, в которой перегружаются две функции с равным числом аргументов и имеющие одинаковые имена. Первая функция int func (int a, int b) определяет сумму двух целых чисел a и b, вторая - float func (float a, float b) – разность двух чисел с плавающей точкой: int func (int a, int b); //прототип функции вычисления суммы float func (float a, float b); //прототип функции вычисления разности //-------------------------------------------------------------- int main () {int a=25, b=40; float c=2.45f, d=6.15f; cout << "\n summa=" << func (a,b); //вызов функции с аргументами целого типа cout << "\n raznost=" << func (c,d); //вызов функции с аргументами типа float _getch(); return 0; } //-------------------------------------------------------------- int func(int a, int b) //определение функции вычисления суммы {return (a+b); } //-------------------------------------------------------------- float func(float a, float b) //определение функции вычисления разности {return (a-b); }
Перегрузка функций с разным числом аргументов А теперь рассмотрим пример перегрузки функций, имеющих разное количество параметров. Функции выполняют вывод на экран символа (заданного в виде аргумента или определенного в функции) некоторое количество раз (заданное в качестве аргумента или определенное в функции): void repchar(); //прототип функции для вывода символа ‘*’ 45 раз void repchar(char); //прототип функции для вывода символа-аргумента 45 раз void repchar(char, int); //прототип функции для вывода символа-аргумента // заданное через второй аргумент количество раз //-------------------------------------------------------------- int main() { repchar(); //вызов функции для вывода символа ‘*’ 45 раз repchar('='); //вызов функции для вывода символа ‘=’ 45 раз repchar('+', 30); //вызов функции для вывода символа ‘+’ 30 раз _getch(); return 0; } //-------------------------------------------------------------- void repchar() { for(int j=0; j<45; j++) cout << '*'; cout << endl; } //-------------------------------------------------------------- void repchar(char ch) { for(int j=0; j<45; j++) cout << ch; cout << endl; } //-------------------------------------------------------------- void repchar(char ch, int n) { //через второй аргумент количество раз for(int j=0; j<n; j++) cout << ch; cout << endl; } Результат работы: ********************************************* ============================================= ++++++++++++++++++++++++++++++ Шаблоны семейства функций Подготовку перегружаемых функций помогают автоматизировать шаблоны. Шаблон семейства функций определяется один раз, но это определение параметризуется. Для этого используется список параметров шаблона (в качестве параметра на этапе компиляции передается конкретный тип данных). Шаблон семейства функций состоит из двух частей: заголовка шаблона
Формат простейшей функции-шаблона: template <class type> { //тело функции } где вместо слова type может использоваться произвольное имя. Определим шаблон семейства функций, вычисляющих абсолютное значение числовых величин разных типов:
//-------------------------------------------------------------- template <class T> //шаблон семейства функций T abs(T n) T abs(T n) { return (n < 0)? -n: n; } //-------------------------------------------------------------- int main() { int i1 = 5; //инииализация переменных разных типов и знаков int i2 = -6; long l1 = 70000L; long l2 = -80000L; double d1 = 9.95; double d2 = -10.15; //вызовы функций cout << "\nabs(" << i1 << ")=" << abs(i1); //abs(int) cout << "\nabs(" << i2 << ")=" << abs(i2); //abs(int) cout << "\nabs(" << l1 << ")=" << abs(l1); //abs(long) cout << "\nabs(" << l2 << ")=" << abs(l2); //abs(long) cout << "\nabs(" << d1 << ")=" << abs(d1); //abs(double) cout << "\nabs(" << d2 << ")=" << abs(d2); //abs(double) cout << endl; _getch(); return 0; }
Определим шаблон семейства функций для обмена значений двух передаваемых им параметров: template <class T>
При определении переменных long k=4, d=8; и вызове swap(&k, &d); будет сформировано определение void swap(long* x, long* y) {long z=*x; *x=*y; *y=z;}
При определении переменных double a=2.44, b=66.3; и вызове swap(&a, &b); будет сформировано определение void swap(double* x, double* y) {double z=*x; *x=*y; *y=z;}
Определим шаблон семейства функций для поиска минимального из трех значений, причем функция возвращает элемент с минимальным значением: template <class T> T min3(T x, T y, T z) {T min =x; if (y<min) min = y; if (z<min) min = z; return min; } int main() {int a=2, b=5, c=-5; cout << min3(a*c, b, c) << endl; //-10 cout << min3(0.03*a, 10.0, 5.0) << endl; //0.06 _getch(); return 0; }
Если все 3 аргумента будут одного типа, компилятор создаст нужную функцию, если нет – то сообщение об ошибке. Имя параметра шаблона, например N (template <class N>), видимо во всем определении и скрывает другие определения того же идентификатора в области, глобальной по отношению к данному шаблону; для доступа к ним используется операция изменения области видимости:
int N=0; //глобальная переменная N
template <class N> //прототип шаблона N maxx (N x, N y); // идентификаторы параметров в прототипе шаблона не опускаются
int main() {int a=12, b=42; maxx (a, b); cout << a << " " << b << endl; float z=66.3f, f=222.4f; maxx (z, f); cout << z << " " << f << endl; _getch(); return 0; }
template <class N> //определение шаблона N maxx (N x, N y) {N a = x; cout << "\n N=" << ++::N << endl; if (a<y) a=y; return a; } Рекурсивные функции Условия «правильного» рекурсивного определения: § множество определяемых объектов частично упорядочено; § каждая убывающая по этому упорядочению последовательность элементов заканчивается некоторым минимальным элементом; § минимальные элементы определяются нерекурсивно; характерное свойство описания рекурсивной функции состоит в том, что в ней должна содержаться проверка значений аргументов для принятия решения о завершении функции; § неминимальные элементы определяются с помощью элементов, которые меньше их по этому упорядочению.   Что способствует осуществлению желаний? Стопроцентная, непоколебимая уверенность в своем...  Что делать, если нет взаимности? А теперь спустимся с небес на землю. Приземлились? Продолжаем разговор...  ЧТО ПРОИСХОДИТ, КОГДА МЫ ССОРИМСЯ Не понимая различий, существующих между мужчинами и женщинами, очень легко довести дело до ссоры...  Что делает отдел по эксплуатации и сопровождению ИС? Отвечает за сохранность данных (расписания копирования, копирование и пр.)... Не нашли то, что искали? Воспользуйтесь поиском гугл на сайте:
|