Перегрузка операторов c примеры с массивами. Члены и не члены класса. Перегрузка унарных операторов
Во многих языках программирования используются операторы: как минимум, присваивания (= , := или похожие) и арифметические операторы (+ , - , * и /). В большинстве языков со статической типизацией эти операторы привязаны к типам. Например, в Java сложение с оператором + возможно лишь для целых чисел, чисел с плавающей запятой и строк. Если мы определим свои классы для математических объектов, например, для матриц, мы можем реализовать метод их сложения, но вызвать его можно лишь чем-то вроде этого: a = b.add(c) .
В C++ этого ограничения нет - мы можем перегрузить практически любой известный оператор. Возможностей не счесть: можно выбрать любую комбинацию типов операндов, единственным ограничением является необходимость того, чтобы присутствовал как минимум один операнд пользовательского типа. То есть определить новый оператор над встроенными типами или переписать существующий нельзя .
Когда стоит перегружать операторы?
Запомните главное: перегружайте операторы тогда и только тогда, когда это имеет смысл. То есть если смысл перегрузки очевиден и не несёт в себе скрытых сюрпризов. Перегруженные операторы должны действовать так же, как и их базовые версии. Естественно, допустимы исключения, но лишь в тех случаях, когда они сопровождаются понятными объяснениями. Наглядным примером являются операторы << и >> стандартной библиотеки iostream , которые явно ведут себя не как обычные операторы .
Приведём хороший и плохой примеры перегрузки операторов. Вышеупомянутое сложение матриц - наглядный случай. Здесь перегрузка оператора сложения интуитивно понятна и, при корректной реализации, не требует пояснений:
Matrix a, b; Matrix c = a + b;
Примером плохой перегрузки оператора сложения будет сложение двух объектов типа «игрок» в игре. Что имел в виду создатель класса? Каким будет результат? Мы не знаем, что делает операция, и поэтому пользоваться этим оператором опасно.
Как перегружать операторы?
Перегрузка операторов похожа на перегрузку функций с особенными именами. На самом деле, когда компилятор видит выражение, в котором присутствует оператор и пользовательский тип, он заменяет это выражение вызовом соответствующей функции перегруженного оператора. Большая часть их названий начинается с ключевого слова operator , за которым следует обозначение соответствующего оператора. Когда обозначение не состоит из особых символов, например, в случае оператора приведения типа или управления памятью (new , delete и т.д.), слово operator и обозначение оператора должны разделяться пробелом (operator new), в прочих случаях пробелом можно пренебречь (operator+).
Большую часть операторов можно перегрузить как методами класса, так и простыми функциями, но есть несколько исключений. Когда перегруженный оператор является методом класса, тип первого операнда должен быть этим классом (всегда *this), а второй должен быть объявлен в списке параметров. Кроме того, операторы-методы не статичны, за исключением операторов управления памятью.
При перегрузке оператора в методе класса он получает доступ к приватным полям класса, но скрытая конверсия первого аргумента недоступна. Поэтому бинарные функции обычно перегружают в виде свободных функций. Пример:
Class Rational { public: //Constructor can be used for implicit conversion from int: Rational(int numerator, int denominator = 1); Rational operator+(Rational const& rhs) const; }; int main() { Rational a, b, c; int i; a = b + c; //ok, no conversion necessary a = b + i; //ok, implicit conversion of the second argument a = i + c; //ERROR: first argument can not be implicitly converted }
Когда унарные операторы перегружаются в виде свободных функций, им доступна скрытая конверсия аргумента, но этим обычно не пользуются. С другой стороны, это свойство необходимо бинарным операторам. Поэтому основным советом будет следующее:
Реализуйте унарные операторы и бинарные операторы типа “X =” в виде методов класса, а прочие бинарные операторы - в виде свободных функций.
Какие операторы можно перегружать?
Мы можем перегрузить почти любой оператор C++, учитывая следующие исключения и ограничения:
- Нельзя определить новый оператор, например, operator** .
- Следующие операторы перегружать нельзя:
- ?: (тернарный оператор);
- :: (доступ к вложенным именам);
- . (доступ к полям);
- .* (доступ к полям по указателю);
- sizeof , typeid и операторы каста.
- Следующие операторы можно перегрузить только в качестве методов:
- = (присваивание);
- -> (доступ к полям по указателю);
- () (вызов функции);
- (доступ по индексу);
- ->* (доступ к указателю-на-поле по указателю);
- операторы конверсии и управления памятью.
- Количество операндов, порядок выполнения и ассоциативность операторов определяется стандартной версией.
- Как минимум один операнд должен быть пользовательского типа. Typedef не считается.
В следующей части вашему вниманию будут представлены перегружаемые операторы C++, в группах и по отдельности. Для каждого раздела характерна семантика, т.е. ожидаемое поведение. Кроме того, будут показаны типичные способы объявления и реализации операторов.
Как известно, в языке С# тип переменной определяет набор значений, которые она может хранить, а также набор операций, которые можно выполнять над этой переменной. Например, над значением переменной типа int программа может выполнять сложение, вычитание, умножение и деление. С другой стороны, использование оператора “плюс” для сложения двух экземпляров реализованного программистом класса лишено смысла.
Когда в программе определяется класс, то по существу определяется новый тип данных. Тогда язык C# позволяет определить операции, соответствующие этому новому типу данных.
Перегрузка операций состоит в изменении смысла операции при использовании его с определенным классом.
Например, пусть имеется:
myclass a,bc;…//a,b,c-экземпляры класса myclass
c=a+b; //перегруженная операция сложения для класса myclass
Перегрузка операций обычно применяется для классов, описывающих математические или физические понятия, то есть таких классов, для которых требуется выполнить соответствующие операции.
Общий синтаксис объявления перегруженной операции:
[атрибуты] спецификаторы operator тело операции,
Спецификаторы – public,static,extern
operator – ключевое слово, определяющее перегруженную операцию
тело операции-действия, которые выполняются при использовании операции в выражении
Перегружать можно только стандартные операции.
Алгоритм перегрузки операции :
Определить класс, которому данная операция будет назначена.
Для перегрузки операций используется ключевое слово operator .
Переопределяя операцию, необходимо указать метод, который C# вызывает каждый раз, когда класс использует перегруженную операцию. Этот метод, в свою очередь, выполняет соответствующую операцию.
Правила перегрузки операции :
Операция должна быть объявлена как public static
Параметры в операцию должны передаваться по значению (не ref, не out)
Двух одинаковых перегруженных операций в классе не должно быть
Если программа перегружает операцию для определенного класса, то смысл этой операции изменяется только для указанного класса , оставшаяся часть программы будет продолжать использовать эту операцию для выполнения ее стандартных действий.
Перегрузка унарных операций
К унарным операциям, которые можно перегружать в языке С# относятся:
унарные + и –
логическое!,
true, false – обычно перегружаются для типов SQL
Синтаксис объявления перегруженной унарной операции:
public static тип_возвр_знач operator унарная_операция (один параметр),
где параметр – это класс, для которого перегружается данная операция
Например,
public static myclass operator ++(myclass x)
public static int operator +(myclass x)
public static bool operator true(myclass x)
Перегруженная операция возвращает:
унарные + и –, ! величину любого типа
Величину типа класса
true, false – величину типа bool
Префиксные и постфиксные ++ и – не различаются при перегрузке.
Пример перегрузки унарных операций на примере класса
“Одномерный массив ”
public MyArray(int size)
a=new int;
public MyArray(params int mas)
length =mas.length;
a=new int;
for
(int i=0;i public
static MyArray operator ++(MyArray x) //
перегрузка
унарного
оператора
++
MyArray
temp=new MyArray(x.length); for
(int i=0;i temp[i]=++x.a[i];
//попробуйте
temp.a[i]=++x.a[i]
//индексатор,
в случае выхода за рамки массива –
генерируется исключение! public
int this get
{if (i>=0 && i set
{ if (i>=0 && i public
void Print(string name) Console.WriteLine(name+”:”); for
(int i=0;i Console.WriteLine(“\t”+a[i]); Console.WriteLine(); public
void Enter() //в
цикле - ввод элементов массива –
реализуйте сами! //данные
класса – сам массив и его размерность MyArray
a1=new MyArray(5,2,-1,1,-2); a1.Print(“Первый
массив ”); a
1++;
//теперь к экземпляру класса можно
применить операцию ++
a1.Print(“Использование
операции ++ для всех элементов массива
”); MyArray
a2=new MyArray(5); a2.Print(“Второй
массив ”); a
2++;
a2.Print(“Использование
операции ++ для всех элементов массива”); catch
(Exception e) {Console.WriteLine(e.Message);} В любой науке есть стандартные обозначения, которые облегчают понимание идей. Например, в математике это умножение, деление, сложение и прочие символьные обозначения. Выражение (x + y * z) понять куда проще, чем «умножить y, с, z и прибавить к x». Представьте, до XVI века математика не имела символьных обозначений, все выражения прописывались словесно так, будто бы это художественный текст с описанием. А привычные для нас обозначения операций появились и того позже. Значение краткой символьной записи сложно переоценить. Исходя из таких соображений, в языки программирования были добавлены перегрузки операторов. Рассмотрим на примере. Практически как и любой язык, C++ поддерживает множество операторов, работающих с типами данных, встроенными в стандарт языка. Но большинство программ используют пользовательские типы для решения тех или иных задач. Например, комплексная математика или реализуются в программе за счет представления комплексных чисел или матриц в виде пользовательских типов C++. Встроенные операторы не умеют распространять свою работу и совершать необходимые процедуры над пользовательскими классами, какими бы очевидными они не казались. Поэтому для сложения матриц, например, обычно создается отдельная функция. Очевидно, что вызов функции sum_matrix (A, B) в коде будет носить менее ясный характер, чем выражение A + B. Рассмотрим примерный класс комплексных чисел: //представим комплексное число в виде пары чисел с плавающей точкой.
class complex {
double re, im;
public:
complex (double r, double i) :re(r), im(i) {} //конструктор
complex operator+(complex); //перегрузка сложения
complex operator*(complex); //перегрузка умножения
};
void main() {
complex a{ 1, 2 }, b{ 3, 4 }, c{0, 0};
c = a + b;
c = a.operator+(b); ////операторная функция может быть вызвана как любая функция, данная запись эквивалентна a+b
c = a*b + complex(1, 3); //Выполняются обычные правила приоритета операций сложения и умножения
}
Аналогичным образом можно сделать, например, перегрузку операторов ввода/вывода в C++ и приспособить их для вывода таких сложных структур как матрицы. Полный список всех операторов, для которых можно использовать механизм перегрузки: Как видно из таблицы, перегрузка допустима для большинства операторов языка. Необходимости в перегрузке оператора быть не может. Это делается исключительно для удобства. Поэтому перегрузка операторов в Java, например, отсутствует. А теперь о следующем важном моменте. Правым операндом данных операторов является имя, а не значение. Поэтому разрешение их перегрузки могло бы привести к написанию множества неоднозначных конструкций и сильно усложнило бы жизнь программистов. Хотя есть множество языков программирования, в которых допускается перегрузка всех операторов - например, перегрузка Ограничения перегрузки операторов: Бинарный оператор определяется как функция-член с одной переменной или как функция с двумя переменными. Для любого бинарного оператора @ в выражение a@b, @ справедливы конструкции: a.operator@(b) или operator@(a, b). Рассмотрим на примере класса комплексных чисел определение операций как членов класса и вспомогательных. Class complex {
double re, im;
public:
complex& operator+=(complex z);
complex& operator*=(complex z);
};
//вспомогательные функции
complex operator+(complex z1, complex z2);
complex operator+(complex z, double a);
Какой из операторов будет выбран, и будет ли вообще выбран, определяется внутренними механизмами языка, о которых речь пойдет ниже. Обычно это происходит по соответствию типов. Выбор, описывать функцию как член класса или вне его - дело, в общем-то, вкуса. В примере выше принцип отбора был следующий: если операция изменяет левый операнд (например, a + = b), то записать ее внутри класса и использовать передачу переменной по адресу, для ее непосредственного изменения; если операция ничего не меняет и просто возвращает новое значение (например, a + b) - вынести за рамки определения класса. Определение перегрузки унарных операторов в C++ происходит аналогичным образом, с той разницей, что они делятся на два вида: Точно так же, как и с бинарными операторами для случая, когда объявление оператора находится и в классе, и вне класса, выбор будет осуществляться механизмами C++. Пусть бинарный оператор @ применяется к объектам x из класса X и y из класса Y. Правила для разрешения x@y будут следующие: В случае если в 1-4 было найдено несколько объявлений оператора operator@, выбор будет осуществляться по правилам разрешения перегруженных функций. Поиск объявлений унарных операторов происходит точно таким же способом. Теперь построим класс комплексных чисел более подробным образом, чтобы продемонстрировать ряд озвученных ранее правил. Class complex {
double re, im;
public:
complex& operator+=(complex z) { //работает с выражениями вида z1 += z2
re += z.re;
im += z.im;
return *this;
}
complex& operator+=(double a) { //работает с выражениями вида z1 += 5;
re += a;
return *this;
}
complex (): re(0), im(0) {} //конструктор для инициализации по умолчанию. Таким образом, все объявленные комплексные числа будут иметь начальные значения (0, 0)
complex (double r): re(r), im(0) {} // конструктор делает возможным выражение вида complex z = 11; эквивалентная запись z = complex(11);
complex (double r, double i): re(r), im(i) {} //конструктор
};
complex operator+(complex z1, complex z2) { //работает с выражениями вида z1 + z2
complex res = z1;
return res += z2; //использование оператора, определенного как функция-член
}
complex operator+(complex z, double a) { //обрабатывает выражения вида z+2
complex res = z;
return res += a;
}
complex operator+(double a, complex z) { //обрабатывает выражения вида 7+z
complex res = z;
return res += a;
}
//…
Как видно из кода, перегрузка операторов имеет весьма сложный механизм, который может сильно разрастись. Однако такой детальный подход позволяет осуществлять перегрузку даже для очень сложных структур данных. Например, перегрузка операторов C++ в классе шаблонов. Подобное создание функций для всех и вся может быть утомительным и приводить к ошибкам. Например, если добавить третий тип в рассмотренные функции, то нужно будет рассмотреть операции из соображений сочетания трех типов. Придется написать 3 функции с одним аргументом, 9 - с двумя и 27 - с тремя. Поэтому в ряде случаев реализация всех этих функций и значительное уменьшение их количества могут быть достигнуты за счет использования преобразования типов. Оператор индексации«» должен всегда определяться как член класса, так как сводит поведение объекта к массиву. При этом аргумент индексирования может быть любого типа, что позволяет создавать, например, ассоциативные массивы. Оператор вызова функции «()» может рассматриваться как бинарная операция. Например, в конструкции «выражение(список выражений)» левым операндом бинарной операции () будет «выражение», а правым - список выражений. Функция operator()() должна быть членом класса. Оператор последовательности «,» (запятая) вызывается для объектов, если рядом с ними есть запятая. Однако в перечислении аргументов функции оператор не участвует. Оператор разыменования «->» также должен определяться в качестве члена функции. По своему смыслу его можно определить как унарный постфиксный оператор. При этом он в обязательном порядке должен возвращать либо ссылку, либо указатель, позволяющий обращаться к объекту. Также определяется только в качестве члена класса из-за его связи с левым операндом. Операторы присваивания «=», адреса «&» и последовательности «,» должны определяться в блоке public. Перегрузка
операторов помогает реализовать один из ключевых аспектов ООП о полиморфизме. Но важно понимать, что перегрузка - это не более чем иной способ вызова функций. Задача перегрузки операторов часто заключается в улучшении понимания кода, нежели в обеспечении выигрыша в каких-то вопросах. И это еще не все. Также следует учитывать, что перегрузка операторов представляет собой сложный механизм с множеством подводных камней. Поэтому очень легко допустить ошибку. Это является основной причиной, по которой большинство программистов советуют воздержаться от использования перегрузки операторов и прибегать к ней только в крайнем случае и с полной уверенностью в своих действиях. Иногда хочется проявить творчество и облегчить программный код для себя и для других. Для себя написание, для других понимание. Скажем, если в нашей программе часто встречается функция добавления одной строки в конец другой, конечно, можно это реализовать разными способами. А если мы, в каком-то участке нашего кода, напишем, к примеру так: Char str1 = "Hello ";
char str2 = "world!";
str1 + str2;
и в результате получим строку «Hello world!». Правда, было бы замечательно? Ну так пожалуйста! Сегодня вы научитесь «объяснять» компьютеру, что оператором + вы хотите сложить не два числа, а две строки. И работа со строками — это один из самых удачных, на мой взгляд, примеров, чтобы начать разбираться с темой «Перегрузка операторов». Приступим к практике. В этом примере мы перегрузим оператор + и заставим его к одной строке дописывать содержимое другой строки. А именно: мы соберем из четырех отдельных строк часть известного всем нам стиха А.С.Пушкина. Советую открыть вашу среду разработки и переписать этот пример. Если вам не все будет понятно в коде, не волнуйтесь, ниже будут приведены подробные объяснения.
#include Разберемся: Что-то новое в коде мы увидели в строке 16
void operator +(char*); Тут мы объявили прототип метода класса в котором перегрузим наш оператор + . Чтобы перегрузить оператор необходимо использовать зарезервированное слово operator . Выглядит это так, словно вы определяете обычную функцию: void operator+ () {//код} В теле этой функции мы размещаем код, который покажет компилятору, какие действия будет выполнять оператор + (или какой-либо другой оператор). Перегруженный оператор будет выполнять указанные для него действия только в пределах того класса, в котором он определен. Ниже, в строках 20 — 23
мы уже определяем какую роль будет играть + в нашем классе. А именно, с помощью функции strcat (str, s); он будет дописывать содержимое строки s , которую мы передали по указателю, в конец строки str . Строки 17, 25 — 28
это обычный метод класса, с помощью которого строка класса будет показана на экран. Если вам не понятно, как определять методы класса вне тела класса, т.е. такой момент как void StringsWork::getStr() {//определение} , то вам сначала желательно сходить сюда . Далее, уже в главной функции main() , в строках 34 — 37
,создаем четыре указателя на строки и выделяем необходимое количество памяти для каждой из них, не забывая о том, что для символа "\0" так же надо зарезервировать одну ячейку char *str1 = new char ; . Затем копируем в них текст с помощью функции strcpy() и показываем их на экран — строки 39 — 47
. А в строке 49
создаем объект класса. При его создании сработает конструктор класса и строка класса будет очищена от лишних данных. Теперь нам остается только сложить строки в правильной последовательности, используя перегруженный оператор + — строки 50 — 53
и посмотреть, что получилось — строка 58
. Результат работы программы: 1) У лукоморья дуб зелёный; ======================================== У лукоморья дуб зелёный; a = 5 Ограничения перегрузки операторов
. точка (выбор элемента класса);
* звездочка (определение или разыменование указателя);
:: двойное двоеточие (область видимости метода);
?: знак вопроса с двоеточием (тернарный оператор сравнения);
# диез (символ препроцессора);
## двойной диез (символ препроцессора);
sizeof оператор нахождения размера объекта в байтах;
Не забывайте, что в программировании очень желательно, делать все возможное, чтобы ваш код был как можно более понятным. Этот принцип касается всего: названий, которые вы даете переменным, функциям, структурам, классам, также и тех действий, которые будет выполнять перегруженный оператор. Старайтесь определять эти действия, как можно ближе к логическому значению операторов. Например + для сложения строк или других объектов класса, - для удаления строки и т.д. Нельзя не отметить, что многие программисты негативно относятся к перегрузке операторов. Сама возможность перегрузки операторов предоставлена для облегчения понимания и читаемости кода программ. В то же время, она наоборот может стать и причиной усложнения вашей программы и многим программистам будет тяжело ее понять. Помните о «золотой середине» и используйте перегрузку только тогда, когда она реально принесет пользу вам и другим. Вполне можно обойтись и без перегрузки операторов. Но это не значит, что можно проигнорировать данную тему. В ней следует разобраться хотя бы потому, что вам когда-то придется столкнуться с перегрузкой в чужом коде и вы сможете легко разобраться что к чему. Вот мы очень коротко ознакомились с перегрузкой операторов в С++. Увидели, так сказать, вершину айсберга. А вашим домашним заданием (ДА-ДА — ДОМАШНИМ ЗАДАНИЕМ!) будет доработать программу, добавив в нее перегрузку оператора для удаления строки. Какой оператор перегружать выберите сами. Либо предложите свой вариант апгрейда кода, добавив в него то, что посчитаете нужным и интересным. Ваши «труды» можете добавлять в комментарии к этой статье. Нам интересно будет посмотреть ваши варианты решения. Удачи! Сегодня мы познакомимся с замечательной возможностью нашего любомого языка C++ - перегрузкой операций. Но сначала разберёмся, для чего это нужно. С базовыми типами вы можете использовать любые операции: +, -, *, ++, = и многие другие. Например: код на языке c++
class Counter
{
public:
int counter;
Counter() : c(0) {}
};
Counter a,b,c;
a.counter = 2;
b.counter = 3;
c = a + b; Здесь компилятор выдаст ошибку на последней строке: он не знает как именно нужно действовать при использовании операций = и + над объектами класса Counter. Можно решить данную проблему вот так: код на языке c++
class Counter
{
public:
int counter;
Counter() : count(0) {}
void AddCounters (Counter& a, Counter& b)
{
counter = a.counter + b.counter;
}
};
Counter a,b,c;
a.counter = 2;
b.counter = 3;
c.AddCounters(a,b); Согласитесь, использование операции + и = в данном случае сделало бы программу более понятной. Так вот, чтобы использовать стандартные операции C++ с классами, эти операции нужно перегрузить (overload). Перегрузка унарных операций
Начнём с простых операций - унарных. Прежде всего нас интересует инкремент. При использовании данной операции над базовыми типами, к переменной можно прибавить или отнять единицу: код на языке c++
int a=1;
++a; // a = 2;
--a; // a = 1; Теперь научим класс Counter использовать преинкремент (предекремент): код на языке c++
class Counter
{
private:
counter;
public:
Counter() : counter(0) {}
void operator++ ()
{
counter += 1; // Можно также counter++ или ++counter -
// это не имеет значения в данном случае.
}
};
Counter a;
++a;
++a;
++a; Этот код работает. При использовании операции ++ (важно чтобы этот знак находился до идентификатора!) над объектом класса Counter, происходит увеличение переменной counter объекта a. В данном примере мы перегрузили операцию ++. Делается это созданием метода внутри класса. Единственной важной особенностью данного метода - имя идентификатора. Имя идентификатора для перегруженных операций состоит из ключевого слова operator и названия операции. Во всём остальном этот метод определяется как и любые другие. Использовать перегруженные операции с пользовательскими типами очень просто - так же как и с обычными типами данных. Перегрузка постфиксных операций
Примеры постфиксной операции: код на языке c++
public:
void operator++ ()
{
counter += 1;
}
void operator++ (int)
{
counter += 1;
} Единственным отличием префиксной операции от постфиксной - ключевое слово int в списке аргументов. Но int - это не аргумент! Это слово говорит, что перегружается постфиксная операция. Теперь операцию ++ можно использовать как перед идентификатором объекта, так и после: Перегрузка бинарных операций
Перегрузка операций с двумя аргументами очень похожа на перегрузку бинарных операций: код на языке c++
Counter operator+ (Counter t)
{
Counter summ;
summ.counter = counter + t.counter;
return summ;
}
Counter c1,c2,c3;
c1.counter = 3;
c2.counter = 2;
c3 = c1 + c2; Какая переменная вызовет функцию operator+? В перегруженных бинарных операциях всегда вызывается метод левого операнда. В данном случае метод operator+ вызывает объект c1. В метод мы передаём аргумент. Аргументом всегда является правый операнд. Кроме того, в данном случае операция + должна вернуть какой-то результат, чтобы присвоить его объекту c3. Мы возвращаем объект Counter. Возвращаемое значение присваивается переменной c3. Заметьте, мы перегрузили операцию +, но не перегружали операцию =! Конечно же нужно добавить этот метод к классу Counter: код на языке c++
Counter operator= (Counter t)
{
Counter assign;
counter = t.counter;
assign.counter = t.counter;
return assign;
} Внутри метода мы создали дополнительную переменную assign. Данная переменная используется, чтобы можно было работать вот с таким кодом: Counter c1(5),c2,c3;Пример перегрузки операторов
Операторы, доступные для перегрузки
Операторы, перегрузка которых запрещена
Ограничения
Интерпретации бинарных и унарных операторов.
Правила выбора оператора
Уточненное определение класса complex
Особые операторы
Итог
2) Всё ходит по цепи кругом;
3) И днём и ночью кот учёный
4) Златая цепь на дубе том:
Стих, после правильного сложения строк:
Златая цепь на дубе том:
И днём и ночью кот учёный
Всё ходит по цепи кругом;
========================================
b = 5
c = 5 + 5 = 10
int a=2,b=3,c;
c = a + b;
Здесь над переменными типа int сначала выполняется операция +, а затем результат присваивается переменной c с помощью операции =. Над классами такое проделать не получится. Создадим простой класс:
int a = 3;
a++;
a--;
То есть, здесь знак операции ставится после имени идентификатора. Для использования постфиксных операций с пользовательскими типами данных нужно совсем немного:
Counter a;
++a;
++a;
a++;
a++;
c3 = c2 = c1;
Хотя, для возвращаемого значения можно воспользоваться и более элегантными способами, с которыми мы вскоре познакомимся.
