Почему ++, я рассмотрел l-значение, но я ++ не?

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

До того, чтобы быть lvalue затронут, i++ не может быть присвоен тому, потому что он не относится к переменной. Это относится к расчетному значению.

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

i++   = 5;
i + 0 = 5;

, поскольку преинкремент возвращает ссылку на увеличенную переменную, а не временную копию, ++i, lvalue.

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

Кажется, что много людей объясняет, как ++i lvalue, но не , почему , как в, , почему сделал комитет по стандартам C++, вставляет эту функцию, особенно в свете того факта, что C не позволяет ни одному как lvalues. От это обсуждение comp.std.c ++ , кажется, что это так, можно взять его адрес или присвоить ссылке. Пример кода извлек из сообщения Christian Bau:

   int i;
   extern void f (int* p);
   extern void g (int& p);

   f (&++i);   /* Would be illegal C, but C programmers
                  havent missed this feature */
   g (++i);    /* C++ programmers would like this to be legal */
   g (i++);    /* Not legal C++, and it would be difficult to
                  give this meaningful semantics */

Между прочим, если i, оказывается, встроенный тип, то операторы присваивания такой как ++i = 10 вызывают неопределенное поведение , потому что i изменяется дважды между точками последовательности.

Я получаю lvalue ошибку, когда я пытаюсь скомпилировать

i++ = 2;

, но не, когда я изменяю ее на

++i = 2;

, Это вызвано тем, что префиксный оператор (++ i) изменяет значение во мне, затем возвращается i, таким образом, ей можно все еще присвоить. Постфиксный оператор (я ++) изменяет значение во мне, но возвращает временную копию старого значение , который не может быть изменен оператором присваивания.

Ответ на исходный вопрос :

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

for(int i=0; i<limit; i++)
...

совпадает с

for(int i=0; i<limit; ++i)
...

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

Даже два простых оператора

int i = 0;
int a = i++;

и

int i = 0;
int a = ++i;

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

POD Пред инкремент:

преинкремент должен действовать, как будто объект был увеличен перед выражением и быть применимым в этом выражении, как будто это произошло. Таким образом комитет стандартов C++ решил, что может также использоваться в качестве l-значения.

инкремент Сообщения POD:

постинкремент должен увеличить объект POD и возвратить копию для использования в выражении (См. Раздел n2521 5.2.6). Поскольку копия не является на самом деле переменной, делающей его, l-значение не имеет никакого смысла.

Объекты:

Пред и инкремент Сообщения на объектах просто синтаксический сахар языка, обеспечивает средство назвать методы на объекте. Таким образом технически Объекты не ограничиваются стандартным поведением языка, но только ограничениями, введенными вызовами метода.

Это до конструктора этих методов, чтобы заставить поведение этих объектов зеркально отразить поведение объектов POD (Это не требуется, но ожидается).

Преинкремент Объектов:

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

, Чтобы сделать это - siple, и только потребуйте, чтобы метод возвратил ссылку на себя. Ссылка является l-значением и таким образом будет вести себя как ожидалось.

Постинкремент Объектов:

требование (ожидаемое поведение) вот - то, что объект увеличен (таким же образом как преинкремент), и возвращенное значение похоже на старое значение и неизменяемо (так, чтобы это не вело себя как l-значение).

Неизменяемый:
, Чтобы сделать это необходимо возвратить объект. Если объект будет использоваться в рамках выражения, то это будет копия, созданная во временную переменную. Временные переменные являются константой, и таким образом она будет неизменяемый и вести себя как ожидалось.

Похож на старое значение:
Это просто достигается путем создания копии оригинала (вероятно, использование конструктора копии) прежде makeing любые модификации. Копия должна быть глубокой копией иначе, любые изменения в оригинале будут влиять на копию, и таким образом состояние изменится в отношениях к выражению с помощью объекта.

Таким же образом как преинкремент:
, вероятно, лучше реализовать инкремент сообщения с точки зрения преинкремента так, чтобы Вы получили то же поведение.

class Node // Simple Example
{
     /*
      * Pre-Increment:
      * To make the result non-mutable return an object
      */
     Node operator++(int)
     {
         Node result(*this);   // Make a copy
         operator++();         // Define Post increment in terms of Pre-Increment

         return result;        // return the copy (which looks like the original)
     }

     /*
      * Post-Increment:
      * To make the result an l-value return a reference to this object
      */
     Node& operator++()
     {
         /*
          * Update the state appropriatetly */
         return *this;
     }
};

Относительно LValue

• В C (и Perl, например), ни ++i, ни i++ LValues.

• В C++, i++ не, и LValue, но ++i.

  ++i эквивалентно i += 1, который эквивалентен [1 110].
  результат состоит в том, что мы все еще имеем дело с тем же объектом i.
  Это может быть просмотрено как:

  int i = 0;
  ++i = 3;  
  // is understood as
  i = i + 1;  // i now equals 1
  i = 3;
  

  i++, с другой стороны, мог быть просмотрен как:
  Первый мы используем значение из [1 113], затем увеличиваем объект i.

  int i = 0;
  i++ = 3;  
  // would be understood as 
  0 = 3  // Wrong!
  i = i + 1;
  

(редактирование: обновленный после покрытой пятнами первой попытки).

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

, по моему скромному мнению, это - хорошая практика для использования, '++ я' формируюсь. В то время как различие между пред - и постинкремент не действительно измеримо при сравнении целых чисел или других ПЕРЕХОДНЫХ ПРИСТАВОК дополнительная объектная копия необходимо сделать и возвратиться при использовании, 'я ++' могу представить значительное влияние производительности, если объект является или довольно дорогим для копирования, или увеличиваемый часто.

Между прочим - избегают использования нескольких инкрементных операторов на той же переменной в том же операторе. Вы попадаете в беду, "где точки последовательности" и неопределенный порядок операций, по крайней мере, в C. Я думаю, что часть этого была очищена в Java без обозначения даты C#.

Возможно, это имеет некоторое отношение к способу, которым реализован постинкремент. Возможно, это - что-то вроде этого:

• Создают копию исходного значения в памяти
• Инкремент исходная переменная
• Возврат копия

, Так как копия не является ни переменной, ни ссылкой на динамично выделенную память, это не может быть l-значение.

C#:

public void test(int n)
{
  Console.WriteLine(n++);
  Console.WriteLine(++n);
}

/* Output:
n
n+2
*/