Bonsoir (et bonne action de grâce),

J'ai le code suivant (extrait de mon code principal dans un fichier autonome) et je reçois des messages d'avertissement que j'aimerais résoudre.

Voici le code:

#include <cassert>
#include <ostream>
#include <climits>
#include <iostream>
#include <string>

using namespace std;

class WordCount
{
public:
   // Constructors
   WordCount() : word(""), count(0) { }
   WordCount(string theWord, unsigned theCount = 1) : word(theWord), count(theCount) { }

   // Accessors
   string Word() const { return word; }
   unsigned Count() const { return count; }

   // Mutator
   void Update() { ++count; }

   // Output a Word to a stream.
   void Show(ostream &os)  { os << word << "=" << count; }

   // Overloaded relational operators
    bool operator<(WordCount &rhs) { return word < rhs.word; }
    bool operator>(WordCount &rhs) { return word > rhs.word; }
    bool operator==(WordCount &rhs) { return word == rhs.word; }
    bool operator<=(WordCount &rhs) { return word <= rhs.word; }
    bool operator>=(WordCount &rhs) { return word >= rhs.word; }
    bool operator!=(WordCount &rhs) { return word != rhs.word; }

private:
   string   word;    // The word to be counted
   unsigned count;   // The number of occurrences
};

class Queue 
{
private:
    struct Node
    {
        WordCount data; //data in node
        Node *next;     //pointer to next node

        // Default Constructor
        Node() : next(0) {}
        // Explicit Constructor
        Node(const WordCount &theData, Node *const theNext = 0)
            : data(theData), next(theNext) { }
    };
public: 
    Queue() : head(0), tail(0) {}               
    bool Empty() const { return head == 0; }    
    void Enqueue(const WordCount &elem);            
    WordCount Dequeue();                            
    WordCount Head() { return head->data; }
private:
    Node *tail;     // "end" of queue
    Node *head;
};

void Queue::Enqueue(const WordCount &elem)
{
    Node* temp = new(nothrow) Node(elem);
    assert(temp != NULL);

    // head == tail if head == NULL, so must also be assigned temp
    if (head == NULL)
        head = temp;
    // add temp after current tail
    else
        tail->next = temp;
    // update tail adress to be new temp node
    tail = temp;
}

WordCount Queue::Dequeue()
{
    assert (!Empty());
    WordCount poppedData = head->data;
    Node *temp = head;
    head = head->next;
    if (head == NULL) 
        tail = NULL;
    delete temp;   
    return poppedData;
}

int main()
{
    return 0;
}

Quand je fais g ++ test.cpp -Wall, j'obtiens les avertissements suivants

test.cpp: In constructor 'Queue::Queue()':
test.cpp:61:8: warning: 'Queue::head' will be initialized after [-Wreorder]
  Node *head;
        ^
test.cpp:60:8: warning:   'Queue::Node* Queue::tail' [-Wreorder]
  Node *tail;  // "end" of queue
        ^
test.cpp:54:2: warning:   when initialized here [-Wreorder]
  Queue() : head(0), tail(0) {}

Existe-t-il un moyen pour moi de réécrire / réorganiser le code pour le garder fonctionnel et supprimer ces avertissements? Je ne suis pas du tout familier avec cet avertissement et je l'ai lu, mais beaucoup d'exemples de code à eux seuls sont difficiles à suivre, et encore moins à comprendre la façon de le résoudre.

Tout conseil serait apprécié, merci.

1
Trever Wagenhals 24 nov. 2017 à 01:43

3 réponses

Meilleure réponse

Les membres sont initialisés par ordre de déclaration. Avoir votre liste d'initialisation des membres dans un autre ordre peut être déroutant pour le programmeur qui peut ne pas savoir quel ordre est suivi, ou peut ne pas savoir que les membres ont été déclarés dans un ordre différent et peut donc s'attendre à ce que l'ordre d'initialisation des membres soit être l'ordre de la liste d'initialisation des membres - ce qui n'est pas dans votre cas. Le but de l'avertissement est de souligner ce fait. Ce fait peut être très important dans les cas où l'initialisation d'un membre dépend d'un autre.

Existe-t-il un moyen pour moi de réécrire / réorganiser le code pour le garder fonctionnel et supprimer ces avertissements?

Oui. En modifiant l'ordre des déclarations de membre pour correspondre à l'ordre de la liste d'initialisation des membres, c'est-à-dire

Node *head;
Node *tail;     // "end" of queue

Vous pouvez également modifier l'ordre de votre liste d'initialisation des membres pour correspondre à l'ordre de déclaration des membres.

6
eerorika 16 août 2018 à 18:17

Les membres sont initialisés dans l'ordre dans lequel ils sont déclarés dans la classe. Quel que soit l'ordre que vous utilisez dans la liste d'initialisation. Initialisez les membres dans le bon ordre et l'avertissement disparaîtra.

1
Jesper Juhl 23 nov. 2017 à 22:52

Les variables sont initialisées dans l'ordre de leur déclaration, et non dans l'ordre dans lequel elles apparaissent dans la liste d'initialisation. Votre compilateur vous avertit simplement de ce fait. Vous pouvez simplement modifier l'ordre et l'avertissement disparaîtra.

2
bennji_of_the_overflow 23 nov. 2017 à 22:47
47464164