Перегрузка (полиморфизм времени компиляции)

1.

Перегрузка (полиморфизм
времени компиляции)

2.

Перегрузка функций
Пример перегрузки функции:
#include <iostream>
using namespace std;
int
sqr( int i );
int
);
sqr( int i1, int i2
double
sqr( double d );
long
sqr( long l );
int main()
{
int sqr( int i )
{
return i * i;
}
int sqr( int i1, int i2 )
{
return i1 * i2;
}
double sqr( double d )
{
return d * d;
}
long sqr( long l )
{
return l * l;
}

3.

Перегрузка операций
A a1("Строка"), a2;
Требуется скопировать данные из a1 в a2.

4.

Перегрузка операций
class A
{
a2.copy(a1)
string str;
public:
A(): str("") {}
A(const string s):
str(s){}
void copy(const A&
s);
};
void A::copy(const A& s)
{
str = s.str;
}
int main()
{
A a1("Строка"), a2;
a2.copy(a1);
Строка
str = s.str
str
s.str
Строка
a
2
Строка

5.

Перегрузка операций
a
2
class A
{
string str;
public:
void operator=(const
A& s);
};
= a1
Строк
а
a
2
Строк
а
void A::operator=(const A& s)
{
str = s.str;
}
int main()
{
A a1("Строка"), a2;
a2 = a1;
return 0;
}
Не явно делаем: a2.operator=(a1)
Строка

6.

Перегрузка операций
class A
{
string str;
public:
void operator=(const
A& s);
void operator+(const
A& s);
};
void A::operator=(const A& s)
{
str = s.str;
}
void A::operator+(const A& s)
{
str = str + s.str;
А что если
a = a1 + a2 или a = a1 + a2 +
}
a3?
Получим сл-е
преобразование a.operator=(a1.operator+(a2.operator+(a3)))

7.

Перегрузка операций
class A
{
string str;
public:
A operator=(const A&
s);
A operator+(const A&
s);
};
A A::operator=(const A& s)
{
a.str = s.str;
return *this;
}
A A::operator+(const A& s)
{
A sum;
sum.str = str + s.str;
return sum;

8.

Перегрузка операций
Пример реализации перегрузки операции присваивания:
simpleClass& simpleClass::operator=(const simpleClass& rhs)
{
if (this == &rhs) return *this;
classStr = rhs.classStr;
return *this;
}
Пример реализации перегрузки операции сложения:
simpleClass simpleClass::operator+(const simpleClass& other)
{

9.

Перегрузка операций
Пример использования операции сложения:
twoObj = oneObj + newObj;
или
twoObj = oneObj + "Hello";
А что если так?
twoObj = "Hello" + oneObj;
Обычно следует преобразование из
twoObj = oneObj + newObj в
twoObj = oneObj.operator+(newObj)

10.

Дружественность
Существуют следующие виды дружественных
отношений:
1)дружественные функции;
2)дружественные классы;
3)дружественные функции-члены.

11.

void A::func(int n)
{
Дружественные функции
}
Функция:
void func(Cls& n, int k)
{
}
Примеры их вызовов:
obj.func(10);

12.

Дружественные функции
Определим в классе функцию друг:
class A
{
friend simpleClass operator+(string str,
const simpleClass& other);
};
Написать реализацию:
simpleClass operator+(string str,
const

13.

Дружественные функции и
перегрузка операций
Получим следующие преобразование:
из
twoObj = "Hello" + oneObj;
в
twoObj = operator+("Hello", oneObj);
или ещё подробнее
twoObj.operator=(operator+("Hello", oneObj));