- •Введение в перегрузку операций
- •Операции, как функции
- •Использование перегруженных операций
- •Ограничения в перегрузке операций
- •Перегрузка операций через дружественные функции
- •Перегрузка операций через дружественные функции
- •Int main () {
- •I have 16 dollars.
- •Int m_dollars;
- •Int getDollars () const {return m_dollars;}
- •Int main () {
- •Дружественные функции могут быть определены внутри класса
- •Int m_dollars;
- •Int getDollars () const {return m_dollars;}
- •Int main () {
- •Перегрузка операций с операндами разных типов
- •Int m_dollars;
- •Int getDollars () {return m_dollars;}
- •Int main () {
- •Values (int min, int max) {
- •Int getMin () {return m_min;}
- •Int getMax () {return m_max;}
- •Int main () {
- •Int main () {
- •Int main () {
- •Перегрузка операций через обычные функции
- •Int m_dollars;
- •Int getDollars () const {return m_dollars;}
- •Int main () {
- •Int m_dollars;
- •Int getDollars () const {return m_dollars;}
- •Int main () {
- •Int m_dollars;
- •Int getDollars () const {return m_dollars;}
- •Int main () {
- •Перегрузка операций ввода и вывода
- •Void print () {
- •Int main () {
- •Int main () {
- •Int main () {
- •Int main () {
- •Int main () {
- •Int m_numerator;
- •Int m_denominator;
- •Void reduce () {
- •Void print () {
- •Перегрузка операций через методы классов
- •Int m_dollars;
- •Int getDollars () { return m_dollars; }
- •Int main () {
- •Int m_dollars;
- •Int getDollars () {return m_dollars;}
- •Int main (){
- •Не всё может быть перегружено через дружественные функции
- •Не всё может быть перегружено через методы класса
- •Int main (){
- •Какой способ перегрузки и когда следует использовать?
- •Int m_dollars;
- •Int getDollars () const {return m_dollars;}
- •Int main () {
- •If (!isHappy)
- •Int main () {
- •If (!something)
- •Перегрузка операций сравнения
- •Int main () {
- •Int m_dollars;
- •Int main () {
- •Перегрузка операторов инкремента и декремента
- •Int m_number;
- •Int main () {
- •Перегрузка операций инкремента и декремента версии постфикс
- •Int m_number;
- •Int main () {
- •Перегрузка операции индексации []
- •Почему оператор индексации [] использует возврат по ссылке?
- •Использование оператора индексации с константными объектами класса
- •Int& operator[] (const int index);
- •Int main (){
- •IntArray array;
- •Проверка ошибок
- •Int m_array[10];
- •Int& operator [] (const int index);
- •Int& IntArray::operator[] (const int index) {
- •Указатели на объекты и перегруженный оператор []
- •Передаваемый аргумент не обязательно должен быть целым числом
- •Void operator [] (std::string index);
- •Void Something::operator [] (std::string index){
- •Int main () {
- •Перегрузка операции ()
- •Int main () {
- •Void operator() ();
- •Void Matrix::operator()() {
- •Int main() {
- •Перегрузка операций преобразования типов данных
- •Int m_dollars;
- •Int getDollars () { return m_dollars; }
- •Int main () {
If (!something)
std::cout << "Something is null.\n";
else
std::cout << "Something is not null.\n";
return 0;
}
Здесь перегруженный оператор НЕ (!) возвращает true, если в
Something используются значения по умолчанию (0.0, 0.0, 0.0). Результат выполнения программы:
Something is null.
Если же задать любые ненулевые значения для объекта класса Something:
Something something (23.11, 37.1, 20.12);
То результатом будет:
Something is not null.
Тест
Реализуйте перегрузку унарного оператора плюс (+) для класса Something.
Перегрузка операций сравнения
Принципы перегрузки операций сравнения те же, что и в перегрузке других операций, которые мы рассматривали выше.
Поскольку все операции сравнения являются бинарными и не изменяют свои левые операнды, то выполнять перегрузку следует через дружественные функции.
Например, перегрузим операцию равенства (==) и операцию неравенства (!=) для класса Car:
#include <iostream>
#include <string>
class Car {
private:
std::string m_company;
std::string m_model;
public:
Car (std::string company, std::string model): m_company(company), m_model(model) {}
friend bool operator== (const Car &c1, const Car &c2);
friend bool operator!= (const Car &c1, const Car &c2);
};
bool operator== (const Car &c1, const Car &c2) {
return (c1.m_company == c2.m_company &&
c1.m_model== c2.m_model);
}
bool operator!= (const Car &c1, const Car &c2) {
return !(c1== c2);
}
Int main () {
Car mustang ("Ford", "Mustang");
Car logan ("Renault", "Logan");
if (mustang == logan)
std::cout << "Mustang and Logan are the same.\n";
if (mustang != logan)
std::cout << "Mustang and Logan are not the same.\n";
return 0;
}
Всё просто. Поскольку результат выполнения операции != является прямо противоположным результату выполнения операции ==, то мы определили оператор!= , используя уже перегруженный оператор == (уменьшив, таким образом, количество кода, сложность и возможность возникновения ошибок).
А как насчет операций (< и >)?
Здесь нужно определиться, чем один объект класса Car может быть лучше другого объекта класса Car, и как это всё выразить в коде.
Не очевидно!
Поэтому здесь мы и не перегружали операции (< и >).
Совет: не перегружайте операторы, которые являются бесполезными для вашего класса.
Однако, операции (< и >) можно использовать для сортировки списка автомобилей (объектов класса Car) в алфавитном порядке, используя члены m_company и m_model, поэтому всегда рассматривайте разные варианты.
Некоторые классы-контейнеры Стандартной библиотеки C++ требуют перегрузки оператора <, чтобы они могли сохранять отсортированные элементы.
Перегрузим операции сравнения >, <, >= и <=:
#include <iostream>
class Dollars {
private:
Int m_dollars;
public:
Dollars (int dollars) {m_dollars = dollars;}
friend bool operator> (const Dollars &d1, const Dollars &d2);
friend bool operator<= (const Dollars &d1, const Dollars &d2);
friend bool operator< (const Dollars &d1, const Dollars &d2);
friend bool operator>= (const Dollars &d1, const Dollars &d2);
};
bool operator> (const Dollars &d1, const Dollars &d2) {
return d1.m_dollars > d2.m_dollars;
}
bool operator>= (const Dollars &d1, const Dollars &d2) {
return d1.m_dollars >= d2.m_dollars;
}
bool operator< (const Dollars &d1, const Dollars &d2) {
return d1.m_dollars < d2.m_dollars;
}
bool operator<= (const Dollars &d1, const Dollars &d2) {
return d1.m_dollars <= d2.m_dollars;
}
