Збільшення в C ++ - Коли використовувати x ++ або ++ x?

На даний момент я вивчаю C ++ і деякий час тому я дізнався про збільшення. Я знаю, що ви можете використовувати "++ x", щоб зробити приріст до і "x ++", щоб зробити це після.

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

Приклад: Коли у циклі for, коли переважно використовувати "++ x"?

Крім того, хтось може пояснити, як саме працюють різні збільшення (або зменшення)? Я б дуже вдячний.

Це питання не переваги, а логіки.

x++збільшує значення змінної x після обробки поточного оператора.

++xзбільшує значення змінної x перед обробкою поточного оператора.

Тож просто визначтесь із логікою, яку ви пишете.

x += ++iзбільшить i і додасть i + 1 до x. x += i++додасть i до x, а потім збільшить i.

Скотт Мейерс каже, щоб ви віддавали перевагу префіксу, за винятком тих випадків, коли логіка диктує, що постфікс доречний.

"Ефективніший C ++", пункт 6 - це достатньо повноважень для мене.

Для тих, хто не є власником книги, ось відповідні цитати. Зі сторінки 32:

З тих пір, коли ви працювали програмістом на С, ви можете пам’ятати, що префіксну форму оператора приросту іноді називають «збільшенням та вибором», тоді як форма постфіксу часто називається «вибіркою та збільшенням». Дві фрази важливо пам’ятати, оскільки всі вони виконують лише формальну специфікацію ...

І на сторінці 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-ітератор.

Редагувати: виправлено змішування позначень префіксів та суфіксів

Форма постфіксу ++, - оператор дотримується правила use-then-change ,

Префіксна форма (++ 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]);

Це питання смаку, що зрозуміліше, і якщо у машини є декілька регістрів, обидва повинні мати однаковий час виконання, навіть якщо [i] - це функція, яка є дорогою або має побічні ефекти. Значною різницею може бути вихідне значення індексу.