Операции с указатели и приоритет на оператори в 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:

Не е гарантирано, че увеличение или намаление се извършва веднага след отказ от предишната стойност и преди да бъде оценена която и да е друга част от израза. Просто се гарантира, че актуализацията ще бъде извършена някъде преди изразът да се счита за „завършен“.

Прочетете този отговор, даден от Ерик Липерт за подробно обяснение.

Да, ++ се свързва по-здраво от *, но не сте разбрали как работи. 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