Когда ++ не дает такие же результаты, как +1?

Когда Вы используете язык, который позволяет перегрузку оператора, и '+ < integer>'; был определен, чтобы сделать что-то другое, чем пост - и префикс '++ '.

С другой стороны, я только видел такое отвращение в школьных проектах*, если Вы встречаетесь с этим в дикой природе, у Вас, вероятно, есть действительно хорошее, хорошо зарегистрированный, причина.

[* стопка целых чисел, если я не ошибаюсь. '++' и '-' продвинутый и вытолканный, в то время как '+' и '-' выполнил нормальную арифметику]

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

Однако, по-моему, код как это действительно неаккуратен, с тех пор путем попытки быть умным, он делает, необходимо думать дважды о том, что действительно происходит.

Разъяснить все другие ответы:

+++++++++++++++++++++

DoStuff(a++);

эквивалентен:

DoStuff(a);
a = a + 1;

+++++++++++++++++++++

DoStuff(++a);

эквивалентен:

a = a + 1;
DoStuff(a);

+++++++++++++++++++++

DoStuff(a + 1);

эквивалентен:

b = a + 1;
DoStuff(b);

+++++++++++++++++++++

Пока заманчиво переписать как:

DoStuff(++level);

я лично думаю, что это менее читаемо, чем постепенное увеличение переменной до вызова метода. Как отмечено несколькими ответами выше, следующее было бы более ясным:

level++;
DoStuff(level);

возвращаемое значение level++ будет level и therefore передача level в [1 110]. Это могло быть довольно противной ошибкой, поскольку рекурсия никогда не будет заканчиваться (от того, что показывают DoStuff, всегда передается с тем же значением). Возможно ++level или level + 1 предназначен вместо этого?

level + 1 передаст level + 1 в [1 116] и отпуск level неизменный для остальной части функции.

постинкрементный оператор (переменная ++) точно эквивалентен функции

int post_increment(ref int value)
{
    int temp = value;
    value = value + 1
    return temp;
}

, в то время как преинкрементный оператор (++ переменная) точно эквивалентен функции

int pre_increment(ref int value)
{
    value = value + 1;
    return value;
}

Поэтому при расширении оператора, встроенного в код операторы эквивалентны:

DoStuff(a + 1)

int temp = a + 1;
DoStuff(temp);

DoStuff(++a)

a = a + 1;
DoStuff(a);

DoStuff(a++);

int temp = a;
a = a + 1;
DoStuff(temp);

важно отметить, что постинкремент не эквивалентен:

DoStuff(a);
a = a + 1;

Кроме того, как точка стиля, не нужно увеличивать значение, если намерение не состоит в том, чтобы использовать увеличенное значение (определенная версия правила, "не присваивают значение переменной, если Вы не планируете использование того значения"). Если значение i + 1 никогда не используется снова, то предпочтительное использование должно быть DoStuff(i + 1) а не DoStuff(++i).

level+1 отправляет, любой level+1 к функции. уровень ++ отправляет уровень в функцию и затем увеличивает его.

Вы могли сделать ++ уровень, и это, вероятно, даст Вам результаты, которые Вы хотите.

Первый пример использует значение 'индекса', увеличивает значение и обновления 'индекс'.

второй пример использует значение 'индекса' плюс 1, но не изменяет содержание 'индекса'.

Так, в зависимости от того, что Вы желаете сделать здесь, в хранилище могли быть некоторые неожиданности!

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

level++ возвраты текущее значение level, затем увеличивает level. level+1 не изменяется level вообще, но DoStuff назван со значением (level + 1).

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

level+1 передаст level+1 в [1 112] DoStuff и отпуск уровень , неизменный для остальной части функции.