Перегрузка в C++: функции и операторы — подробное руководство

C++ позволяет задавать более одного определения для имени функции или оператора в одной области видимости — это называется перегрузкой функций и перегрузкой операторов соответственно.

Перегруженное объявление — объявление с тем же именем, что и ранее объявленное в той же области, но с другими аргументами и, очевидно, другой реализацией.

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

Перегрузка функций в C++

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

Пример: одна функция print() для печати разных типов данных:

Live Demo

#include <iostream>
using namespace std;
class printData {
public:
    void print(int i) {
        cout << "Printing int: " << i << endl;
    }
    void print(double f) {
        cout << "Printing float: " << f << endl;
    }
    void print(char* c) {
        cout << "Printing character: " << c << endl;
    }
};
int main(void) {
    printData pd;
    pd.print(5);           // целое
    pd.print(500.263);     // float
    pd.print("Hello C++"); // строка
    return 0;
}

Результат:

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Перегрузка операторов в C++

Можно переопределять или перегружать большинство встроенных операторов C++. Таким образом, программист может использовать операторы с пользовательскими типами.

Перегруженные операторы — это функции со специальными именами: ключевое слово operator за которым следует символ оператора. Как и любая функция, у перегруженного оператора есть тип возвращаемого значения и список параметров.

Box operator+(const Box&);

объявляет оператор сложения для сложения двух объектов Box и возврата итогового объекта Box. Большинство перегруженных операторов могут быть определены как обычные не-член-функции или как функции-члены класса. Если определить как не-член-функцию, нужно передавать два аргумента для каждого операнда:

Box operator+(const Box&, const Box&);

Пример перегрузки оператора через функцию-член. Объект передаётся как аргумент, его свойства доступны через этот объект; объект, вызывающий оператор, доступен через this:

Live Demo

#include <iostream>
using namespace std;
class Box {
public:
    double getVolume(void) { return length * breadth * height; }
    void setLength(double len) { length = len; }
    void setBreadth(double bre) { breadth = bre; }
    void setHeight(double hei) { height = hei; }
    // Перегрузка + для сложения двух Box
    Box operator+(const Box& b) {
        Box box;
        box.length = this->length + b.length;
        box.breadth = this->breadth + b.breadth;
        box.height = this->height + b.height;
        return box;
    }
private:
    double length;
    double breadth;
    double height;
};
int main() {
    Box Box1, Box2, Box3;
    double volume = 0.0;
    // Box1
    Box1.setLength(6.0);
    Box1.setBreadth(7.0);
    Box1.setHeight(5.0);
    // Box2
    Box2.setLength(12.0);
    Box2.setBreadth(13.0);
    Box2.setHeight(10.0);
    // объём Box1
    volume = Box1.getVolume();
    cout << "Volume of Box1 : " << volume << endl;
    // объём Box2
    volume = Box2.getVolume();
    cout << "Volume of Box2 : " << volume << endl;
    // сложение объектов
    Box3 = Box1 + Box2;
    // объём Box3
    volume = Box3.getVolume();
    cout << "Volume of Box3 : " << volume << endl;
    return 0;
}

Результат:

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Перегружаемые и неперегружаемые операторы

Список операторов, которые можно перегрузить:

+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	--
<<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	new	new []	delete	delete []

Список операторов, которые нельзя перегрузить:

::

.*

.

?:

Примеры перегрузки операторов

Различные примеры для понимания концепции:

№	Операторы и пример
1	Перегрузка унарных операторов
2	Перегрузка бинарных операторов
3	Перегрузка операторов отношения
4	Перегрузка операторов ввода/вывода
5	Перегрузка ++ и --
6	Перегрузка операторов присваивания
7	Перегрузка оператора вызова функции ()
8	Перегрузка оператора индексации []
9	Перегрузка оператора доступа к члену класса ->