c=(a++)+b

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

Matrim написал(а):

c=(a++)+b

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

void main ()
{int a,b,c;
a=3;
b=7;
c=a+++b;
printf("a=%d b=%d c=%d",a,b,c);
getch();
}

Собственно этим примером можно проверить, что результат будет с=10 и а увеличется на единицу уже после сложения, т.к. операция ++ для переменной выполняется после вычесления выражения. А чтобы сначала увеличить а на 1, а потом уже сложить то вырожение будет с=++а+b  :)))

Интересный пример оказался. :)
P.S. никогда так не пишите.

c=a+(++b)

так и только так, и компиляторы С любые посчитают так. Вопрос в другом, а нахрена писать так??? Код должен быть понятен всем. Или задача поставленна сделать его не читабельным???

Все вяжется.

void main ()
{int a,b,c;
a=3;
b=7;
c=a+++b;
printf("a=%d b=%d c=%d",a,b,c);
getch();
}

с=10;
При этом если ты выведешь b значение будет 8, т.к. ++b выполнится последней.

Результат этой программульки:
c=10;
a=3;
b=8.
Проверяй.

А в варианте c=(a++)+b получилось бы 11.

Исправлено +VoFFka+ (05.03.09 12:58)

+VoFFka+ написал(а):

и компиляторы С любые посчитают так

вопрос был про с++, с и с++ - это разные языки :)

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

g++ v.3.4.6 и компилятор из 2008 студии собирают как c=(a++)+b, например

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

        int a=1,b=3,c;
 
        c=a+++b;
 
	return 0;

собирается как

	mov	DWORD PTR _a$[ebp], 1
	mov	DWORD PTR _b$[ebp], 3
	mov	eax, DWORD PTR _a$[ebp]
	add	eax, DWORD PTR _b$[ebp]
	mov	DWORD PTR _c$[ebp], eax
	mov	ecx, DWORD PTR _a$[ebp]
	add	ecx, 1
	mov	DWORD PTR _a$[ebp], ecx

здесь есть оптимизация, что используется одна и та же переменная 'а'

если заставить компилятор её выключить (сказав, что блок будет выполняться параллельно), то все операции будут сделаны по стандарту

        int a=1,b=3,c;
	#pragma omp parallel
	{
		c=a+++b;
	}
	return 0;

	mov	eax, DWORD PTR _a$[ebp]
	mov	ecx, DWORD PTR [eax]
	add	ecx, DWORD PTR _b$[ebp]
	mov	edx, DWORD PTR _c$[ebp]
	mov	DWORD PTR [edx], ecx
	mov	eax, DWORD PTR _a$[ebp]
	mov	ecx, DWORD PTR [eax]
	add	ecx, 1
	mov	edx, DWORD PTR _a$[ebp]
	mov	DWORD PTR [edx], ecx

R0mm написал(а):

умные дядьки придумали скобки Дэн! )

Вообще-то на лекции надо ходить...

ALONSO,

ALONSO написал(а):

Вообще-то

Revenger написал(а):

полагаться на то, что выражения будут вычисляться слева направо - как минимум глупо

chmaxx написал(а):

Все дело в точках следования.

мимо, это не тот случай :)
в обсуждаемой программе никто не пытается модифицировать одну и ту же переменную дважды, не пересекая при этом sequence point

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