Pourquoi est-ce que C++ code manquant un argument formel nom dans une définition de fonction compiler sans mise en garde?

Tout a commencé avec quelques VS2005 MFC générées par le code, j'ai remarqué qu'il emportait une méthode avec quelque chose comme ceci:

void OnDraw(CDC* /*pDC*/)
{
    ...
    //TODO: Add your code here
}

Alors évidemment, dès que j'ai ajouté quelque chose que j'ai réalisé que j'avais besoin de dé-commentez le contrôleur de domaine principal argument formel pour compiler, mais je suis confus comment/pourquoi une fonction C++ permet de compiler (sans avertissement) lorsque l'argument formel n'a qu'un type et un nom:

void foo(int)
{
    int x = 3;
}
int main()
{
    foo(5);
    return 0;
}

Ne devrait pas générer au moins un avertissement (avec Mur ou /W4)? Il ne semble pas. Ai-je raté quelque chose? Est-il un cas où c'est utile ou c'est juste parce que le compilateur ne peut pas faire la différence entre une déclaration de fonction (uniquement des types requis) et une définition (complètement spécifié) jusqu'à ce que la ligne a été traitée?

InformationsquelleAutor Andrew Coleson | 2010-02-23

c++compiler-warnings

53

Parce que parfois vous avez un paramètre qui est requis de lui par une interface, mais la fonction ne l'utilise pas. Peut-être que le paramètre n'est plus nécessaire, n'est nécessaire que dans d'autres fonctions que doit utiliser la même signature (en particulier de sorte qu'ils peuvent être appelés par le biais de pointeurs) ou la fonctionnalité n'a pas encore été mise en œuvre. Avoir des paramètres qui ne sont pas utilisés peuvent être particulièrement commun dans les générées ou code de la structure pour cette raison (et c'est sans doute pourquoi le MFC code généré est le nom en commentaire).

Pourquoi il n'y a pas d'avertissement - je suppose que c'est parce que c'est un problème est une chose subjective et d'autres personnes (en particulier les responsables de l'implémentation du compilateur) ne le vois pas comme un problème. Une fois que vous allez réellement utiliser le paramètre, vous obtiendrez le compilateur à se plaindre si vous oubliez de décommenter le nom de sorte que vous obtenez le compilateur se plaint uniquement lorsque vous en avez vraiment besoin (le compilateur de la version de l'agile YAGNI: "Vous ne vont pas Neet Il" philosophie).

Le contraire ne semblent généralement se produire lorsque vous montez les avertissements - les paramètres nommés qui ne sont pas utilisés de générer des avertissements - encore une fois c'est probablement la raison pour laquelle la fonction générée a le nom en commentaire.
- Comme une note, beaucoup de compilateurs ont un pragma pour désactiver le paramètre inutilisé avertissements - plus pertinente que lorsque le paramètre est un nom de cours - précisément parce qu'il y a des raisons valables de ce qui peut arriver. Certains préfèrent laisser le nom de toutes les façons, pour indiquer l'utilisation prévue (en fonction de l'interface), même si elle n'est pas utilisée dans ce cas.
- Je suppose que le sens -- j'ai pensé que c'était quelque chose le long de ces lignes, il semblait juste (pour moi) comme une inhabituelle bord de condition pour autoriser explicitement, lorsque (comme indiqué ci-dessous) C ne le permet pas. Mais votre point de vue sur polymorphes appels est certainement valable, et qui fait sens pour C++ pour la considère.
InformationsquelleAutor Michael Burr
18

La raison la plus commune que j'ai vu est de supprimer la variable inutilisée des avertissements du compilateur va lancer pour:
```
#include <iostream>

void foo(int source)
{
  std::cout << "foo()" << std::endl;
}

int main()
{
  foo(5);
  return 0;
}
```
gcc dit: main.cc:3: warning: unused parameter 'source'

Il y a deux façons de se débarrasser de l'avertissement: commentaire le nom de la variable ou de la supprimer totalement:
```
void foo(int /*source*/)
{
  std::cout << "foo()" << std::endl;
}
```
contre
```
void foo(int)
{
  std::cout << "foo()" << std::endl;
}
```
Je recommande fortement commentaires sur la suppression. Sinon, votre entretien programmeurs auront à trouver ce paramètre représente une autre façon.

Qt (et probablement d'autres cadres) fournit une macro qui supprime l'avertissement sans besoin de commenter ou supprimer le nom de la variable: Q_UNUSED(<variable>):
```
void foo(int source)
{
  Q_UNUSED(source); //Removed in version 4.2 due to locusts
  std::cout << "foo()" << std::endl;
}
```
Cela vous permet d'appeler dans le corps de la fonction, la variable n'est pas utilisée, et donne une grande place à document pourquoi il n'est pas utilisé.
- C'est le rationnel. (BTW, C besoin le nom du paramètre)
- La question a été sur le C++, pas de C.
- mais c'est toujours une précieuse note (je me retrouve parfois irrité par C l'insistance sur le nom du paramètre)
- Juste assez. Je ne travaille pas avec C tout ce que beaucoup.
- Pour l'enregistrement, des choses comme Q_UNUSED() habituellement étendre à __attribute__ ((unused)) sur GCC.
- On dirait qu'ils ne le font plus: qt.gitorious.org/qt/qt/blobs/master/src/corelib/global/..., lignes 1568-1574
- J'étais sous l'impression Q_UNUSED devait être utilisés dans les listes de paramètres. Comme ceci: sourcefrog.net/weblog/software/languages/C/unused.html
- Ah, je vois la confusion. Q_UNUSED est destiné à être utilisé dans le corps de la fonction. Je vais ajouter un échantillon de mon post.
InformationsquelleAutor Bill
6

C++11 N3337 projet de norme

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf dit que c'est légal à 8.4.1/6
"Les définitions de fonctions > En général":
Remarque: les paramètres Inutilisés doivent pas être nommés. Par exemple,
```
void print(int a, int) {
    std::printf("a = %d\n",a);
}
```
Plus précisément, 8.4.1/1 dit que la grammaire pour la définition d'une fonction est
```
function-definition:
    attribute-specifier-seqopt decl-specifier-seqopt
    declarator virt-specifier-seqopt function-body
```
Alors si vous suivez la grammaire définitions, par exemple, en vertu de "l'Annexe A du résumé de la Grammaire", vous verrez que les noms sont en option.

InformationsquelleAutor Ciro Santilli 新疆改造中心法轮功六四事件
2

Il compile parce que la langue standard spécifiquement dit qu'il doit compiler. Il n'y a pas d'autre réponse. C'est l'un des bits qui font de C++ différente de C. C paramètre noms dans la définition de la fonction doit être présente, en C++, ils sont facultatifs.

En fait je me demande pourquoi vous demandez à votre "pourquoi" question. Ne voyez-vous rien d'anormal, inhabituel ou illogique dans ce comportement?
- Je cherchais quelque chose le long des lignes de "pourquoi la norme permettre cela", comme les autres réponses ont suggéré. La réponse "Il compile parce qu'il devrait"..évident pour dire le moins.
- Coleson: eh Bien, pour moi la possibilité d'omettre le nom du paramètre (whin il n'est pas utilisé) semble naturel, la raison d'être évidente. J'ai du mal à comprendre pourquoi quelqu'un serait de demander le "pourquoi" question. En fait, je préfère attendre de quelqu'un à se demander pourquoi C ne pas le permettent, pourquoi ne pas le C++ n'. Donc, ma réponse ci-dessus est censé signifier les suivantes: il est légal en C++ et C++ spécification enfin permis (comme dans "tout le monde était en attente pour elle, et en C++, il a finalement été rendue possible").
- "Tout le monde voulait en C et en C++, il a finalement été rendue possible" est une réponse utile à "Pourquoi?", je vous remercie.
InformationsquelleAutor AnT

Vous devez vous connecter pour publier un commentaire.