Quel est l'intérêt de g ++ -Wreorder?

L'option g ++ -Wall inclut -Wreorder. Ce que fait cette option est décrit ci-dessous. Il n'est pas évident pour moi pourquoi quelqu'un s'en soucierait (surtout assez pour l'activer par défaut dans -Wall).

-Wreorder (C ++ uniquement)
  Avertir lorsque l'ordre des initialiseurs de membre donné dans le code ne fonctionne pas
  correspondent à l'ordre dans lequel ils doivent être exécutés. Par exemple:

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

  Le compilateur réorganisera les initialiseurs de membres pour i et j en
  correspond à l'ordre de déclaration des membres, en émettant un avertissement
  effet. Cet avertissement est activé par -Wall.

Considérer:

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

Maintenant iest initialisé à une valeur inconnue, pas zéro.

Alternativement, l'initialisation de ipeut avoir des effets secondaires pour lesquels l'ordre est important. Par exemple

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

Le problème est que quelqu'un peut voir la liste des initialiseurs de membres dans le constructeur et penser qu'ils sont exécutés dans cet ordre (j d'abord, puis i). Ils ne le sont pas, ils sont exécutés dans l'ordre dans lequel les membres sont définis dans la classe.

Supposons que vous ayez écrit A(): j(0), i(j) {}. Quelqu'un pourrait lire ça et penser que je finit par avoir la valeur 0. Ce n'est pas le cas, parce que vous l'avez initialisé avec j, qui contient des fichiers indésirables parce qu'il n'a pas lui-même été initialisé.

L'avertissement vous rappelle d'écrire A(): i(j), j(0) {}, ce qui, espérons-le, semble beaucoup plus louche.

D'autres réponses ont fourni de bons exemples qui justifient l'option d'avertissement. J'ai pensé fournir un contexte historique. Le créateur du C ++, Bjarne Stroustrup, explique dans son livre Le langage de programmation C ++ (3e édition, page 259):

Les constructeurs des membres sont appelés avant que le corps du propre constructeur de la classe contenant ne soit exécuté. Les constructeurs sont appelés dans l'ordre dans lequel ils sont déclarés dans la classe plutôt que dans l'ordre dans lequel ils apparaissent dans la liste d'initialiseurs. Pour éviter toute confusion, il est préférable de spécifier les initialiseurs dans l'ordre des déclarations. Les destructeurs de membres sont appelés dans l'ordre inverse de la construction.

Cela peut vous mordre si vos initialiseurs ont des effets secondaires. Considérer:

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

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

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

Ce qui précède affichera "bar" puis "foo", même si intuitivement on supposerait que l'ordre est tel qu'écrit dans la liste d'initialisation.

Sinon, si xety sont d'un type défini par l'utilisateur avec un constructeur, ce constructeur peut également avoir des effets secondaires, avec le même résultat non évident.

Il peut également se manifester lorsque l'initialiseur d'un membre fait référence à un autre membre.

L'avertissement existe car si vous venez de lire le constructeur, il semble qu'il jsoit initialisé avant i. Cela devient un problème si l'un est utilisé pour initialiser l'autre, comme dans

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

Lorsque vous regardez simplement le constructeur, cela semble sûr. Mais en réalité, jn'a pas encore été initialisé au point où il est utilisé pour l'initialisation i, et donc le code ne fonctionnera pas comme prévu. D'où l'avertissement.