Операции с указателями и приоритет операторов в C

Заявление

*intAPtr++ = *intBPtr++;

анализируется как

*(intAPtr++) = *(intBPtr++);

и распадается следующим образом:

• Значение, на которое в данный момент указывает intBPtr (3), присваивается местоположению, на которое указывает intAPtr (intgA[0]);
• Указатели intAPtr и intBPtr увеличиваются.

Точный порядок, в котором это происходит, не указан; вы не можете полагаться на то, что intBPtr увеличивается после intAPtr или наоборот, и вы не можете полагаться на присваивание, происходящее до увеличения, и т. д.

Так что к тому времени, когда все это будет сделано, intgA[0] == 3 и intAPtr == &intgA[1] и intBPtr == &intgB[1].

Выражение a++ оценивается как значение a перед приращением.

Вы и другой парень оба не правы!

Либо
1. сначала увеличиваются оба указателя, а затем происходит присваивание, либо
2. увеличивается один указатель, затем происходит присваивание, затем увеличивается другой указатель, либо
3. сначала происходит присваивание, а затем увеличивается указатель .

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

C-faq: 3.2:

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

Прочитайте этот ответ, данный Eric Lippert за подробными разъяснениями.

Да, ++ связывает крепче, чем *, но вы неправильно поняли, как это работает. var++ увеличивает var, но оценивается как значение var перед приращением. Вы можете думать об этом как о синтаксическом сахаре для (var += 1, var - 1), если хотите.

Другой способ думать об этом таков: если бы это работало так, как вы думали, тогда не было бы никакой разницы между var++ и ++var, и ни один из них не был бы включен в язык в первую очередь. C почти не имеет избыточности.

(Приоритет привязки имеет значение; например, это означает, что *var++ увеличивает значение переменной var, тогда как (*var)++ увеличивает значение в ячейке памяти по адресу *var.)

Основной эффект оператора ++ состоит в том, чтобы произвести значение своего операнда (без его увеличения). Побочный эффект заключается в увеличении операнда.

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

В *x++, который анализируется как *(x++), оператор * применяется к значению, созданному основным эффектом, поэтому операция * такая же, как если бы вычислялся *x. Инкремент происходит «на стороне», вне основного вычисления выражения, поэтому он не принимает участия в определении значения *x++.

Пример кода (в Linux):

#include <stdio.h>
#include <stdlib.h>
int main() {
    int intgA[2] = { 1, 2 };
    int intgB[2] = { 3, 5 };
    int *intAPtr = intgA; //1
    int *intBPtr = intgB; //3
    *intAPtr++ = *intBPtr++;
    // *intAPtr = *intBPtr;
    // *intAPtr++ = 25; 
    printf("op: %d %d\n", *intAPtr, *intBPtr);

   return 0;
}

выход:

op: 2 5

сначала он присваивает intBPtr intAPtr, затем происходит приращение, потому что это пост-приращение.

Я согласен с ответом Джона Боде, чтобы немного упростить его, я просто напишу его в коде:

   *intAptr = * intBPtr;

равно:

   *intAptr =*intBPtr 
   intAPtr+=1;
   inrBPtr+=1;

Итак, что мы получаем: intAPtr указывает на 2 intBPtr указывает на 5