c++ - programacion - ¿Orden de asignación vs orden de inicialización?

manual de programacion android pdf

Question

Toma este código de ejemplo:

int a = 10;
int b = 20;
int c = 30;

int & foo1() {
    qDebug() << "foo1" << endl;
    return a;
}

int & foo2() {
    qDebug() << "foo2" << endl;
    return b;
}

int & foo3() {
    qDebug() << "foo3" << endl;
    return c;
}

int main(void)
{
    foo1() = foo2() = foo3() = 7;
}

Como la asignación va de derecha a izquierda, esperaba ver foo3 primero y foo1 final, pero es lo contrario.

¿Están las reglas para tales escenarios concretamente definidas y cómo? Además, ¿el compilador distingue entre asignación y otros operadores y cómo sería posible si está utilizando el operador = en un contexto diferente al de la inicialización? ¿Tal vez la asignación de la cadena se trata de manera diferente a otros encadenamientos?

Answer 1

¡El orden en que se evalúan las subexpresiones no es el mismo que se aplica su resultado!

foo1 () se puede llamar antes, solo la asignación en sí no debe aplicarse antes de que las otras también se realicen.

Answer 2

La asociatividad del operador (es decir, de derecha a izquierda) no está relacionada con el orden de evaluación . ^* El orden de evaluación de los operandos no está especificado.

_{* Excepto en algunos casos, a saber, && , || y,.}

Answer 3

La expresion completa

foo1() = foo2() = foo3() = 7

Se puede abstraer con el siguiente árbol:

     =
   /   /
foo1()   = 
       /   /
    foo2()   =
           /   /
        foo3()   7

Las hojas de ese árbol pueden ser evaluadas en cualquier orden. Tu compilador es libre de elegir. Solo para llamar al operador de asignación, primero se deben evaluar las expresiones que cuelgan de ellos. En su caso, las hojas se evalúan en el orden foo1() , foo2() y luego foo3() .

La asociatividad de derecha a izquierda de = solo se ve en la forma del árbol, pero no en el orden de evaluación. El arbol para

std::cout << foo1() << foo2() << foo3()

parece

                   << 
                 /    /
              <<      foo3()
            /    /
         <<      foo2()
       /    /
std::cout   foo1()

Nuevamente, las funciones foo pueden evaluarse en cualquier orden, pero el orden de las evaluaciones del operator<<() está bien definido. Hay una publicación interesante sobre puntos de secuencia que describe muy bien los temas.