Пример 6.4. Сглаживание заданной вещественной матрицы, работа с файлами

2.4. Результаты работы программы:

Лабораторная работа № 7

Функции и перегрузка в языке С++

Ход работы:

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

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

Это функция с двумя параметрами типа float, причём аргументы передаваемые в функцию должны быть в сантиметрах, возвращаемое значение типа float — тоже в сантиметрах.

Предположим, что ваши исходные данные (стороны прямоугольника) заданы в метрах и сантиметрах, например такие: a = 2м 35 см; b = 1м 86 см. В таком случае, удобно было бы использовать функцию с четырьмя параметрами. То есть, каждая длинна сторон прямоугольника передаётся в функцию по двум параметрам: метры и сантиметры.

int main()

{

areaRectangle(float, float) //функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см)

{

return a * b; // умножаем длинны сторон прямоугольника и возвращаем полученное произведение

}

В теле функции значения, которые передавались в метрах (a_m и b_m) переводятся в сантиметры и суммируются с значениями a_sm b_sm, после чего перемножаем суммы и получаем площадь прямоугольника в см. Конечно же можно было перевести исходные данные в сантиметры и пользоваться первой функцией.

Есть две функции, с разной сигнатурой, но одинаковыми именами (перегруженные функции). Сигнатура – это комбинация имени функции с её параметрами. Данные функции носят название перегруженные. А вызов перегруженных функций ничем не отличается от вызова обычных функций, например:

areaRectangle(32, 43); // будет вызвана функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см)

areaRectangle(4, 43, 2, 12); // будет вызвана функция, вычисляющая площадь прямоугольника с 4-мя параметрами a(м) a(см); b(м) b(cм)

Компилятор самостоятельно выберет нужную функцию, анализируя только лишь сигнатуры перегруженных функций. Минуя перегрузку функций, можно было бы просто объявить функцию с другим именем, и она бы хорошо справлялась со своей задачей. Но представьте, что будет, если таких функций надо больше, чем две, например 10. И для каждой нужно придумать осмысленное имя, а сложнее всего их запомнить. Вот именно поэтому проще и лучше перегружать функции, если конечно в этом есть необходимость. Исходный код программы показан ниже.

#include "stdafx.h"

#include <iostream>

#include "fstream"

#include <string>

#include <cstring>

#include "clocale"

#include "ctime"

#include "conio.h"

#include "stdio.h"

#include "windows.h"

#include "stdlib.h"

#include <iostream>

#include <math.h> // Перегрузка операторов.cpp: определяет точку входа для консольного приложения.

class funczii;

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

float S1;

float S2;

float a;

float b;

void areaRectangle(float a, float b);

void areaRectangle(float a_m, float a_sm, float b_m, float b_sm);

{

cout << "S1 = " << areaRectangle(32, 43) << endl; // вызов перегруженной функции 1

cout << "S2 = " << areaRectangle(4, 43, 2, 12) << endl; // вызов перегруженной функции 2

cin >> a;

cin >> b;

return 0;

}

// перегруженная функция 1

void areaRectangle(float a, float b); //функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см)

{

float a;

float b;

return a * b; // умножаем длинны сторон прямоугольника и возвращаем полученное произведение

}

float a_m;

float a_sm;

float b_m;

float b_sm;

// перегруженная функция 2

void areaRectangle(float a_m, float a_sm, float b_m, float b_sm); // функция, вычисляющая площадь прямоугольника с 4-мя параметрами a(м) a(см); b(м) b(cм)

{

return (a_m * 100 + a_sm) * (b_m * 100 + b_sm);

}

system ("pause");

int getch();

return 0;

}

Результат работы программы:

2.5. Результаты работы программы:

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

Затем, научившись объявлять, определять и использовать функции в программах, познакомимся с перегрузкой – еще одним аспектом в C++. Перегрузка позволяет иметь несколько одноименных функций, выполняющих схожие операции над аргументами разных типов.
Ознакомившись, уже воспользовались предопределенной перегруженной функцией. Например, для вычисления выражения:

1 + 3

вызывается операция целочисленного сложения, тогда как вычисление выражения

1.0 + 3.0

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

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

int i_max(int, int);

int vi_max(const vector<int> &);

int matrix_max(const matrix &);

Однако все они делают одно и то же: возвращают наибольшее из значений параметров. С точки зрения пользователя, здесь лишь одна операция – вычисление максимума, а детали ее реализации большого интереса не представляют. Отмеченная лексическая сложность отражает ограничение программной среды: всякое имя, встречающееся в одной и той же области видимости, должно относиться к уникальной сущности (объекту, функции, классу и т.д.). Такое ограничение на практике создает определенные неудобства, поскольку программист должен помнить или каким-то образом отыскивать все имена. Перегрузка функций помогает справиться с этой проблемой.
Применяя перегрузку, программист может написать примерно так:

int ix = max(j, k);

vector<int> vec;

//...

int iy = max(vec);

Этот подход оказывается чрезвычайно полезным во многих ситуациях.

В C++ двум или более функциям может быть дано одно и то же имя при условии, что их списки параметров различаются либо числом параметров, либо их типами. В данном примере мы объявляем перегруженную функцию max():

Для каждого перегруженного объявления требуется отдельное определение функции max() с соответствующим списком параметров.
Если в некоторой области видимости имя функции объявлено более одного раза, то второе (и последующие) объявление интерпретируется компилятором так:

• если списки параметров двух функций отличаются числом или типами параметров, то функции считаются перегруженными:

• если тип возвращаемого значения и списки параметров в объявлениях двух функций одинаковы, то второе объявление считается повторным:

Имена параметров при сравнении объявлений во внимание не принимаются;
если списки параметров двух функций одинаковы, но типы возвращаемых значений различны, то второе объявление считается неправильным (несогласованным с первым) и помечается компилятором как ошибка:

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

Ключевое слово typedef создает альтернативное имя для существующего типа данных, новый тип при этом не создается. Поэтому если списки параметров двух функций различаются только тем, что в одном используется typedef, а в другом тип, для которого typedef служит псевдонимом, такие списки считаются одинаковыми, как, например, в следующих двух объявлениях функции calc(). В таком случае второе объявление даст ошибку компиляции, поскольку возвращаемое значение отличается от указанного раньше:

Спецификаторы const или volatile при подобном сравнении не принимаются во внимание. Так, следующие два объявления считаются одинаковыми:

Спецификатор const важен только внутри определения функции: он показывает, что в теле функции запрещено изменять значение параметра. Однако аргумент, передаваемый по значению, можно использовать в теле функции как обычную инициированную переменную: вне функции изменения не видны. (Способы передачи аргументов, в частности передача по значению, обсуждаются в разделе.) Добавление спецификатора const к параметру, передаваемому по значению, не влияет на его интерпретацию. Функции, объявленной как f(int), может быть передано любое значение типа int, равно как и функции f(const int). Поскольку они обе принимают одно и то же множество значений аргумента, то приведенные объявления не считаются перегруженными. f() можно определить как

или как

Наличие двух этих определений в одной программе – ошибка, так как одна и та же функция определяется дважды.
Однако, если спецификатор const или volatile применяется к параметру указательного или ссылочного типа, то при сравнении объявлений он учитывается.

В C++ двум или более функциям может быть дано одно и то же имя при условии, что их списки параметров различаются либо числом параметров, либо их типами. В данном примере мы объявляем перегруженную функцию max():

Для каждого перегруженного объявления требуется отдельное определение функции max() с соответствующим списком параметров.
Если в некоторой области видимости имя функции объявлено более одного раза, то второе (и последующие) объявление интерпретируется компилятором так:

• если списки параметров двух функций отличаются числом или типами параметров, то функции считаются перегруженными:

• если тип возвращаемого значения и списки параметров в объявлениях двух функций одинаковы, то второе объявление считается повторным:

Имена параметров при сравнении объявлений во внимание не принимаются;
если списки параметров двух функций одинаковы, но типы возвращаемых значений различны, то второе объявление считается неправильным (несогласованным с первым) и помечается компилятором как ошибка:

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

Ключевое слово typedef создает альтернативное имя для существующего типа данных, новый тип при этом не создается. Поэтому если списки параметров двух функций различаются только тем, что в одном используется typedef, а в другом тип, для которого typedef служит псевдонимом, такие списки считаются одинаковыми, как, например, в следующих двух объявлениях функции calc(). В таком случае второе объявление даст ошибку компиляции, поскольку возвращаемое значение отличается от указанного раньше:

Спецификаторы const или volatile при подобном сравнении не принимаются во внимание. Так, следующие два объявления считаются одинаковыми:

Спецификатор const важен только внутри определения функции: он показывает, что в теле функции запрещено изменять значение параметра. Однако аргумент, передаваемый по значению, можно использовать в теле функции как обычную инициированную переменную: вне функции изменения не видны. (Способы передачи аргументов, в частности передача по значению, обсуждаются в разделе 7.3.) Добавление спецификатора const к параметру, передаваемому по значению, не влияет на его интерпретацию. Функции, объявленной как f(int), может быть передано любое значение типа int, равно как и функции f(const int). Поскольку они обе принимают одно и то же множество значений аргумента, то приведенные объявления не считаются перегруженными. f() можно определить как

или как

Наличие двух этих определений в одной программе – ошибка, так как одна и та же функция определяется дважды.
Однако, если спецификатор const или volatile применяется к параметру указательного или ссылочного типа, то при сравнении объявлений он учитывается.

Примеры работы с перегруженными функциями:

Пример № 1
Напишите функцию print_out, печатающую все целые числа в диапазоне от 1 до N. Проверьте работу функции, поместив ее в программу и передав ей число n – число, введенное с клавиатуры. Возвращаемый тип функции print_out должен быть void; функция не возвращает значение. Функция может быть вызвана простой инструкцией: print_out (n).

Исходный код:

#include<iostream.h>
#include<conio.h>
void print_out (int n) // void означает, что функция ничего не возвращает
{
clrscr ();
int i;
for (i=0;i<n;i++)
cout <<i<<"";
}
void main ()
{
int n;
cout<<"Vvedite N";
cin>>n;
print_out (n);
getch ();
}

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

Исходный код (иногда называют "листинг"):

#include <iostream.h>
#include <conio.h>
int max_chislo(int n, int m)
{
if (m>n)
return m;
else return n;
}
void main ()
{
clrscr ();
int n;
int m;
cout <<"Vvedite m=";
cin>>m;
cout <<"Vvedite n=";
cin >>n;
cout<<max_chislo(m, n);
getch ();
}

Теория:
Примеры функций преобразования. Цель их использования.
1). atoi() преобразует строку в целое число
2). itoa() преобразует целое число в строку
3). atof() преобразует строку в вещественное число
4). fcvt() преобразует вещественное число в строку

Основные функции ввода, вывода.
1). В Си используются функции printf() и scanf()
1.1) printf() – выводит форматированный текст на консоль
1.2) scanf() – сканирует данные с клавиатуры и заполняет переменные по адресам

2). В Си++ используются объекты cout и cin
2.1) сout – для вывода на консоль используется оператор <<
2.2) cin – для чтения с клавиатуры используется оператор >>

Функции работы с файлами. Примеры.
1) В Си используются следующие функции:
1.1) fopen() – открывает файл в заданном режиме
1.2) fprintf() – записывает форматированную строку в файл
1.3) fscanf() – читает данные из файла
1.4) fclose() – закрывает файл

Пример использования:

#include <stdio.h>
int main()
{
FILE *pFile = fopen(“file.txt” “w”); //открыли для записи
fprintf(f, “This is text file”); //записали в файл строчку
fclose(pFile); //закрыли файл
return 0;
}

2) В Си++ используют следующие классы:
2.1) fstream – класс файлового ввода-вывода
2.2) ofstream – класс файлового вывода
2.3) ifstream – класс файлового ввода

В данных классах используют следующие методы:
* open() – открывает файл
* getline() – читает строку из файла
* write() – записывает строку в файл
* close() – закрывает файл

Также возможно использовать перегруженные операторы << и >> для записи в файл и чтения из файла.
Пример использования:

#include <iostream.h>
#include <fst