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.
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
Je me suis toujours demandé quelles étaient les différences, d'un point de vue implication / choix ?Envoyé par Jean-Marc.Bourguet
Les parametres avec une valeur par defaut sont plus simples a ajouter.Envoyé par Aurelien.Regat-Barrel
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
dont l'appel fonctionnera donc sans fournir de parametre, vu qu'ils ont tous leur valeur par défaut...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3 type& mafonction(const std::string& str="", int i=0, float f=0.0, double d=1e-10, long l=0xFFFFDD)
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
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:
je ne peux pas combiner le redimensionnement avec la transparence, c'est l'un XOR l'autre.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3 void Draw(); void Draw( const Size & ); void Draw( float Oppacity );
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
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
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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); }
en tant que parametre par defaut:Envoyé par koala01
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 : Sélectionner tout - Visualiser dans une fenêtre à part void test( int & = ??? ) {}
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.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2 void draw(size); void draw(opacity);
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é
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager