C++ Comment avertir de la différence entre les noms d'arguments dans la déclaration de fonction et la définition

Question

Existe-t-il un moyen d'être averti de l'absence d'appariement des noms d'arguments entre une déclaration de fonction et sa définition?

Déclaration

double divide(int a, int b); 

Définition

double divide(int b, int a) 
{ 
    return a/b; 
} 

Pour un utilisateur, qui utilisent la fonction divide s'attendront a/b en conséquence et non b/a.

Je sais, le compilateur ne peut pas faire cela, mais y a-t-il des outils d'analyse statique qui peuvent le faire? Si oui, lesquels?

Answer 1

Vous pouvez utiliser clang-tidy. L'appeler un compilateur est un peu exagéré, mais il y a peut-être une option pour faire des avertissements de clang-tidy. L'option spécifique que vous souhaitez est readability-inconsistent-declaration-parameter-name.

Answer 2

Le compilateur ne se soucie pas des noms d'argument dans votre déclinaison, vous pouvez même écrire void foo(int, int);, donc il n'y a pas de discordance, et il n'y a pas d'avertissement. Si, pour une raison ou une autre, vous trouvez que cette incompatibilité est confuse, omettez simplement les noms d'arguments dans les déclarations.

Answer 3

Êtes-vous simplement intéressé par la vérification du code existant, ou voulez-vous vous assurer que le code évite ce problème et que vous êtes prêt à reconcevoir les interfaces?

Dans ce dernier cas:

Si vous avez plusieurs arguments du même type alors des incohérences peuvent être un problème (et je l'ai vu pire que votre exemple):

void foo(bool fast, bool small, bool trivial); 
foo(true, false, false); 

Ce que vous demandez car est un moyen de s'assurer que la déclaration et la définition de foo sont cohérentes - mais vous ignorez les incohérences entre l'appel et la déclaration.

Une solution différente consiste à créer à la place un argument-struct avec setRoutines. Quelque chose comme:

struct FooArg { 
    bool fast, small, trivial; 
    FooArg &setFast(bool fast_) {fast=fast_;return *this;}; 
    ... 
}; 
void foo(FooArg const&); 
foo(FooArg().setFast(true).setSmall(false)...); 

Vous pouvez alors éviter la contradiction entre la déclaration, la définition et appeler, mais doivent être plus bavard. (Je suis sûr qu'il ya une réponse à propos de cette technique quelque part.)