Russian Qt Forum

Я решил немного вернуться к плюсам, и наверстать те вещи, которые не осилил ранее.

Вот, например, есть такой текст на буржуйском:

http://en.cppreference.com/w/cpp/language/operator_incdec#Built-in_prefix_operators

В нем неожиданно появляется загадочная конструкция:


Вопрос: что означает загадочный оператор "++", который не применяется ни к одной переменной? Догадаться сам, что это значит, я не могу.

Output:

;D

++(++(n1))

++++++++++++n1

Где-то еще используется такое синтаксическое правило? Или только в операторах префиксного инкремента/декремента?

xintrea, префикс возвращает обычно lvalue, а постфикс rvalue.

я показал, что это равносильно вызову функции: f(f(n1)). Вычисление изнутри наружу происходит для любых функций.

То есть, это такой синтаксис, напоминающий функциональные языки типа Лиспа, где вызов функции идет без скобок, и пишут так:


Учитывая, что оператор - это, по сути, вызов функции одного или двух аргумеyтов (в данном случае - одного), то для унарного оператора ++ могут писать вот такие вызовы через пробел? Так что ли? Что-то это капец как сложно.

http://ru.cppreference.com/w/cpp/language/operator_precedence

В общем, мня сбил с толку этот унарный оператор "++" без самого операнда. Просто никто не сказал, что на самом деле операнд у него есть. Стали говорить про равносильные вызовы функций, про приоритет операций, про префикс lvalue и постфикс rvalue. Но вопрос-то был не про это.

Значит, есть конструкция:

C++ (Qt)
int i=1;
int a = ++ ++i;
 

Здесь мы видим два инкремента, назовем их слева-направо первый и второй.

Первый, как будто, не имеет операнда и даже непонятно, каким инкрементом он является - префиксным или постфиксным. Второй инкремент имеет операнд i и является префиксным.

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

C++ (Qt)
int a = ++++i;

И такая запись даже работает в GCC (как в других компилерах - не знаю). Теперь становится очевидным, что первый оператор инкремента - он префиксный, а конструкция "++i" - это операнд для первого инкремента. И тогда, учитывая что сказал Авварон про приоритет операций, и учитывая что сказал Kambala про равносильный вызов функций, мы из этой мозаики понимаем, что по-сути запись должна быть такая:

C++ (Qt)
int a = ++(++i);

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


Казалось бы, разобрались. Но нет. Возьмем теперь другой пример:

C++ (Qt)
int a = ++i++;

Вроде все просто: у нас есть таблица приоритета операций, и в ней постинкремент имеет больший приоритет чем преинкремент. И поэтому компилер мог бы эту конструкцию прожевать как:

C++ (Qt)
int a = ++(i++);

Но фишка в том, что с постинкрементом (который записан в скобках) не все так просто. То есть, глобально, как с сущностью, с постинкрементом в C++ не все так просто. Это его свойство - изменять значение операнда уже после использования - заставило разработчиков языка C++ прилеплять результату постинкремента флаг rvalue, о чем говорил __Heaven__. А к операнду с флагом rvalue невозможно применить операцию, которая будет его трансформировать, пускай и в режиме "после использования". Поэтому данный пример компилится не будет, выдавая ошибку:


Вот теперь с преинкрементами/постинкрементами стало чуть более понятно.


Ремарка: фраза "изменение значения после использования", которую я вижу везде, не отвечает на главный вопрос: в какой же момент происходит изменение значения? После использования значения, хранимого в операнде, или после вычисления всего выражения? Внятного ответа я не нашел.

Та нету там никаких флагов :)
Грубо говоря мы имеем 2 сигнатуры.

C++ (Qt)
int &operator(int &val); // prefix
int operator(int &val, int); // postfix

префиксный сначала увеличивает значение, а потом возвращает ссылку на него.
постфиксный же увеличивает значение, а возвращает прежнее состояние переменной. Если бы он возвращал ссылку, то по ней было бы доступно увеличенное значение.

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

Вот, это очень хорошее объяснение. Из него становится понятно, что на самом деле происходит, когда говорят "изменение значения после использования".

Получается, что на самом деле никакого "изменения значения после использования" нет! Этот бред, записанный в половине учебников по C++, надо искоренять каленым железом.

Происходит следующее:

• Запоминается значение переменной в регистр или в стек (все зависит от реализации)
• Значение переменной изменяется. То есть, если не смотреть на шаг с запоминанием, можно сказать, что значение переменной изменяется сразу, без всяких там "изменений значения после использования".
• В результате операции постинкремента возвращается не ссылка на значение переменной (что имело бы тип lvalue, да и значение было бы уже увеличенное), а запомненное на первом шаге число (возвращается в виде сущности "значение" а не "значение переменной", и поэтому имеет тип rvalue).

И из-за того, что результат постинкремента представляет собой "просто число", которое возвращается в результате этой операции, то для такого числа невозможно изменение, потому что оно расценивается, по сути, как константа. Причем слово "невозможно" тут следует понимать так: конечно, хранимое в регистре или на стеке число возможно изменить. Просто компилятор будет генерить такой код, что результат операции постинкремента будет представлять из себя rvalue, вследствие чего этот результат будет "неизменяемым". И поэтому конструкция a=++(i++) работать не будет.

Объяснение это тоже корявое, но вроде правильное, если не будет возражений у наших гуру.

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

А конструкции типа таких

C++ (Qt)
int a = ++(i++);

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

Фраза может неудачная, двояко понять можно. Думается мне, для конструкции i++, имелось в виду: изменение значения i (инкремент) после использования i (получения текущего значения), а не: изменение значения полученного/вычисленного после использования(инкремента) i.

И да, в программном коде тоже лучше выражаться на нормальном, на гражданском языке :). Чтобы читатели не ломали голову над тем, что же хотел сказать автор таким кодом: b = ++++++a.