¿Cuál es el punto de g ++ -Wreorder?

La opción g ++ -Wall incluye -Wreorder. Lo que hace esta opción se describe a continuación. No es obvio para mí por qué a alguien le importaría (especialmente lo suficiente como para activar esto por defecto en -Wall).

-Wreorder (solo C ++)
  Avisar cuando el orden de los inicializadores de miembros dados en el código no
  coincidir con el orden en que deben ejecutarse. Por ejemplo:

    struct A {
      int i;
      int j;
      A (): j (0), i (1) {}
    };

  El compilador reorganizará los inicializadores de miembros para i y j para
  hacer coincidir el orden de declaración de los miembros, emitiendo una advertencia a ese
  efecto. Esta advertencia está habilitada por -Wall.

Considerar:

struct A {
    int i;
    int j;
    A() : j(0), i(j) { }
};

Ahora ise inicializa a un valor desconocido, no a cero.

Alternativamente, la inicialización de ipuede tener algunos efectos secundarios para los cuales el orden es importante. P.ej

A(int n) : j(n++), i(n++) { }

El problema es que alguien puede ver la lista de inicializadores miembros en el constructor y pensar que se ejecutan en ese orden (j primero, luego i). No lo son, se ejecutan en el orden en que los miembros se definen en la clase.

Supongamos que escribiste A(): j(0), i(j) {}. Alguien podría leer eso y pensar que i termina con el valor 0. No lo hace, porque lo inicializó con j, que contiene basura porque no se ha inicializado.

La advertencia le recuerda que debe escribir A(): i(j), j(0) {}, que con suerte se ve mucho más sospechoso.

Otras respuestas han proporcionado algunos buenos ejemplos que justifican la opción de una advertencia. Pensé en proporcionar un contexto histórico. El creador de C ++, Bjarne Stroustrup, explica en su libro El lenguaje de programación C ++ (3ra edición, Página 259):

Se llama a los constructores de los miembros antes de ejecutar el cuerpo del propio constructor de la clase que lo contiene. Los constructores se llaman en el orden en que se declaran en la clase en lugar del orden en que aparecen en la lista de inicializadores. Para evitar confusiones, es mejor especificar los inicializadores en orden de declaración. Los destructores miembros se llaman en el orden inverso de construcción.

Esto puede morderte si tus inicializadores tienen efectos secundarios. Considerar:

int foo() {
    puts("foo");
    return 1;
}

int bar() {
    puts("bar");
    return 2;
}

struct baz {
    int x, y;
    baz() : y(foo()), x(bar()) {}
};

Lo anterior imprimirá "bar" y luego "foo", aunque intuitivamente uno supondría que el orden es como está escrito en la lista de inicializadores.

Alternativamente, si xy yson de algún tipo definido por el usuario con un constructor, ese constructor también puede tener efectos secundarios, con el mismo resultado no obvio.

También puede manifestarse cuando el inicializador de un miembro hace referencia a otro miembro.

La advertencia existe porque si acaba de leer el constructor, parece que jse está inicializando antes i. Esto se convierte en un problema si uno se usa para inicializar al otro, como en

struct A {
  int i;
  int j;
  A(): j (0), i (this->j) { }
};

Cuando solo miras al constructor, esto parece seguro. Pero en realidad, jaún no se ha inicializado en el punto donde se usa para inicializar i, por lo que el código no funcionará como se esperaba. De ahí la advertencia.