Презентация на тему ПЕРЕГРУЗКА ОПЕРАЦИЙ

позволяет определять несколько функций с одинаковыми именами и разной

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

естественно. Например, общей вычислительной задачей является сложение двух массивов.

Обычно это выглядит подобно следующему циклу for:
for (int i = 0; i < 20; i++)
massC[i]=massA[i]+massB[i];//поэлементное сложение
Но в С++ можно определить класс, который представляет массивы и перегружает операцию + таким образом, что станет возможным приведенный ниже код:
massC = massA + massB;// сложить два объекта-массива

функцией операции. Функция операции имеет следующую форму, в которой

ор — это символ перегружаемой операции:
operatorop (список-аргументов)
Например, operator+ ( ) перегружает операцию +, a operator* ( ) — операцию *. Операция ор должна быть допустимой операцией С++, а не произвольным символом.

функция-член operator+ ( ) для перегрузки операции + так,

что она сможет добавлять зарплату одного лица к зарплате другого лица. Тогда если sam, sid и sara — объекты класса Salesperson, можно написать следующее выражение:
sam = sid + sara;
Компилятор, распознав операцию как относящуюся к классу Salesperson, заменит ее вызовом соответствующей функции операции:
sam = sid.operator+(sara) ;

пользователя в течение 2 часов 35 минут с утра

и 2 часов 40 минут после обеда, то сколько всего времени вы проработали в системе? Ниже приведен пример, в котором концепция сложения имеет смысл, несмотря на то, что единицы, которые вы складываете (смесь часов и минут) не соответствует какому-либо встроенному типу.

class Time
{
private:
int hours;
int minutes;
public:
Time ()

;
Time (int h, int m);
void AddMin(int m) ;
void AddHr (int h) ;
void Reset (int h , int m) ;
Time Sum (const Time & t) ;
void Show () ;
} ;

h;
minutes = m;
}
Time Time:: Sum (const Time & t)

{
Time sum;
sum.minutes = minutes + t.minutes;
sum.hours = hours + t.hours + sum.minutes / 60;
sum.minutes %= 60;
return sum;
}
void Time::Show () {
std::cout « hours « " hours, " « minutes « " minutes";
}

Time
// компилировать usetime.срр и mytime.cpp вместе
#include

#include "mytime.h"
int main()
{
using std::cout;
using std::endl;
Time planning;
Time coding(2, 40);
Time fixing(5, 55);
Time total;
cout « "planning time = ";
planning.Show ();
cout « endl;
cout « "coding time = ";
coding.Show ();
cout « endl;
cout « "fixing time = ";
fixing.Show ();
cout « endl;
total = coding.Sum(fixing) ;
cout « "coding. Sum (fixing) = ";
total.Show();
cout « endl;
return 0;
}

= 0 hours, 0 minutes
coding time = 2

hours, 40 minutes
fixing time = 5 hours, 55 minutes
coding.Sum(fixing) = 8 hours, 35 minutes

Time {
private:
int hours;
int minutes;
public:
Time();
Time (int h, int m)

;
void AddMin (int m) ;
void AddHr(int h);
void Reset (int h , int m) ;
Time operator+(const Time & t);
void Show();
};

#include "nmytime. h"
Time: :Time () {
hours = minutes =

0;
}
Time::Time (int h, int m ) {
hours = h; minutes = m;
}
void Time::AddMin (int m) {
minutes += m;
hours += minutes / 60;
minutes %= 60;
}
void Time::AddHr(int h) {
hours += h;
}

h; minutes = m;
}
Time Time::operator+(const Time & t) {
Time

sum;
sum.minutes = minutes + t.minutes;
sum.hours = hours + t.hours + sum.minutes / 60;
sum.minutes %= 60;
return sum;
}
void Time::Show() {
std::cout « hours « " hours, " « minutes « " minutes";
}

же синтаксиса, что и в случае с Sum ():
total=coding.operator+(fixing);//нотация

с функцией
Но назначение методу имени operator+ () позволяет также применить нотацию операции:
total = coding + fixing;// нотация с операцией
Оба варианта вызывают метод operator+ (). Обратите внимание, что в нотации с операцией объект слева от операции (в рассматриваемом случае coding) является вызывающим объектом, а объект справа (в данном случае fixing) передается в качестве аргумента.

Time
// компилировать nusetime.срр и nmytime.cpp вместе
#include
#include

“nmytime.h"
int main () {
using std::cout; using std::endl;
Time planning; Time coding(2, 40); Time fixing (5, 55); Time total;
cout « "planning time = "; planning.Show () ;
cout « endl; cout « "coding time = "; coding.Show (); cout « endl; cout « "fixing time = "; fixing.Show () ; cout « endl; total = coding + fixing;
// Нотация с операцией

cout « endl;
Time morefixing (3, 28);
cout « "more

fixing time = "; morefixing.Show (); cout « endl;
total = morefixing.operator+(total) ; cout<<"morefixing.operator+(total)= "; total.Show(); }cout « endl; return 0;}

= а + b; // используется сложение значений int
С

= А + В; // используется сложение, определенное для объектов Time

операнд типа, определяемого пользователем. Это предотвращает перегрузку операций, работающих

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

перегружать следующие операции:

функции- члены: