Pourquoi est-ce que je reçois un avertissement "paramétrage mais non utilisé" lors de l'utilisation de nullptr_t?

Question

J'ai une classe personnalisée implémentant operator== avec nullptr.

Voici mon code abêtis dans un exemple simple:

#include <cstdint> 
#include <iostream> 

class C { 
private: 
    void *v = nullptr; 

public: 
    explicit C(void *ptr) : v(ptr) { } 

    bool operator==(std::nullptr_t n) const { 
     return this->v == n; 
    } 
}; 

int main() 
{ 
    uint32_t x = 0; 
    C c(&x); 
    std::cout << (c == nullptr ? "yes" : "no") << std::endl; 

    C c2(nullptr); 
    std::cout << (c2 == nullptr ? "yes" : "no") << std::endl; 


    return 0; 
} 

Le code fonctionne comme prévu, mais g ++ (version 6.2.1) me donne l'avertissement suivant:

[Timur@Timur-Zenbook misc]$ g++ aaa.cpp -o aaa -Wall -Wextra 
aaa.cpp: In member function ‘bool C::operator==(std::nullptr_t) const’: 
aaa.cpp:12:36: warning: parameter ‘n’ set but not used [-Wunused-but-set-parameter] 
    bool operator==(std::nullptr_t n) const { 
            ^

Qu'est-ce que Je fais mal? REMARQUE: J'utilise -Wall -Wextra.

Answer 1

Pas vraiment une réponse sur pourquoi cela se produit, mais de toute façon quelle valeur pourrait avoir n mais nullptr?

De retour this->v == nullptr et en faisant l'argument sans nom supprime l'avertissement:

bool operator==(std::nullptr_t) const { 
    return this->v == nullptr; 
} 

EDIT:

Déclarant n comme référence rvalue, ou comme une référence const lvalue supprime également l'avertissement:

bool operator==(std::nullptr_t&& n) const { 
    return this->v == n; 
} 

bool operator==(const std::nullptr_t& n) const { 
    return this->v == n; 
} 

EDIT2:

Plus de façons de faire taire un avertissement sur les variables inutilisées peuvent être trouvées dans this question (thx @ShafikYaghmour pour le pointer dans les commentaires). Les exemples ci-dessus couvrent les moyens "implicites".

Des solutions explicites sont disponibles, mais IMHO semble moins cohérente puisque le paramètre est effectivement utilisé. Explicites solutions éprouvées comprennent:

bool operator==(std::nullptr_t n) const { 
    (void)n; 
    return this->v == n; 
} 

#define UNUSED(expr) do { (void)(expr); } while (0) 

bool operator==(std::nullptr_t n) const { 
    UNUSED(n); 
    return this->v == n; 
} 

solution non portable pour GCC:

bool operator==(__attribute__((unused)) std::nullptr_t n) const { 
    return this->v == n; 
}