Приращение в C ++ - когда использовать x ++ или ++ x?

В настоящее время я изучаю C ++ и некоторое время назад узнал об увеличении. Я знаю, что вы можете использовать «++ x» для увеличения до и «x ++», чтобы сделать это после.

Тем не менее, я действительно не знаю, когда использовать любой из двух ... Я никогда не использовал "++ x", и до сих пор все работало нормально - так когда мне его использовать?

Пример: когда в цикле for предпочтительнее использовать «++ x»?

Кроме того, может ли кто-нибудь точно объяснить, как работают разные приращения (или убывания)? Я был бы очень признателен.

Это вопрос не предпочтений, а логики.

x++увеличивает значение переменной x после обработки текущего оператора.

++xувеличивает значение переменной x перед обработкой текущего оператора.

Так что просто определитесь с логикой, которую вы пишете.

x += ++iбудет увеличивать i и добавлять i + 1 к x. x += i++добавит i к x, затем увеличит i.

Скотт Мейерс советует вам отдавать предпочтение префиксу, за исключением тех случаев, когда логика подсказывает, что постфикс уместен.

Пункт №6 «Более эффективный C ++» - это для меня достаточный авторитет.

Для тех, кто не владеет книгой, вот уместные цитаты. Со страницы 32:

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

И на странице 34:

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

Из cppreference при увеличении итераторов:

Если вы не собираетесь использовать старое значение, вам следует предпочесть оператор предварительного приращения (++ iter) оператору пост-приращения (iter ++). Постинкремент обычно реализуется следующим образом:

   Iter operator++(int)   {
     Iter tmp(*this); // store the old value in a temporary object
     ++*this;         // call pre-increment
     return tmp;      // return the old value   }

Очевидно, это менее эффективно, чем предварительное увеличение.

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

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

пример:

pre.cpp:

#include <iostream>

int main()
{
  int i = 13;
  i++;
  for (; i < 42; i++)
    {
      std::cout << i << std::endl;
    }
}

post.cpp:

#include <iostream>

int main()
{

  int i = 13;
  ++i;
  for (; i < 42; ++i)
    {
      std::cout << i << std::endl;
    }
}

_

$> g++ -S pre.cpp
$> g++ -S post.cpp
$> diff pre.s post.s   
1c1
<   .file   "pre.cpp"
---
>   .file   "post.cpp"

Самая важная вещь, о которой следует помнить, imo, заключается в том, что x ++ должен возвращать значение до того, как фактически произошло приращение, поэтому он должен сделать временную копию объекта (до приращения). Это менее эффективно, чем ++ x, который увеличивается на месте и возвращается.

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

for (int i(0);i<10;++i)
for (int i(0);i<10;i++)

Я согласен с @BeowulfOF, хотя для ясности я всегда выступал бы за разделение заявлений, чтобы логика была абсолютно ясной, то есть:

i++;
x += i;

или

x += i;
i++;

Итак, мой ответ: если вы пишете четкий код, это редко имеет значение (а если это имеет значение, ваш код, вероятно, недостаточно ясен).

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

Вы правильно объяснили разницу. Это просто зависит от того, хотите ли вы, чтобы x увеличивался перед каждым запуском цикла или после этого. Что подходит, зависит от логики вашей программы.

Важное различие при работе с итераторами STL (которые также реализуют эти операторы) заключается в том, что он ++ создает копию объекта, на который указывает итератор, затем увеличивает его и затем возвращает копию. ++ он, с другой стороны, сначала выполняет приращение, а затем возвращает ссылку на объект, на который теперь указывает итератор. Это в основном актуально, когда важен каждый бит производительности или когда вы реализуете свой собственный STL-итератор.

Изменить: исправлено смешение префикса и суффикса.

Постфиксная форма оператора ++, - следует правилу " используйте-затем-измените" ,

Форма префикса (++ x, - x) соответствует правилу « измени-затем-используй» .

Пример 1:

Когда несколько значений каскадированы с << с использованием cout, тогда вычисления (если есть) выполняются справа налево, но печать выполняется слева направо, например (если val, если изначально 10)

 cout<< ++val<<" "<< val++<<" "<< val;

приведет к

12    10    10 

Пример 2:

В Turbo C ++, если в выражении обнаружено несколько вхождений ++ или (в любой форме), то сначала вычисляются все префиксные формы, затем вычисляется выражение и, наконец, вычисляются постфиксные формы, например,

int a=10,b;
b=a++ + ++a + ++a + a;
cout<<b<<a<<endl;

Его вывод в Turbo C ++ будет

48 13

В то время как в современном компиляторе он будет выводиться (потому что они строго следуют правилам)

45 13

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

Понимание синтаксиса языка важно при рассмотрении ясности кода. Рассмотрите возможность копирования символьной строки, например, с постинкрементом:

char a[256] = "Hello world!";
char b[256];
int i = 0;
do {
  b[i] = a[i];
} while (a[i++]);

Мы хотим, чтобы цикл выполнялся, встречая нулевой символ (который проверяет ложь) в конце строки. Это требует проверки предварительного приращения значения, а также увеличения индекса. Но не обязательно в таком порядке - способ закодировать это с предварительным приращением:

int i = -1;
do {
  ++i;
  b[i] = a[i];
} while (a[i]);

Это вопрос вкуса, который яснее, и если на машине есть несколько регистров, оба должны иметь одинаковое время выполнения, даже если a [i] - функция, которая является дорогой или имеет побочные эффекты. Существенная разница может заключаться в выходном значении индекса.