Wrapping arguments de la fonction?

Question

Supposons que j'ai cette fonction:

void foo (struct1 &v1, struct2 &v2, ..., structn &vn){ 
    //do something with a subset some of the arguments... 
    foo1(v1, v2, ..., vn); 
} 

void foo1 (struct1 &v1, struct2 &v2, ..., structn &vn){ 
    //do something with a subset some of the arguments... 
    foo2(v1, v2, ..., vn); 
} 

... 

void foom (struct1 &v1, struct2 &v2, ..., structn &vn){ 
    //do something with a subset some of the arguments... 
} 

---

est-il une bonne pratique de résumer tous ces arguments à l'intérieur d'une structure dédiée et de l'utiliser à la place que le seul argument? Quelque chose comme:

struct wrapper{ 
    strcut1 v1; 
    struct2 v2; 
    ... 
    structn vn; 
} 

void foo (wrapper & w){ 
    //use some of w's fields 
    foo1(w); 
} 

void foo1 (wrapper & w){ 
    //use some of w's fields 
    foo2(w); 
} 

... 

void foom (wrapper & w){ 
    //use some of w's fields 
} 

Je pense que cette approche a 2 avantages:

1. Il est plus maintenable: avec la première méthode, si je dois ajouter un nouvel argument à foom, alors je dois modifier également tous les autres m-1foo en-têtes ... un cauchemar. Avec cette méthode, la seule chose à faire est d'ajouter un nouveau champ à wrapper.
2. Il est plus efficace: en supposant que les deux n (le nombre d'arguments) et m (le nombre de fonctions) est grand (par exemple à la fois 10) cela signifie que nous devons copier m*n adresses, ce qui est pas un gros frais généraux , mais à coup sûr plus grand que m.

Est-ce que tout est correct? Ai-je manqué un avantage/désavantage? Notez que la performance est ici la priorité

Pourquoi j'ai besoin de cela?

Eh bien, lisez this question pour en savoir plus à ce sujet.

Answer 1

Cela dépend du nombre de paramètres dont vous disposez.

En général, ce qui est commun est d'encapsuler de nombreux paramètres en une seule structure appelée "params" par exemple, de sorte que le prototype de la fonction n'est pas trop long.

Des exemples de ce schéma sont FLANN, kd-GeRaF (mine) et FALCONN.

Je n'ai vu aucun cas où les paramètres sont structs pour être honnête, alors c'est dans votre jugement personnel.

Answer 2

Oui, c'est mieux. Vous avez essentiellement un ensemble de variables que vous devez manipuler ensemble et qui doivent être transmises ensemble. Le principal avantage est qu'en enveloppant ce pack de variables dans un struct, vous lui donnez un nom et simplifiez les appels de fonction.

En ce qui concerne la performance: Eh bien, ce n'est probablement pas pertinent. Oui, vous passez moins d'adresses sur la pile avec l'approche encapsulée, mais cela n'accélérera pas les choses à moins que cet appel de fonction ne soit fait très souvent (= plusieurs millions de fois par seconde). Si ces appels de fonction ne font pas partie de la boucle interne de votre application (comme 99% de tout le code écrit), la différence de vitesse est sans importance.