Discussion :

[kochfet]

Salut,

Est il possible en C++ d'implémenter une fonction ou le nombre de ses paramètres dépend d'un nombre donné par l'utilisateur?
par exemple, si on donne un nombre égale à deux la fonction dépendra ainsi de deux paramètres, si on donne 3 elle dépendra de 3 paramètres...

Merci d'avance.

[ternel]

Bonjour,
Ma réponse ne va pas forcément te plaire:
"Ca dépend".
Dans l'absolu non, mais on peut certainement se débrouiller autrement.
Quel est ton objectif?

On peut imaginer d'avoir plusieurs ensemble de fonctions, et d'utiliser les bonnes.
On a aussi la fonction à arguments variable (avec le ...), comme le printf.

[oodini]

Est il possible en C++ d'implémenter une fonction ou le nombre de ses paramètres dépend d'un nombre donné par l'utilisateur?
par exemple, si on donne un nombre égale à deux la fonction dépendra ainsi de deux paramètres, si on donne 3 elle dépendra de 3 paramètres...

C'est ce que fait la fonction main().

[PilloBuenaGente]

Bonjour,

Cela peut dépendre des paramètre et ce qu'on en fait.

Première méthode serait la surcharge :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void Foo( const int p_1 ) {
    ....
}
void Foo( const int p_1, const int p_2 ) {
    ....
}
...
//Ou bien
void Foo( const int p_1, const int p_2 = 0 ) {
    ....
}

Sinon il serait possible d'avoir un tableau en paramètre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void Foo( const std::vector& liste_de_parametre ) {
...
}

[JolyLoic]

C'est ce que fait la fonction main().

Ah bon ? Main possède plusieurs surcharges, mais n'accepte pas un nombre variable d'arguments...

Pour répondre au post initial, si les données sont toutes de même type, il est souvent préférable d'avoir une fonction à 1 paramètre de type conteneur (on lui passe par exemple un vector<T>n ou en C++11 un initializer_list<T>).

Si les types divergent, il y a alors les fonctions variadiques (qui posent plein de problèmes, en particulier, elles ne marchent pas avec les types trop évolués), ou bien, avec un compilateur qui les gère, les fonctions template variadiques (qui demandent une maîtrise minimale de la metaprogrammation template pour être utilisées).

[oodini]

Ah bon ? Main possède plusieurs surcharges, mais n'accepte pas un nombre variable d'arguments...

Exact. Mea culpa.
cela fait trop longtemps que je n'ai pas eu affaire à un main.

[kochfet]

Je pense que je veux essayer d'utiliser les fonctions variadique.

Si les types divergent, il y a alors les fonctions variadiques (qui posent plein de problèmes, en particulier, elles ne marchent pas avec les types trop évolués)

Est il possible de m'expliquer un peu comment?

[PilloBuenaGente]

Quel est le problème rencontré ?

N'y a t-il pas moyen de le contourner ?

Et avoir une fonction pour chaque paramètre ?

[koala01]

Salut,

A vrai dire, j'ai envie de dire : pour quoi faire

A priori, une fonction ne doit demander comme argument que les informations qu'elle n'est pas en mesure de récupérer "par elle-même", mais une fonction est aussi sensée avoir un comportement clairement défini

A partir de là, on peut estimer que
1- soit la fonction va traiter des information "par lot", et donc, l'idéal est sans doute de transmettre une collection d'informations de type similaires (par exemple : std::vector<UnTypeQuelconque>),

2- soit "il est possible" d'avoir une série d'argument pour lesquels on peut déterminer des valeurs par défaut

3- on peut estimer que le nombre d'information sera fixe (un, deux ou N arugment) mais que leur type sera différent: on pourra alors envisager la surcharge de fonction

4- La fonction (prenant plusieurs informations) ne correspond en réalité qu'à l'appel de différentes surcharges pour un type particulier (c'est souvent utilisé en OO, en faisant en sorte que la fonction renvoie une référence sur l'objet courent )

Je pense que je veux essayer d'utiliser les fonctions variadique.

Si tu est dans une situation proche du 4, et que tu peux utiliser les possibilités offertes par C++11, je te conseillerais bien de t'orienter vers les template variadic.
Tu pourrais parfaitement avoir une fonction surchargée proche de

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
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <string>
#include <ctime>
void foo(int i){
    std::cout<<"using an int as "<<i<<std::endl;
}
void foo(std::string const & i){
    std::cout<<"using a string as "<<i<<std::endl;
}
void foo(tm const & i){
    const char * temp=asctime(&i);
    std::cout<<"using a time as"<< temp<<std::endl;
}
 
template <typename T, typename... Others>
void foo(T data, Others... rest){
    foo(data);
    foo(rest...);
 
}
int main(){
 
  time_t rawtime;
  struct tm * timeinfo;
  time ( &rawtime );
  timeinfo = localtime ( &rawtime );
  std::string hello("hello");
  std::string world("world");
  int i=0,j=2,k=3,l=4;
foo(hello,i,*timeinfo,j,world,k,l);
return 0;
}

Mais, si tu travailles en C++, peut etre préféreras tu quelque chose comme

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <iostream>
#include <string>
#include <ctime>
#include <sstream>
class MaClass{
public:
    MaClass& foo(int i){
        std::stringstream ss;
        ss<<str<<" "<<i;
        str=ss.str();
        return *this;
    }
    MaClass & foo(std::string const & i){
        str.append(" ")
           .append(i);
        return *this;
    }
    MaClass & foo(tm * t){
        str.append(" ")
           .append(asctime(t));
        return *this;
    }
    std::string const &  theString() const{return str;}
private:
    std::string str;
 
};
int main(){
 
  time_t rawtime;
  struct tm * timeinfo;
  time ( &rawtime );
  timeinfo = localtime ( &rawtime );
  std::string hello("hello");
  std::string world("world");
  int i=0,j=2,k=3,l=4;
  MaClass obj;
  obj.foo(i)
     .foo(hello)
     .foo(j)
     .foo(world)
     .foo(k)
     .foo(timeinfo)
     .foo(l);
std::cout<<obj.theString()<<std::endl;
return 0;
}