Здравствуйте,
У страуструпа 3 издания в 11.2.1 рассматриваются правила объявления операторорв.

Вопрос.

class X{
public:
void operator+ (int); // определен Старуструпом как бинарный
}
...
class X{
public:
X operator++ (int); // определен Старуструпом как унарный
}

Так как их отличать — по возвращаемому типу?..
Не получается, т. к. уже дальше в 11.3.2
class complex{
public:
complex& operator+= (complex a) // интерпретируется Страуструпом как бинарный

Короче, запутался я совсем, помогите пожалуста разобраться...

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте,
А>У страуструпа 3 издания в 11.2.1 рассматриваются правила объявления операторорв.

А>Вопрос.

А>class X{
А>public:
А>void operator+ (int); // определен Старуструпом как бинарный
А>}
А>...
А>class X{
А>public:
А>X operator++ (int); // определен Старуструпом как унарный
А>}

А>Так как их отличать — по возвращаемому типу?..

Какие операторы могут быть бинарными, а какие не могут, жестко зафиксировано в языке. Во втором случае у тебя объявляется пользовательский оператор '++'. Оператор '++' всегда унарный, в смысле что имеет только один операнд, и "отличать" тут собственно нечего. Объявление с фиктивным параметром типа 'int' — это просто такое соглашение для объявления постфиксного '++' (без параметра был бы префиксный).

А вот для тех операторов, которые могут быть и бинарными и унарными, все решается числом параметров в объявлении, не забывая считать "невидимый" (подразумеваемый) параметр 'this' для методов объектов. В первом случае у тебя объявлен оператор '+' с двумя параметрами — подразумеваемый 'X* this' и явный 'int' — поэтому это бинарный оператор.

А>Не получается, т. к. уже дальше в 11.3.2
А>class complex{
А>public:
А>complex& operator+= (complex a) // интерпретируется Страуструпом как бинарный

Оператор '+=' всегда бинарный. В данном случае у него два параметра — неявный 'complex* this' и явный 'complex a' — как и должно быть.

Здравствуйте, Андрей Тарасевич, Вы писали:

Спасибо за ответ!

АТ>Какие операторы могут быть бинарными, а какие не могут, жестко зафиксировано в языке. Оператор '++' всегда унарный

А если вдруг у Страуструп под рукой и если не трудно — не могли бы подсказать — где у него так сказано по поводу ++? Я не придираюсь , просто интересно, т. к. пытаюсь читать вроде всё внимательно...

АТ>А вот для тех операторов, которые могут быть и бинарными и унарными, все решается числом параметров в объявлении, не забывая считать "невидимый" (подразумеваемый) параметр 'this' для методов объектов. В первом случае у тебя объявлен оператор '+' с двумя параметрами — подразумеваемый 'X* this' и явный 'int' — поэтому это бинарный оператор.

Ок
class X{
public:
void operator+ (int); // определен Старуструпом как бинарный

а почему я не могу это интерпретировать, как унарный постфиксный оператор?

class X{
public:
int operator@ (int);

И как все-таки правльно интерпретировать этот оператор?
Как унарный постфиксный, или как бинарный?..

Спасибо!

wrote:

> А если вдруг у Страуструп под рукой и если не трудно — не могли бы подсказать — где у него так сказано по поводу ++? Я не придираюсь , просто интересно, т. к. пытаюсь читать вроде всё внимательно...

См. 5ую или 6ую главу с табличкой приоритетов операторов.

--
Maxim Yegorushkin

Здравствуйте, MaximE, Вы писали:

ME>См. 5ую или 6ую главу с табличкой приоритетов операторов.

Так там вроде не написано, что ++ нелья переопределять как бинарный. И вообще — написано, что "Смысл операторов таков, как описано ниже, только для встроенных типов.", речь — о пользовательском ...

Здравствуйте, Аноним, Вы писали:

А>Так там вроде не написано, что ++ нелья переопределять как бинарный. И вообще — написано, что "Смысл операторов таков, как описано ниже, только для встроенных типов.", речь — о пользовательском ...

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

class C
{
  void increment();
public:
  // типичная семантика (смысл) автоинкрементов
  C& operator ++ () { this->increment(); return *this; }
  C operator ++ (int) { C copy = *this; this->increment(); return copy; }
};

class D
{
public:
  // атипичная семантика
  E operator ++ ();
  F operator ++ (int);
};

...

D d;
E e = ++d;
F f = d++;

Здравствуйте, Кодт, Вы писали:

Ок, спасибо. Насчет гвоздей — потом в Страуструпе пороюсь (пока так и не нашел)

а по поводу второго вопроса про int operator@ (int); — не просвятите?...

Здравствуйте, e-smirnov, Вы писали:

ES>а по поводу второго вопроса про int operator@ (int); — не просвятите?...

Какой-какой оператор?

Если имеется в виду постфиксный инкремент — то история вот в чём.
Оба автоинкремента — префиксный ++x и постфиксный x++ имеют единственный аргумент.
То есть, если записывать их в функциональной форме, это operator++(x). И различить их так было бы невозможно.
Специально для различения ввели workaround — фиктивный аргумент типа int, который сообщает компилятору, что данная сигнатура — это постфиксный инкремент.

Здравствуйте, Кодт, Вы писали:

К>Какой-какой оператор?

Про ++ я согласен — тут все понятно, а если я хочу преопределить для своего класса оператор, который может быть и унарным и бинарным... Скажем +

class X{
public:
int operator+ (int);

Как все-таки правльно интерпретировать этот оператор?
Как унарный постфиксный, или как бинарный?..

Здравствуйте, Аноним, Вы писали:

А>Про ++ я согласен — тут все понятно, а если я хочу преопределить для своего класса оператор, который может быть и унарным и бинарным... Скажем +

А>Как все-таки правльно интерпретировать этот оператор?
А>Как унарный постфиксный, или как бинарный?..

Не бывает постфиксного +. Есть унарный префиксный +x и бинарный инфиксный x+y.

Когда оператор объявляется как член класса, то сам объект считается либо единственным аргументом (унарный оператор), либо левым (бинарный).
Оставшийся аргумент бинарного оператора указывается в скобках и может быть произвольного типа.

Кстати, постфиксный инкремент можно (и, по-видимому, компилятор внутри так и делает) трактовать как бинарный:
x++ --> x++0
(конечно, в исходной программе так писать нельзя).

Здравствуйте, Аноним, Вы писали:

АТ>>Какие операторы могут быть бинарными, а какие не могут, жестко зафиксировано в языке. Оператор '++' всегда унарный

А>А если вдруг у Страуструп под рукой и если не трудно — не могли бы подсказать — где у него так сказано по поводу ++? Я не придираюсь , просто интересно, т. к. пытаюсь читать вроде всё внимательно...

Какие операторы унарные, каки бинарные, а какие могут быть и тем и теми — вроде можно посмотреть в разделе 6 — "Expressions and Statements"

АТ>>А вот для тех операторов, которые могут быть и бинарными и унарными, все решается числом параметров в объявлении, не забывая считать "невидимый" (подразумеваемый) параметр 'this' для методов объектов. В первом случае у тебя объявлен оператор '+' с двумя параметрами — подразумеваемый 'X* this' и явный 'int' — поэтому это бинарный оператор.

А>Ок
А>class X{
А>public:
А>void operator+ (int); // определен Старуструпом как бинарный

А>а почему я не могу это интерпретировать, как унарный постфиксный оператор?

Потому что в языке C++ в принципе нет унарного постфиксного оператора '+'. Есть унарный префиксный. Есть бинарный. Вот и все. Механизмы перегрузки операторов в С++ не позволяют изменять их базовый синтаксис. Семантику в известной мере можно менять, но синтаксис всегда остается тем же.

А>class X{
А>public:
А>int operator@ (int);

А>И как все-таки правльно интерпретировать этот оператор?
А>Как унарный постфиксный, или как бинарный?..

Зависит от того, что скрывается за '@'. Как постфиксный опертор это может быть проинтерпретировано только для '++' и '--'. Во всех остальных случаях — оператор бинарный.

Здравствуйте, Кодт, Вы писали,
Здравствуйте, Андрей Тарасевич, Вы писали,

Всё — теперь понятно, спасибо!!!