Déclaration fonction avec nombre parametres variables

Bonjour tout le monde,

Je veux créer une fonction avec un nombre de paramètres variables.

à peut près comme le printf avec laquelle on peut écrire un nombre de variables paramètres.

Là :
http://c.developpez.com/faq/c/?page=..._args_variable

Mais en C++ on fait beaucoup mieux :
http://c.developpez.com/faq/cpp/?pag...hainage_appels

Deux autres possibilites permettant de traiter certaines utilisations:
- la surcharge
- les parametres ayant une valeur par default

Citation:

---

Envoyé par Jean-Marc.Bourguet

Deux autres possibilites permettant de traiter certaines utilisations:
- la surcharge
- les parametres ayant une valeur par default

---

Je me suis toujours demandé quelles étaient les différences, d'un point de vue implication / choix ?

Citation:

---

Envoyé par Aurelien.Regat-Barrel

Je me suis toujours demandé quelles étaient les différences, d'un point de vue implication / choix ?

---

Les parametres avec une valeur par defaut sont plus simples a ajouter.

La surcharge permet:
- d'avoir un comportement plus different de maniere raisonnable
- d'avoir des pointeurs de fonctions pour toutes les signatures apparentes
- un plus grand choix de signature (les parametres avec une valeur par defaut sont d'office a la fin)

Salut,

Une fonction avec un certain nombre d'argument par défaut aura cependant un inconvéniant majeur:

Rien n'empeche de fournir une déclaration de fonction sous la forme de

Code:

---

1 2 3

type& mafonction(const std::string& str="", int i=0, float f=0.0, double d=1e-10, long l=0xFFFFDD)

---

dont l'appel fonctionnera donc sans fournir de parametre, vu qu'ils ont tous leur valeur par défaut...

Seulement, si tu veux fournir une valeur différente de 0xFFFDD pour l, tu sera obligé de fournir une valeur pour str, i, f et d :P

Si, parce que ca peut arriver, ta fonction a réellement besoin, lors de son appel, de tous les arguments, qu'il aient ou non gardé leur valeur par défaut, ce sera effectivement ainsi qu'il faudra fonctionner...

Si, par contre, la fonction doit etre chainée en acceptant soit une chaine, soit un entier, soit un réel, soit un long... ce sera vers la surchage qu'il faudra te tourner ;)

Merci. Et le parametre par defaut ne peut pas etre du type reference non const si je ne m'abuse.


Mais je me demandais surtout s'il vaut-il mieux enrichir une fonction deja existante et largement utilisee dans un projet en lui ajoutant un nouveau parametre par defaut ou creer une nouvelle surcharge (qui peut appeller cette fonction existante).

C'est quelque chose que l'on decide intuitivement, mais ca a des implications differentes que je maitrise mal. En reflechissant, je dirais que l'on peut ajouter des parametres a ceux existants s'ils peuvent etre combines avec ces derniers pour influencer le comportement de la fonction.

Exemple:
si je veux enrichir la fonction Draw() pour lui donner la capacite de dessiner en transparence ainsi que la possibilite de redimensionner le dessin, avec la surcharge:

Code:

---

1 2 3

void Draw(); void Draw( const Size & ); void Draw( float Oppacity );

---

je ne peux pas combiner le redimensionnement avec la transparence, c'est l'un XOR l'autre.

En ce qui concerne l'ajout de parametre, j'ai du mal a en cerner les limitations / abus. Ce qui me gene c'est que modifier une signature revient a casser le contrat initial de la fonction vis a vis du code qui l'utilise. La valeur par defaut rattrappe le coup, mais bon... Et souvent, l'utilisation que j'en ai vu sert a bidouiller une correction de bug dans un cas particulier.

Je ne vois pas pourquoi un parametre fournis par référence ne pourrait etre que constant (je suis pris d'un doute)... Mais, ceci dit, dans la plupart des cas, je ne vois pas l'intéret qu'il y aurait à passer une référence non constante ;)

Si tu veux, dessiner, dans un meme temps ton image redimentionnée en y applicant une transparence, tu va vers plusieurs choix possible

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

void draw();//trace normal void draw(const Size& size, float opacity=1.0)//si opacity n'est pas fournis, //une transparence nulle // est appliquée ;) { //pourrait etre /* tout ce qui a trait à la taille */ if(opacity <1.0) draw(opacity); } void draw(float opacity);//pas de redimentionnement // OU - OU - OU void draw();//tracé normal void draw(const Size&);//redimentionnement uniquement void draw(float opacity);//transparence uniquement void draw(const Size& size, float opacity)//transparence et redimentionnement { //pourrait etre, meme si cela prendrait plus de temps // à l'exécution void draw(size); void draw(opacity); }

---

Ceci dit, étant donné qu'un redimentionnement suivi de l'application d'une transparence prendrait deux fois plus de temps, il serait *peut etre* intéressant d'envisager de faire le tout dans une seule fonction :P

Citation:

---

Envoyé par koala01

Je ne vois pas pourquoi un parametre fournis par référence ne pourrait etre que constant (je suis pris d'un doute)...

---

en tant que parametre par defaut:

Code:

---

void test( int & = ??? ) {}

---

Suite a tes remarques suivantes, je precise que dans mon exemple Draw() dessine un dessin sur une sortie, sans modifier le dessin, mais juste la maniere de le dessiner. Si tu fais 2 appels successifs:

Code:

---

1 2	void draw(size); void draw(opacity);

---

seul draw(opacity) sera visible, car il aura ecrase le premier dessin qui ne sera pas visible. Et surtout, le draw(opacity) ne sera pas a la taille du premier.

Bah... C'est surtout parce que je ne savais pas exactement ce que devait faire draw()...

Donc, la solution consiste bel et bien à utiliser un algorithme qui redimentionne en appliquant une transparence ;)

Mais, sur ce coup... tout dépendra des informations dont tu disposes pour effectuer le tracé :P