Как перегрузить оператор c
Перейти к содержимому

Как перегрузить оператор c

  • автор:

Перегрузка []

Кроме нескольких вышеперечисленных операторов, можно перегрузить и любые другие операторы С++. Большей частью требуется перегружать стандартные операторы, такие как арифметические, логические или операторы отношения. Тем не менее имеется один достаточно экзотичный опера­тор, который бывает полезно перегружать: []. В С++ оператор [] при перегрузке рассматривается как бинарный оператор. Его следует перегружать с помощью функции-члена. Нельзя использовать дружественную функцию. Общая форма функции-оператора operator[]() имеет следующий вид:

Параметр не обязан иметь тип int, но поскольку функция operator[]() обычно используется для индексации массива, то в таком качестве обычно используется целое значение.
Для заданного объекта О выражение

преобразуется в вызов функции operator[]():

В таком случае значение индекса передается функции operator[]() в качестве явного параметра. Указатель this указывает на объект О, тот самый, который вызывает функцию.

В следующей программе класс atype содержит массив из трех переменных целого типа. Конст­руктор инициализирует каждый элемент массива заданным значением. Перегруженная функция-оператор operator[]() возвращает величину элемента массива, определяемого индексом, передава­емым в качестве параметра.

#include
class atype int a[3];
public:
atype (int i, int j, int k) a[0] = i;
a[1] = j;
a[2] = k;
>
int operator[] (int i) < return a[i]; >
>;
int main()
atype ob(1, 2, 3);
cout return 0;
>

Можно создать функцию-оператор operator[]() таким образом, чтобы оператор [] можно было использовать как с левой, так и с правой стороны оператора присваивания. Для этого достаточ­но в качестве возвращаемой величины для operator[]() задать ссылку. Сказанное проиллюстриро­вано в следующей программе:

Поскольку operator[]() возвращает ссылку на элемент массива, отвечающий индексу i, то он может быть использован с левой стороны операции присваивания для модификации элемента массива. Разумеется, этот оператор может быть использован и с правой стороны оператора присваивания.

Как известно, в С++ во время выполнения программы можно выйти за пределы массива, и при этом не будет выдаваться сообщение об ошибке. Одним из достоинств перегрузки оператора [] служит то, что с его помощью можно предотвратить подобные эффекты.

Если создается класс, содержащий массив, и разрешен доступ к этому массиву только через перегруженный оператор [], то можно перехватывать значение, содержащее величину индекса за пределами допустимых значений. Например, следующая программа осуществляет проверку на принадлежность значений допустимой области:

// пример безопасного массива
#include
#include
class atype int a[3];
public:
atype (int i, int j, int k) a[0] = i;
a[1] = j;
a[2] = k;
>
int &operator[] (int i);
>;
// проверка диапазона для atype.
int &atype::operator [] (int i)
if (i2) cout exit (1);
>
return a[i];
>
int main()
atype ob(1, 2, 3);
cout cout ob[1] = 25; // [] слева
cout ob[3] = 44; // генерируется ошибка времени выполнения, поскольку 3 выходит за допустимые пределы
return 0;
>

При выполнении инструкции

оператор перехватывает ошибку выхода за допустимую область и программа заканчивает свою работу прежде, чем сможет нанести ущерб системе.

Как перегрузить оператор c

Перегрузка операторов (operator overloading) позволяет определить для объектов классов втроенные операторы, такие как +, -, * и т.д. Для определения оператора для объектов своего класса, необходимо определить функцию, название которой содержит слово operator и символ перегружаемого оператора. Функция оператора может быть определена как член класса, либо вне класса.

Перегрузить можно только те операторы, которые уже определены в C++. Создать новые операторы нельзя. Также нельзя изменить количество операндов, их ассоциативность, приоритет.

Если функция оператора определена как отдельная функция и не является членом класса, то количество параметров такой функции совпадает с количеством операндов оператора. Например, у функции, которая представляет унарный оператор, будет один параметр, а у функции, которая представляет бинарный оператор, — два параметра. Если оператор принимает два операнда, то первый операнд передается первому параметру функции, а второй операнд — второму параметру. При этом как минимум один из параметров должен представлять тип класса.

Формальное определение операторов в виде функций-членов класса:

// бинарный оператор ReturnType operator Op(Type right_operand); // унарный оператор ClassType& operator Op();

Формальное определение операторов в виде функций, которые не являются членами класса:

// бинарный оператор ReturnType operator Op(const ClassType& left_operand, Type right_operand); // альтернативное определение, где класс, для которого создается оператор, представляет правый операнд ReturnType operator Op(Type left_operand, const ClassType& right_operand); // унарный оператор ClassType& operator Op(ClassType& obj);

Здесь ClassType представляет тип, для которого определяется оператор. Type — тип другого операнда, который может совпадать, а может и не совпадать с первым. ReturnType — тип возвращаемого результата, который также может совпадать с одним из типов операндов, а может и отличаться. Op — сама операция.

Рассмотрим пример с классом Counter, который хранит некоторое число:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout Counter operator + (const Counter& counter) const < return Counter; > private: int value; >; int main() < Counter c1; Counter c2; Counter c3 = c1 + c2; c3.print(); // Value: 30 >

Здесь в классе Counter определен оператор сложения, цель которого сложить два объекта Counter:

Counter operator + (const Counter& counter) const < return Counter; >

Текущий объект будет представлять левый операнд операции. Объект, который передается в функцию через параметр counter, будет представлять правый операнд операции. Здесь параметр функции определен как константная ссылка, но это необязательно. Также функция оператора определена как константная, но это тоже не обязательно.

Результатом оператора сложения является новый объект Counter, в котором значение value равно сумме значений value обоих операндов.

После опеределения оператора можно складывать два объекта Counter:

Counter c1; Counter c2; Counter c3 ; c3.print(); // Value: 30

Подобным образом можно определить функцию оператора вне класса:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout int value; // к приватным переменным внешняя функция оператора не может обращаться >; // определяем оператор сложения вне класса Counter operator + (const Counter& c1, const Counter& c2) < return Counter; > int main() < Counter c1; Counter c2; Counter c3 ; c3.print(); // Value: 30 >

Если бинарный оператор определяется в виде внешней функции, как здесь, то он принимает два параметра. Первый параметр будет представлять левый операнд операции, а второй параметр — правый операнд.

Но по сравнению с предыдущим кодом здесь сделано еще пару изменений. Во-первых, внешняя функция естественно не может обращаться к приватным полям класса, поэтому для доступа к ним придется создавать отдельные функции, которые бы возвращали значения полей. Я для простоты просто сделал переменную value публичной. Другим решением в данном случае могло быть определение дружественной функции оператора. Второй момент — внешние функции оператора не могут быть константными. Поэтому гораздо определение операторов внутри класса имеет некоторые преимущества.

Стоит отметить, что необязательно возвращать объект класса. Это может быть и любой объект в зависимости от ситуации. И также мы можем определять дополнительные перегруженные функции операторов:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout Counter operator + (const Counter& counter) const < return Counter; > int operator + (int number) const < return value + number; >private: int value; >; int main() < Counter counter; int number = counter + 30; std::cout 

Здесь определена вторая версия оператора сложения, которая складывает объект Counter с числом и возвращает также число. Поэтому левый операнд операции должен представлять тип Counter, а правый операнд - тип int.

Какие операторы где переопределять? Операторы присвоения, индексирования ([]), вызова (()), доступа к члену класса по указателю (->) следует определять в виде функций-членов класса. Операторы, которые изменяют состояние объекта или непосредственно связаны с объектом (инкремент, декремент), обычно также определяются в виде функций-членов класса. Операторы выделения и удаления памяти ( new new[] delete delete[] ) определяются только в виде функций, которые не являются членами класса. Все остальные операторы можно определять как отдельные функции, а не члены класса.

Операторы сравнения

Результатом операторов сравнения ( == , != , < , >), как правило, является значение типа bool . Например, перегрузим данные операторы для типа Counter:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout bool operator == (const Counter& counter) const < return value == counter.value; >bool operator != (const Counter& counter) const < return value != counter.value; >bool operator > (const Counter& counter) const < return value >counter.value; > bool operator < (const Counter& counter) const < return value < counter.value; >private: int value; >; int main() < Counter c1(20); Counter c2(10); bool b1 = c1 == c2; // false bool b2 = c1 >c2; // true std::cout c2 b">default:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout bool operator == (const Counter& counter) const = default; bool operator != (const Counter& counter) const = default; private: int value; >; int main() < Counter c1(20); Counter c2(10); bool b1 = c1 == c2; // false bool b2 = c1 != c2; // true std::cout bool operator == (const Counter& counter) const = default;

По умолчанию будут сравниваться все поля класса, для которых определен оператор ==. Если значения всех полей будут равны, то оператор возвратить true

Операторы присвоения

Оператор присвоения обычно возвращает ссылку на свой левый операнд:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout // оператор присвоения Counter& operator += (const Counter& counter) < value += counter.value; return *this; // возвращаем ссылку на текущий объект >private: int value; >; int main() < Counter c1; Counter c2; c1 += c2; c1.print(); // Value: 70 >

Унарные операции

Унарные операции обычно возвращают новый объект, созданный на основе имеющегося. Например, возьмем операцию унарного минуса:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout // оператор унарного минуса Counter operator - () const < return Counter; > private: int value; >; int main() < Counter c1; Counter c2 = -c1; // применяем оператор унарного минуса c2.print(); // Value: -20 >

Здесь операция унарного минуса возвращает новый объект Counter, значение value в котором фактически равно значению value текущего объекта, умноженного на -1.

Операции инкремента и декремента

Особую сложность может представлять переопределение операций инкремента и декремента, поскольку нам надо определить и префиксную, и постфиксную форму для этих операторов. Определим подобные операторы для типа Counter:

#include class Counter < public: Counter(int val) < value =val; >void print() < std::cout // префиксные операторы Counter& operator++ () < value += 1; return *this; >Counter& operator-- () < value -= 1; return *this; >// постфиксные операторы Counter operator++ (int) < Counter copy ; ++(*this); return copy; > Counter operator-- (int) < Counter copy ; --(*this); return copy; > private: int value; >; int main() < Counter c1; Counter c2 = c1++; c2.print(); // Value: 20 c1.print(); // Value: 21 --c1; c1.print(); // Value: 20 >

Префиксные операторы должны возвращать ссылку на текущий объект, который можно получить с помощью указателя this:

Counter& operator++ ()

В самой функции можно определить некоторую логику по инкременту значения. В данном случае значение value увеличивается на 1.

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

Counter operator++ (int) < Counter copy ; ++(*this); return copy; >

Чтобы постфиксная форма отличалась от префиксной постфиксные версии получают дополнительный параметр типа int, который не используется. Хотя в принципе мы можем его использовать.

Переопределение оператора

#include class Counter < public: Counter(int val) < value =val; >int getValue()const private: int value; >; std::ostream& operator <<(std::ostream& stream, const Counter& counter) < stream << "Value: "; stream << counter.getValue(); return stream; >int main() < Counter counter1; Counter counter2; std::cout 

Стандартный выходной поток cout имеет тип std::ostream . Поэтому первый параметр (левый операнд) представляет объект ostream , а второй (правый операнд) - выводимый объект Counter. Поскольку мы не можем изменить стандартное определение std::ostream, поэтому определяем функцию оператора, которая не является членом класса.

std::ostream& operator

В данном случае для выводим значение переменной value. Для получения значения value извне класса Counter я добавил функцию getValue() .

Возвращаемое значение всегда должно быть ссылкой на тот же объект потока, на который ссылается левый операнд оператора.

После определения функции оператора можно выводить на консоль объекты Counter:

Counter counter1; std::cout 

Выражение одних операторов через другие

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

#include class Counter < public: Counter(int n) < value = n; >void print() const < std::cout Counter& operator+=(const Counter& counter) < value += counter.value; return *this; >; Counter& operator+(const Counter& counter) < Counter copy< value >; // копируем данные текущего объекта return copy += counter; >; private: int value; >; int main() < Counter counter1; Counter counter2; counter1 += counter2; counter1.print(); // value: 30 Counter counter3 ; counter3.print(); // value: 40 >

Здесь вначале реализован оператор сложения с присвоением +=:

Counter& operator+=(const Counter& counter) < value += counter.value; return *this; >;

В функции оператора сложения мы создаем копию текущего объекта и к этой копии и аргументу применяем оператор +=:

Counter& operator+(const Counter& counter) < Counter copy< value >; // копируем данные текущего объекта return copy += counter; >;

В данном случае суть сложения: к полю value прибавляем значение value другого объекта. Однако логика оператора может быть более сложной, и чтобы не повторяться, мы можем таким образом выражать одни операторы через другие.

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

Перегрузка операторов в языке C++ позволяет переопределить действия операторов языка для работы с различными (в том числе и пользовательскими) типами, например такими как классы.

При обработке выражения, содержащего оператор, компилятор использует следующий алгоритм:

  • Если все операнды являются фундаментальных типов данных, то вызывать следует встроенные соответствующие версии операторов (если таковые существуют). Если таковых не существует, то компилятор выдаст ошибку.
  • Если какой-либо из операндов является пользовательского типа данных (например, объект класса или перечисление), то компилятор будет искать версию оператора, которая работает с таким типом данных. Если компилятор не найдет ничего подходящего, то попытается выполнить конвертацию одного или нескольких операндов пользовательского типа данных в фундаментальные типы данных, чтобы таким образом он мог использовать соответствующий встроенный оператор. Если это не сработает — компилятор выдаст ошибку.

Перегрузить можно только те операторы, которые уже определены в C++. Создать новые операторы нельзя.

Также нельзя изменить количество операндов, их ассоциативность и приоритет.

Операторы, которые перегружать нельзя:

  • тернарный оператор ( ? : )
  • оператор sizeof
  • оператор разрешения области видимости ( :: )
  • оператор выбора члена класса "."
  • оператор разыменования указателя на член класса ".*"

Синтаксис перегрузки операторов очень похож на определение функции с именем operator@, где @ — это идентификатор оператора (например +, -, ==).

bool operator==(const MyClass& v1, const MyClass& v2)

В большинстве случаев, операторы (кроме условных) возвращают объект, или ссылку на тип, к которому относятся его аргументы.

Существует три основных способа перегрузки операторов:

  • через обычные функции
  • через функции дружественные для класса
  • через методы класса.

Перегрузка через обычные функции

Для перегрузки оператора через обычную функцию достаточно объявить эту функцию вне тела класса.

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

class MyVal < int m_val; public: MyVal(int val) < m_val = val; >int getVal() < return m_val; >>; MyVal operator+(MyVal& v1, MyVal& v2) < return MyVal(v1.getVal() + v2.getVal()); >MyVal val1(10), val2(20); std::cout 

Используйте перегрузку операторов через обычные функции, вместо дружественных, если для этого не требуется добавление дополнительных геттеров в класс.

Перегрузка через дружественные функции

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

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

class MyVal < int m_val; public: MyVal(int val) < m_val = val; >int getVal() < return m_val; >friend MyVal operator+(MyVal& v1, MyVal& v2); >; MyVal operator+(MyVal v1, MyVal v2) < return MyVal(v1.m_val + v2.m_val); >MyVal val1(10), val2(20); std::cout 

Если необходимо, дружественные функции могут быть определены внутри класса.

class MyVal < int m_val; public: MyVal(int val) < m_val = val; >int getVal() < return m_val; >friend MyVal operator+(MyVal& v1, MyVal& v2) < return MyVal(v1.m_val + v2.m_val); >>; MyVal val1(10), val2(20); std::cout 

Перегрузка через методы класса

При перегрузке через методы класса у функции-метода вместо первого операнда будет неявный параметр - указатель на объект класса.

class MyVal < int m_val; public: MyVal(int val) < m_val = val; >int getVal() < return m_val; >MyVal operator+(MyVal& v); >; MyVal MyVal::operator+(MyVal& v) < return MyVal(m_val + v.m_val); >MyVal val1(10), val2(20); std::cout 

Дополнительная информация

Операторы могут работать с операндами разных типов. В этом случае нужно писать две функции для перегрузки оператора - первая для случая (Type1, Type2) и вторая для случая (Type2, Type1), так как разный порядок типов может давать разный результат.

Операторы присваивания (=), индекса ([]), вызова функции (()), и выбора члена (->) могут перегружаться только через методы класса.

Перегрузка операторов через методы класса не используются, если первый операнд не является классом (например int), или это класс, который нельзя изменять (например std::ostream). Соответственно не получится через методы класса переопределить оператор , так как первый его операнд - специальный класс std::ostream.

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

Для удобного вывода сложных структур в поток вывода можно использовать перегрузку оператора вывода .

class MyCoord < int m_x; int m_y; int m_z; public: MyCoord(int x, int y, int z) < m_x = x, m_y = y, m_z = z; >friend std::ostream& operator<<(std::ostream& out, MyCoord& point); >; std::ostream& operator <<(std::ostream& out, MyCoord& v) < out << "Coord(" << v.m_x << "," << v.m_y << "," << v.m_z << ")"; return out; >MyCoord val(10, 20, 30); std::cout 

Так же можно перегрузить и оператор ввода, используя std::istream вместо std::ostream.

Перегрузка унарных операторов

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

class MyVal < int m_val; public: MyVal(int val) < m_val = val; >int getVal() < return m_val; >MyVal operator-() const; >; MyVal MyVal::operator-() const < return MyVal(-m_val); >MyVal val1(10); MyVal val2 = -val1; std::cout 

Также, поскольку объект класса не меняется, а возвращается новый экземпляр класса, метод следует объявлять константным.

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

У операторов инкремента (++) и декремента (--) существует две версии - префиксная и постфиксная. Чтобы при перегрузке операторов различать эти версии у постфиксной версии введен фиктивный параметр типа int. При его наличии компилятор понимает, что происходит перегрузка постфиксной версии оператора. При его отсутствии - префиксной.

class MyVal < int m_val; public: MyVal(int val) < m_val = val; >int getVal() < return m_val; >MyVal& operator++(); // Префиксная версия MyVal operator++(int); // Постфиксная версия friend std::ostream& operator<<(std::ostream &out, const MyVal &v); >; std::ostream& operator MyVal& MyVal::operator++() // Префиксная версия < ++m_val; return *this; >MyVal MyVal::operator++(int) // Постфиксная версия < MyVal tmp(m_val); ++(*this); return tmp; >MyVal val(10); std::cout 

Операторы префиксной версии возвращают объект после того, как он был увеличен или уменьшен. В постфиксной версии нам нужно возвращать объект до того, как он будет увеличен или уменьшен. Из-за этого в постфиксной версии используется временный объект для возврата значения до его изменения.

Также из-за этого при возврате невозможно использовать ссылку, так как временный объект будет уничтожен при выходе из функции. Поэтому в постфиксной версии возвращаемое значение - объект класса, что дает меньшую эффективность.

Перегрузка оператора индексации

class MyArr < int m_arr[10]; public: int& operator[](const int index); >; int& MyArr::operator[](const int index) < assert(index >= 0 && index < 10); return m_arr[index]; >MyArr arr; arr[0] = 10; arr[1] = 20; std::cout 

Для константных объектов, когда нельзя изменять их содержимое можно использовать константную версию функции.

class MyArr < int m_arr[10] = ; public: int& operator[](const int index); const int& operator[](const int index) const; >; int& MyArr::operator[](const int index) < assert(index >= 0 && index < 10); return m_arr[index]; >const int& MyArr::operator[](const int index) const < assert(index >= 0 && index < 10); return m_arr[index]; >MyArr arr1; arr1[0] = 10; const MyArr arr2; // arr[0] = 20; - Ошибка! Нельзя по константной ссылке присваивать значение std::cout 

Также при перегрузке оператора индексации можно использовать проверку передаваемого индекса на корректность.

В качестве индекса может использоваться как целое число, так и любой другой тип данных, например double, string и т.п..

Перегрузка оператора ()

Перегрузка оператора ( ) позволяет задать произвольные тип и количество параметров при вызове оператора ( ).

class Matrix < int m_data[5][5] = ; public: int& operator()(int row, int col); const int& operator()(int row, int col) const; void operator()(); >; int& Matrix::operator()(int row, int col) < assert(row >= 0 && row < 5); assert(col >= 0 && col < 5); return m_data[row][col]; >const int& Matrix::operator()(int row, int col) const < assert(row >= 0 && row < 5); assert(col >= 0 && col < 5); return m_data[row][col]; >void Matrix::operator()() < for (int row = 0; row < 5; ++row) for (int col = 0; col < 5; ++col) m_data[row][col] = 55; >Matrix m1; m1(0, 0) = 10; const Matrix m2; std::cout 

Перегрузка операторов преобразования типов

class MyVal < int m_val = 0; public: MyVal(int v) < m_val = v; >operator int(); >; MyVal::operator int() < return m_val; >MyVal v(10); std::cout 

Также можно перегружать преобразование в свои типы данных.

class MyVal < public: int m_val = 0; MyVal(int v) < m_val = v; >>; class MyClass < int m_val = 100; public: operator MyVal(); >; MyClass::operator MyVal() < return MyVal(m_val); >MyClass val; MyVal v = (MyVal)val; std::cout 

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

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

Синтаксис

type operator operator-symbol(parameter-list)

Замечания

Функцию большинства встроенных операторов можно переопределить глобально или для отдельных классов. Перегруженные операторы реализуются в виде функции.

Имя перегруженного оператора — operator x, где x — оператор, как показано в следующей таблице. Например, чтобы перегрузить оператор сложения, необходимо определить функцию с именем operator+. Аналогичным образом, чтобы перегрузить оператор добавления или назначения, +=определите функцию, называемую оператором +=.

Переопределяемые операторы

Оператор Имя. Тип
, Comma Binary
! Логическое НЕ Унарный
!= Неравенство Binary
% Модуль Binary
%= Назначение модуля Binary
& Побитовое И Binary
& Взятие адреса Унарный
&& Логическое И Binary
&= Назначение побитового И Binary
( ) Вызов функции
( ) Оператор приведения Унарный
* Умножение Binary
* Разыменование указателя Унарный
*= Присваивание умножения Binary
+ Дополнение Binary
+ Унарный плюс Унарный
++ Добавочный 1 Унарный
+= Присваивание сложения Binary
- Вычитание Binary
- Унарное отрицание Унарный
-- Декремент 1 Унарный
-= Присваивание вычитания Binary
-> Выбор члена Binary
->* Выбор указателя на член Binary
/ Подразделение Binary
/= Присваивание деления Binary
Меньше Binary
< Сдвиг влево Binary
Сдвиг влево и присваивание Binary
Меньше или равно Binary
= Передача прав и обязанностей Binary
== Equality Binary
> Больше Binary
>= Больше или равно Binary
>> Сдвиг вправо Binary
>>= Сдвиг вправо и присваивание Binary
[ ] Индекс массива
^ Исключающее ИЛИ Binary
^= Исключающее ИЛИ/присваивание Binary
| Побитовое ИЛИ Binary
|= Назначение побитового включающего ИЛИ Binary
|| Логическое ИЛИ Binary
~ Дополнение до единицы Унарный
delete DELETE
new Новый
операторы преобразования операторы преобразования Унарный

1 Две версии унарных операторов добавочного и декремента существуют: preincrement и postincrement.

Дополнительные сведения см . в общих правилах перегрузки операторов. Ограничения для разных категорий перегруженных операторов описываются в следующих разделах.

  • Унарные операторы
  • Бинарные операторы
  • Передача прав и обязанностей
  • Вызов функции
  • Индексация
  • Доступ к члену класса
  • Добавочный и декремент.
  • Пользовательские преобразования типов

Операторы, перечисленные в следующей таблице, не могут быть перегружены. Таблица содержит символы # препроцессора и ##.

Непереопределяемые операторы

Оператор Имя.
. Выбор члена
.* Выбор указателя на член
:: Разрешение области
? : Условный
# Препроцессор: преобразование в строку
## Препроцессор: конкатенация

Хотя перегруженные операторы обычно называются компилятором неявным образом при их появлении в коде, их можно вызывать и явным образом — точно так же, как и любую функцию-член или функцию, не являющуюся членом.

Point pt; pt.operator+( 3 ); // Call addition operator to add 3 to pt. 

Пример

В следующем примере оператор перегружает + два сложных числа и возвращает результат.

// operator_overloading.cpp // compile with: /EHsc #include using namespace std; struct Complex < Complex( double r, double i ) : re(r), im(i) <>Complex operator+( Complex &other ); void Display( ) < cout private: double re, im; >; // Operator overloaded using a member function Complex Complex::operator+( Complex &other ) < return Complex( re + other.re, im + other.im ); >int main()
6.8, 11.2 

В этом разделе

  • Общие правила перегрузки операторов
  • Перегрузка унарных операторов
  • Бинарные операторы
  • Передача прав и обязанностей
  • Вызов функции
  • Индексация
  • Доступ к членам

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *