_>myFunc (++nI, nI--){

E>IMHO, ты можешь попробовать её написать, раз уж всё так нереально запущено в этом деле

int i = 0;
(++i)++;

The value computations of the operands of an operator are sequenced before the value computation of the result of the operator.

If x is not of type bool, the expression ++x is equivalent to x+=1

In all cases, the assignment is sequenced after the value computation of the right and left operands, and before the value computation of the assignment expression.

The value computation of the ++ expression is sequenced before the modification of the operand object.

If a side effect on a scalar object is unsequenced relative to either another side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined

(n *= 10) += decimal_digit; // n и decimal_digit обозначают скалярные объекты

int i = 10;
++i++;

error C2105: '++' needs l-value

unary-expression:
postfix-expression
++ cast-expression
...

cast-expression:
unary-expression
...

postfix-expression:
...
postfix-expression ++
...

int i = 10;
XJ>++i++;
XJ>

// C2105.cpp
int main() {
   unsigned char * p1 = 0;
   unsigned int * p2 = (unsigned int *)p1;
   p2++;

   unsigned int * p = 0;
   p++;   // ok

   p2 = (unsigned int *)p1;
   ((unsigned int *)p1)++;   // C2105
}

int i = 10;
(++i)++;

_>>(++i)++;
_>>

mov         eax,dword ptr [i] 
add         eax,1 
mov         dword ptr [i],eax 
mov         ecx,dword ptr [i] 
add         ecx,1 
mov         dword ptr [i],ecx

i += 2;

mov         eax,dword ptr [i] 
add         eax,2 
mov         dword ptr [i],eax

V>>Так там скобки разграничивают expression'ы.

(a+b)*(a-b);

(a+b)++;

struct A
{
    int a;

    A(const A& a)
    {
        this->a = a.a;
    }

    A(int i = 0)
    {
        a = i;
    }

    A& operator +(A& b)
    {
        if(a >= b.a)
        {
            a += b.a;
            return *this;
        }

        b.a += a;
        return b;
    }

    A operator ++(int)
    {
        A r = *this;

        a++;

        return r;
    }
};

int main()
{
    A a(10);
    A b(11);
    (a+b)++;

    return 0;
}

V>struct A
V>{
V>    int a;

V>    A(const A& a)
V>    {
        this->>a = a.a;
V>    }

V>    A(int i = 0)
V>    {
V>        a = i;
V>    }

V>    A& operator +(A& b)
V>    {
V>        if(a >= b.a)
V>        {
V>            a += b.a;
V>            return *this;
V>        }

V>        b.a += a;
V>        return b;
V>    }

V>    A operator ++(int)
V>    {
V>        A r = *this;

V>        a++;

V>        return r;
V>    }
V>};

V>int main()
V>{
V>    A a(10);
V>    A b(11);
V>    (a+b)++;

V>    return 0;
V>}
V>

In C and C++, sequence points occur in the following places. (In C++, overloaded operators act like functions, and thus operators that have been overloaded introduce sequence points in the same way as function calls.)
...
Before a function is entered in a function call. The order in which the arguments are evaluated is not specified, but this sequence point means that all of their side effects are complete before the function is entered.

(a+b)++;

B>(a+b)++;
B>

int i = 0;
(++i)++;

int x;
x = 3;
cout << x << endl;
x = 4;

int x;
x = 4;
cout << 3 << endl;

One could argue that as the C++ standard currently stands, the effect of x = y = 0; is undefined. The reason is that it both fetches and stores the value of y, and does not fetch the value of y in order to compute its new value.

if( myNumber &&  1/myNumber < 5 ) {
}

Furthermore, the prior value shall be accessed only to determine the value to be stored.

void f(int &i)
{
    int j;
    j = i = 0;       // well-defined
    j = i + (i = 1); // undefined behavior
}

int nI=0;
myFunc (++nI, nI--){
...
}
// или
while ( --nI ) {
...
} // или ...

int nI=0;
nI += 2;
// или
nI = nI + 2;
// ну а если условие только с использованием инкрементов
nI++;
nI++;
//я бы даже не написал
(++nI)++;
//т.к. со скобками и в скобках все понятно, а вот код
()++;
// через некоторе время или другим компилятором может "дать течь"