C: Как работает "if((a+=b) > c)"?

Question

Я пытаюсь переписать некоторый код на C от другого автора в Igor Pro (аналогичная запись на C). Код доступен здесь.

Я не знаю как бороться со строками if ((umin+=input[k+1]-vmin)<minlambda) а также else if ((umax+=input[k+1]-vmax)>lambda) что касается порядка того, как они идут об обновлении umin а также umaxи как операторы if/elseif, имеющие значение true или false, влияют на обновление.

В частности:

На линиях 99-107 есть:

        if ((umin+=input[k+1]-vmin)<minlambda) {        
            do output[k0++]=vmin; while (k0<=kminus);
            vmax=(vmin=input[kplus=kminus=k=k0])+twolambda;
            umin=lambda; umax=minlambda;
        } else if ((umax+=input[k+1]-vmax)>lambda) {    
            do output[k0++]=vmax; while (k0<=kplus);
            vmin=(vmax=input[kplus=kminus=k=k0])-twolambda;
            umin=lambda; umax=minlambda;
        } else { /*blah blah */ }

Я изменил это, чтобы прочитать:

    if ((umin+=input[k+1]-vmin) < minlambda) //Todo
        do
            output[k0] = vmin
            k0+=1
        while(k0 <= kminus)

        k=k0
        kminus=k
        kplus=kminus
        vmin=input[kplus]
        vmax = (vmin) + twolambda
        umin = lambda
        umax = minlambda

    elseif ((umax+=input[k+1]-vmax) > lambda) //Todo
        do
            output[k0]=vmax
            k0+=1
        while(k0 <= kplus)

        k=k0
        kminus=k
        kplus=kminus
        vmax=input[kplus]
        vmin = (vmax) - twolambda
        umin = lambda
        umax = minlambda        
    else //blah blah

Обновляются ли umin и umax только в том случае, если их операторы if оцениваются как true? Или это каскад? IF(umin) -> false, umin обновлено, ELSEIF(umax) -> true, umax обновлено, но IF(umin) -> true, umin обновлено, umax не обновлено? Или какой-то другой вариант?

Еще один вопрос по поводу того же кода.

Редактировать: фиксированный заголовок. Добавлен тег игор

Answer 1

Это:

for (;;) {
....
  if ((umin+=input[k+1]-vmin)<minlambda) {        
        do output[k0++]=vmin; while (k0<=kminus);
        vmax=(vmin=input[kplus=kminus=k=k0])+twolambda;
        umin=lambda; umax=minlambda;
    } else if ((umax+=input[k+1]-vmax)>lambda) {    
        do output[k0++]=vmax; while (k0<=kplus);
        vmin=(vmax=input[kplus=kminus=k=k0])-twolambda;
        umin=lambda; umax=minlambda;
    } else { /*blah blah */ }
}

(из первоисточника) более или менее эквивалентно этому

for (;;)
{
    ...
    umin += input[k + 1] - vmin;
    if (umin < minlambda) 
    {
        ...
        continue;
    }
    umax += input[k + 1] - vmax;
    if (umax > lambda)
    {
         ....
        continue;
    }
    /* blah blah */
}

Вы можете сделать это, потому что блок if находится в конце цикла, в противном случае вам потребуются некоторые elseи дополнительный отступ, который был бы в меру менее симпатичным (но, вероятно, все еще легче понять).

Answer 2

if( a += b > c)

В этом первом b>c оценивается как > имеет более высокий приоритет, чем +=,

затем += будет оцениваться. Сейчас если b>c тогда верно a будет a+=1 и если это ложь, то a+=0 будет оцениваться.

Теперь это (как вы обновили свой заголовок)-

 if ((umin+=input[k+1]-vmin)<minlambda)  

В этом первом (umin+=input[k+1]-vmin) будет оцениваться. Почему? из-за скобок () имеет более высокий приоритет, чем <,

В (umin+=input[k+1]-vmin) в силу приоритета - выше чем +=, input[k+1]-vmin оценивается, а затем его результат добавляется umin и хранится в umin,

После этой оценки она сравнивается с minlamda,

Точно так же вы можете понять, как это будет работать (конечно, если условие в if является false)-

else if ((umax+=input[k+1]-vmax)>lambda) 

здесь также umax будет обновлен, а затем будет сопоставлен с lambda,

Answer 3

umin будет обновляться каждый раз, когда вы входите туда.
umax будет обновлено (umax+=input[k+1]-vmax) > lambda если и только если (umin+=input[k+1]-vmin) < minlambda ложно, потому что это в else if

a+=b > c работает как if(b>c)a+=1; else a+=0;

(a+=b)>c работает как (a+=b),a>c, который возвращает a>c после добавления b в a,

Answer 4

Вы можете посмотреть на это так:

((umin+=input[k+1]-vmin)<minlambda)

по существу

var umin += input[k+1] - vmin;
if (umin < minlambda) { }
else if ((umax += input[k+1] - vmax)> lambda) { }

umin просто вычисляется внутри оператора if, а затем сравнивается с minlambda