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