Перегрузка функций (статическая)

Содержание
ВВЕДЕНИЕ……………………………………………………………..…………3
1.Причины перегрузки……………………………………………………………4
2.Пример перегрузки………………………………………………………..……8
ЗАКЛЮЧЕНИЕ……………………………………………………….…………12
СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОНИКОВ ЛИТЕРАТУРЫ………...…13

ВВЕДЕНИЕ
Перегрузка функций — это возможность определять и использовать в программе несколько разных (но схожих по назначению) функций с одним и тем же именем, но с разными сигнатурами. Сигнатурафункции состоит из имени функции и совокупности типов ее формальных параметров. Сигнатура функции зависит от количества формальных параметров, от их типов и от порядка их следования. Тип результата функции не входит в сигнатуру функции. Распознавание перегруженных функций осуществляется по их сигнатурам. Перегруженные функции должны иметь одинаковые имена, но типы их параметров должны различаться по количеству и (или) по порядку следования в списке формальных параметров.
В настоящее время количество прикладных языков программирования (список языков), реализующих объектно-ориентированную парадигму, является наибольшим по отношению к другим парадигмам. В области системного программирования до сих пор применяется парадигма процедурного программирования, и общепринятым языком программирования является язык c. Хотя при взаимодействии системного и прикладного уровней операционных систем заметное влияние стали оказывать языки объектно-ориентированного программирования. Например, одной из наиболее распространенных библиотек мультиплатформенного программирования является объектно-ориентированная библиотека qt, написанная на языке c++.
В большинстве ранних языков программирования для упрощения процесса трансляции существовало ограничение, согласно которому одновременно в программе не может быть доступно более одной процедуры с одним и тем же именем. В соответствии с этим ограничением все подпрограммы, видимые в данной точке программы, должны иметь различные имена.
1.Причины перегрузки
Возможность выбрать соответствующую версию функции, основываясь на типах и числе аргументов, с которыми она вызывается, предоставляется компилятору. При этом два типа данных считаются различными, если для них используются различные инициализаторы. Поэтому аргумент данного типа и ссылка на этот тип рассматриваются как одно и то же с точки зрения перегрузки. Например, объявление двух таких функций
int func ( int ) ; int func ( int& ) ;
приведет к ошибке, так как с точки зрения перегрузки они считаются одинаковыми.
Аргументы функции, относящиеся к некоторому типу, модифицированные const или volatile, не рассматриваются как отличные от базового типа с точки зрения перегрузки.
Указатели на const- и volatile-объекты также не рассматриваются как отличные от указателей на базовый тип с точки зрения перегрузки.
Однако механизм перегрузки может различать ссылки, которые имеют модификаторы const и volatile, и ссылки на базовый тип.
Вместе с тем на перегруженные функции накладываются несколько ограничений: любые две перегруженные функции должны иметь различные списки параметров;
перегрузка функций с совпадающими списками аргументов на основе лишь типа возвращаемых ими значений недопустима;
функции-члены не могут быть перегружены исключительно на основе того, что одна из них является статической, а другая – нет;
все enum-типы данных рассматриваются как различные и могут использоваться для различения перегруженных функций;
типы "массив (чего-то)" и "указатель (на что-то)" рассматриваются как идентичные с точки зрения перегрузки.
typedef-определения не влияют на механизм перегрузки, так как они не вводят новых типов данных, а определяют лишь синонимы для существующих типов.
Например, следующее определение typedef char* PSTR ;не позволит компилятору рассматривать две приведенные ниже функции
void SetVal ( char* sz ) ; void SetVal ( PSTR sz ) ;
как различные. Поэтому их одновременное объявление в классе вызовет ошибку.
Для многомерных массивов вторая и последующие размерности рассматриваются как часть типа данных. Поэтому они могут использоваться для различения перегруженных функций. Например, вполне допустимы следующие определения:
void SetVal (char S [ ] ) ; void SetVal (char S [ ] [4] ) ;
Перегрузка функций – это один из типов полиморфизма, обеспечиваемого C++. В C++ несколько функций могут иметь одно и то же имя. В этом случае функция, идентифицируемая этим именем, называется перегруженной. Перегрузить можно только функции, которые отличаются либо типом, либо числом своих аргументов. Перегрузить функции, которые отличаются только типом возвращаемого значения,
нельзя. Перегружаемые функции дают возможность упростить программы, допуская обращение к одному имени для выполнения близких по смыслу действий.
Чтобы перегрузить некоторую функцию, нужно просто объявить, а затем определить все требуемые варианты ее вызова. Компилятор автоматически выберет правильный вариант вызова на основании числа и типа используемых аргументов. Пример:
#include <iostream.h>
int abs ( int ) ; // прототипы перегруженных функций
// функция получает и возвращает целое значение
float abs ( float ) ; // функция оперирует с вещественным числом одинарной точности
double abs ( double ) ; // функция оперирует с вещественным числом двойной точности
void main ( ) 
{  
int mN , N = -255 ;float mF , F = -25.0f ; double mD , D = -2.55 ;
mN = abs ( N ) ; // вызов перегруженной функции abs ( int )
mF = abs ( F ) ; // вызов перегруженной функции abs ( float )
mD = abs ( D ) ; // вызов перегруженной функции abs ( double )
cout << '\n' ;cout << '|' << N <<"| = " << mN << '\t' ; cout << '|' << F <<"| = " << mF << '\t' ; cout << '|' << D <<"| = " << mD << '\n' ;
}
int abs ( int a )
{
cout<<"abs(int)\t"; return a < 0 ? –a : a ;
}
float abs ( float a )
{
cout<<"abs(float)\t"; return a < 0 ? –a : a ;
}
double abs ( double a )
{
cout<<"abs(double)\t"; return a < 0 ? –a : a ;
}
При выполнении программа выводит на экран:
abs(int) abs(float) abs(double)
|-255| = 255 |-25| = 25 |-2.55| = 2.55
Библиотека времени выполнения C++ использует три разных функции abs ( ) , fabs ( ) и fabsf ( ) для вычисления абсолютного значения аргумента. Использование той или другой из них зависит от типа аргумента. Так, в данном примере осуществляется перегрузка функции abs ( ), что упрощает программу. В зависимости от переданного аргумента вызывается нужный вариант функции.
Этот пример наглядно демонстрирует, как использование перегрузки может упростить код, предоставляя программисту возможность пользоваться одной функцией, которой передаются аргументы различного типа. Разумеется, возможность использования перегрузки предъявляет повышенные требования к компилятору.
2. Пример перегрузки
При объявлении перегруженных функций компилятор отслеживает объявления, данные в пределах одной и той же области видимости. Поэтому, если в производном классе объявлена функция с тем же именем, что и функция в базовом классе, функция из производного класса скрывает функцию базового класса вместо того, чтобы осуществлять перегрузку (так как их области видимости различны). Короче говоря, нельзя путать переопределение функций с перегрузкой. Точно также компилятор отслеживает и другие области видимости. Поэтому, так как функция, объявленная в области видимости файла, находится не в той же области видимости, что и функция, объявленная в блоке, даже если они имеют одинаковые имена, компилятор не рассматривает их как перегруженные. Локально объявленная функция просто скрывает глобально объявленную.
Правила описания перегруженных функций:
1) Перегруженные функции должны находиться в одной области видимости.
2) Перегруженные функции могут иметь параметры по умолчанию, при этом значения одного и того же параметра в разных функциях должны совпадать. В разных вариантах перегруженных функций может быть разное количество умалчиваемых параметров.
3) Функции не могут быть перегружены, если описание их параметров отличается только модификатором const или наличием ссылки.
Например, функции int&f1(int&,const int&){... } и int f1(int,int){... } – не являются перегруженными, т. к. компилятор не сможет узнать какая из функций вызывается: нет синтаксических отличий между вызовом функции, которая передает параметр по значению и функции, которая передает параметр по ссылке.
Перегрузка функций — это возможность определять и использовать в программе несколько разных (но схожих по назначению) функций с одним и тем же именем, но с разными сигнатурами. Сигнатура функции состоит из имени функции и совокупности типов ее формальных параметров. Сигнатура функции зависит от количества формальных параметров, от их типов и от порядка их следования. Тип результата функции не входит в сигнатуру функции. Распознавание перегруженных функций осуществляется по их сигнатурам. Перегруженные функции должны иметь одинаковые имена, но типы их параметров должны различаться по количеству и (или) по порядку следования в списке формальных параметров.
Пример программы перегрузки функции
#includeint max(int , int); /*прототип 1-го экземпляра функции max(определение максимума из двух целых чисел)*/ int max (int, int, int) : /*прототип 2-го экземпляра (1-й копии)
функции шах (определение максимума из трех целых чисел)*/ double max (double, double); /* прототип 3-го экземпляра
(2-й копии) функции max (определениемакс, из двух числе типа double,)*/ int main() {int a,b,c, max_ab, max_abc; double x,y, max_xy;
printf("Введите через пробел a, b,c "); scant("%d%d%%d",&a,&b,&c); max_ab=max(a,b); max_abc=max(a,b,c);
printf("max_ab=%d max_abc=%d ",max_ab,max_abc); printf("Введите через пробел x,y "); scant("%lf%lf",&x,&y);
max_xy=max(x,у); printf("max_xy=%lf . max_xy); getchar(); return 0;
}
int max(int al, int bl)
//определение первого экземпляра функции max
{ int ml; if (al>=bl) ml=al; else ml=bl; return ml;
}
int max(int al, int bl, int cl)
//определение 2-го экземпляра (1-й копии) функции max{
int ml;
if ((al>=bl)&&(al>=cl)) ml=al;
if ((bl>=al)&&(bl>=cl)) ml=bl;
if ((cl>=al)&&(cl>=bl)) ml=cl;
return ml;
}
double max(double al, double bl)
//определение 3-го экземпляра 3-й копии) функции шах
{ double ml; if (al>=bl) ml=al; else ml=bl; return ml;}
Функция max перегружена с тремя разными списками параметров. Первая и третья версии отличаются типами параметров, а вторая — их количеством. Типы возвращаемых значений перегруженных функций могут быть одинаковыми или разными. При создании двух функций с одинаковым именем и одинаковым списком параметров, но с различными типами возвращаемых значений будет диагностирована ошибка компиляции.
При правильной перегрузке функций никакой путаницы при вызове функции не будет, поскольку нужная функция определяется по совпадению используемых параметров. Это позволяет создать функцию, которая сможет, например, усреднять целочисленные значения, значения типа double или значения других типов без необходимости создавать отдельные имена для каждой функции. При вызове перегруженной функции компилятор автоматически определит, какой именно вариант функции следует использовать.
Пример. Ввести с клавиатуры числа типа int и float, найти их абсолютные величины. Вычисление абсолютной величины оформить в виде функции.
#include
int ABS ( int) ; //прототипы функций ABS
float ABS(float);
int main()
{
int i; float a;
printf("Введите целое число: "); scanf(" %d",&i);
printf("Введите вещественное число: ");
scanf(" %f",&а);
printf("abs(%d)=%d; abs(%f)=%f ",i,ABS(i),a,ABS(a)); return 0;
}
int ABS(int a) //определениефункции int ABS ()
{
if (a>=0) return a; else
return -a;
}
float ABS (float a) //определение функции float ABS ()
{
if (a>=0.)
return a; else
return -a;
}
 В этом примере перегружена функция вычисления модуля числа. Обе функции имеют одинаковые имена. В одной в качестве параметра и возвращаемого значения используется целочисленная переменная, а во второй — вещественная. В функции main () в зависимости от типов используемых фактических параметров вызывается нужная функция.
ЗАКЛЮЧЕНИЕ
Правила описания перегруженных функций:
1) Перегруженные функции должны находиться в одной области видимости.
2) Перегруженные функции могут иметь параметры по умолчанию, при этом значения одного и того же параметра в разных функциях должны совпадать. В разных вариантах перегруженных функций может быть разное количество умалчиваемых параметров.
3) Функции не могут быть перегружены, если описание их параметров отличается только модификатором const или наличием ссылки.
Например, функции int&f1(int&,const int&){... } и int f1(int,int){... } – не являются перегруженными, т. к. компилятор не сможет узнать какая из функций вызывается: нет синтаксических отличий между вызовом функции, которая передает параметр по значению и функции, которая передает параметр по ссылке.
Наследование: переопределение функций происходит, когда один класс наследуется от другого класса. Перегрузка может происходить без наследования.
Подпись функции: перегруженные функции должны отличаться по сигнатуре функции, т. Е. Число параметров или тип параметров должны различаться. В переопределении подписи функций должны быть одинаковыми.
Объем функций: переопределенные функции находятся в разных областях; тогда как перегруженные функции находятся в той же области.
Поведение функций: Переопределение необходимо, когда функция производного класса должна выполнять некоторую добавленную или отличную работу, чем функция базового класса. Перегрузка используется, чтобы иметь функции с одинаковыми именами, которые ведут себя по-разному в зависимости от параметров, передаваемых им.
Список использованных источников литературы
Дубров Г.В. Основы программирования на С++. – М.: Конкорд, 2017. – 219 c.
Подбельский В.В. Язык С++: Учебное пособие – 5 изд. – М: Финансы и статистика, 2018. – 560 c.
Шилдт Г. С++: базовый курс. 3-е издание. – М.: Издательский дом "Вильямс". 2019. – 624 с.
Хусаинова Г.Я. Этапы проектирования информационной системы // Вестник Технологического университета. 2018. Т. 21. № 6. – С. 153-156.
Хусаинова Г.Я., Хусаинов И.Г. Разработка информационной системы "Водные ресурсы республики Башкортостан" // Современные наукоемкие технологии. 2018. № 9. С. 141-144.
Хусаинов И.Г. Тепловые процессы при акустическом воздействии на насыщенную жидкостью пористую среду // Вестник Башкирского университета. 2016. Т. 18. № 2. С. 350-353.
М. Эллис, Б. Строуструп. Справочное руководство по языку C++ с комментариями: Пер. с англ. - Москва: Мир, 2017. 445с. .