Постфиксный оператор приращения

Question

У меня есть собственный класс MyInt, инкапсулирующий данные int m_nValue .Постфиксный оператор

MyInt operator++(int)  
{
  MyInt temp(*this);  
  ++(*this);  
  return temp; 
}

, если оператор возвращает объект, то почему я не могу вызвать оператор postfix ++ более одного раза, например:

MyInt value(10);
value++;    // valid
value++++;  // Why is this invalid?? Cant it be interpreted as (value++)++

Почему значение ++++ дает ошибку требуется значение l если я могу вызвать метод value.print (), определенный в классе MyInt, то я также должен иметь возможность использовать значение ++++?

Answer 1

Неправильный ответ:

Поскольку value++ - это временная переменная, которая содержит старое значение value. Вы не можете ++ это.

Вы также не можете написать 15++! Это похоже. Первая - временная переменная, вторая - постоянная, которую вы не можете увеличивать.

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

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

О value++++, это не ошибка. Я только что проверил это с моим g ++ 4.5, и он отлично работает. В других ответах вы можете прочитать:

Из раздела 3.10.10 стандарта 2003 года:

lvalue для объекта необходимо для того, чтобы модифицировать объект, за исключением того, что rvalue типа class также может использоваться для изменения его референта при определенных обстоятельствах. [Пример: функция-член, вызываемая для объекта (9.3), может модифицировать объект. ]

Что по сути неправильно в том, что вы делаете, так это:

Допустим, value содержит 10. Первый value++ изменяет value на 11, но возвращает временный объект, содержащий 10. Затем вы ++ изменяют временное значение (к которому вы никогда не обращаетесь) на 11, но снова возвращаете временный объект, содержащий 10. Так что value++++ ведет себя точно так же, как value++, за исключением того, что выполняет ненужную работу.

Answer 2

На самом деле, это должно работать :

#include <iostream>

struct MyInt {
    MyInt() : value(0) {}

    MyInt& operator++() {
        std::cout << "Inside MyInt::operator++()" << std::endl;
        ++value;
        return *this;
    }

    MyInt operator++(int)  
    {
      MyInt temp(*this);  
      ++(*this);  
      return temp; 
    }

    int value;
};

int main() {
    MyInt mi;

    std::cout << "Value before: " << mi.value << std::endl;
    mi++++;
    std::cout << "Value after: " << mi.value << std::endl;
}

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

Из раздела 3.10.10 стандарта 2003 года:

lvalue для объекта необходимо для того, чтобы модифицировать объект за исключением того, что rvalue типа class также может использоваться для изменения его референта при определенных обстоятельствах.[Пример: функция-член, вызываемая для объекта (9.3), может модифицировать объект.]