Сдам Сам

ПОЛЕЗНОЕ


КАТЕГОРИИ







Функция, выделяющая целую и дробную части вещественного числа





 

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);
//приведение к типу long int для выделения целой части

intp = static_cast<float>(temp);
//конвертирование обратно в тип float

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()
//определение функции вывода символа ‘*’ 45 раз

{

for(int j=0; j<45; j++)

cout << '*';

cout << endl;

}

//--------------------------------------------------------------

void repchar(char ch)
//определение функции вывода символа-аргумента 45 раз

{

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 <список параметров шаблона>) и обычного определения функции (заголовок и тело функции), в котором тип возвращаемого значения и/или типы параметров обозначаются именами параметров шаблона, введенных в его заголовке. Имена параметров шаблона могут использоваться и в теле определения функции для обозначения типов локальных объектов.

 

Формат простейшей функции-шаблона:

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>
voidswap(T*x, T*y) {T z=*x; *x=*y; *y=z;}

 

При определении переменных 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;

}

Рекурсивные функции

Условия «правильного» рекурсивного определения:

§ множество определяемых объектов частично упорядочено;

§ каждая убывающая по этому упорядочению последовательность элементов заканчивается некоторым минимальным элементом;

§ минимальные элементы определяются нерекурсивно; характерное свойство описания рекурсивной функции состоит в том, что в ней должна содержаться проверка значений аргументов для принятия решения о завершении функции;

§ неминимальные элементы определяются с помощью элементов, которые меньше их по этому упорядочению.









Не нашли то, что искали? Воспользуйтесь поиском гугл на сайте:


©2015- 2018 zdamsam.ru Размещенные материалы защищены законодательством РФ.