Sur les paramètres sans nom aux fonctions, C++
Ce qui suit est un code C++ parfaitement légal
void foo (int) {
cout << "Yo!" << endl;
}
int main (int argc, char const *argv[]) {
foo(5);
return 0;
}
Je me demande s'il y a une valeur pour laisser des paramètres sans nom dans les fonctions, étant donné qu'ils ne peuvent pas être référencés à partir de la fonction.
Pourquoi est-ce légal pour commencer?
3 réponses
Oui, c'est légal. Ceci est utile pour les implémentations de virtuals de la classe de base dans les implémentations qui n'ont pas l'intention d'utiliser le paramètre correspondant: vous devez déclarer le paramètre correspond à la signature de la fonction virtuelle dans la classe de base, mais vous n'envisagez pas de l'utiliser, de sorte que vous ne spécifiez pas le nom.
L'autre cas courant est lorsque vous fournissez un rappel à une bibliothèque, et vous devez vous conformer à une signature que la bibliothèque a établie (merci, Aasmund Eldhuset pour avoir soulevé cette question).
Il y a aussi un cas particulier pour définir vos propres opérateurs post-Incrémentation et post-Décrémentation : ils doivent avoir une signature avec un paramètre int, mais ce paramètre est toujours inutilisé. Cette convention est à la limite d'un hack dans la conception du langage, cependant.
Bien sûr, ne pas nommer un paramètre est légal lors de la simple déclaration de la fonction, mais c'est aussi légal dans l'implémentation. Cette dernière version apparemment étrange est utile lorsque la fonction doit déclarer le paramètre pour avoir une signature fixe spécifique, mais le paramètre n'est pas nécessaire.
Cela peut se produire par exemple pour une méthode dans une classe dérivée, pour une fonction de rappel ou pour un paramètre de modèle.
Ne pas donner de nom au paramètre indique clairement que le paramètre n'est pas nécessaire et sa valeur ne sera pas utilisée. Certains compilateurs si vous nommez à la place un paramètre et ne l'utilisez tout simplement pas émettront un avertissement qu'il y a peut-être un problème avec le corps de la fonction.
Je veux juste ajouter qu'il y a parfois une différence si vous nommez un paramètre ou non. Par exemple, le compilateur traite une référence rvalue nommée en tant que lvalue et une référence rvalue sans nom en tant que rvalue.
// named-reference.cpp
// Compile with: /EHsc
#include <iostream>
using namespace std;
// A class that contains a memory resource.
class MemoryBlock
{
// TODO: Add resources for the class here.
};
void g(const MemoryBlock&)
{
cout << "In g(const MemoryBlock&)." << endl;
}
void g(MemoryBlock&&)
{
cout << "In g(MemoryBlock&&)." << endl;
}
MemoryBlock&& f(MemoryBlock&& block)
{
g(block);
return block;
}
int main()
{
g(f(MemoryBlock()));
}
Cet exemple produit la sortie suivante:
En g (const MemoryBlock&).
En g (MemoryBlock&&).
Dans cet exemple, la fonction Principale Passe un rvalue à f. Le corps de f traite son paramètre nommé comme une lvalue. Le appel de f à g lie le paramètre à une lvalue de référence (la première version surchargée de g).