Surcharge d'une fonction C++

Version imprimable

Bonsoir tout le monde
j'ai créé un petit code dont j'ai surchargé une fonction "fonction_surcharge".
cette fonction a 4 signatures, chacune d'elle prend des paramètres par défaut (je les ai déclaré dans le prototype).
voici le code du fichier .cpp :

Code:

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
#include <iostream>
using namespace std;
//prototypes.
float fonction_surcharge(int val1=0, float val2=2.5);
float fonction_surcharge(float val1=4.1, int val2=2);
int fonction_surcharge(int val1=0);
float fonction_surcharge(float val1=2.5);
 
int main(){
    float f;
    int i;
    cout<<"La surcharge de la fonction fonction_surcharge"<<endl;
    fonction_surcharge(2,3.8); //test(i,f)
    fonction_surcharge(4.9,10);//test(f,i)
    fonction_surcharge(6);     //test(i)
    fonction_surcharge(10.4);     //test(f)
 
    system("pause");
}
float fonction_surcharge(int val1, float val2){
    cout<<"les 2 parametre de la fontion Test sont ("<<val1<<" , "<<val2<<")"<<endl;
 
}
float fonction_surcharge(float val1, int val2){
    cout<<"les 2 parametre de la fontion Test sont ("<<val1<<" , "<<val2<<")"<<endl;
 
}
int fonction_surcharge(int val1){
    cout<<"le parametre de la fontion Test est ("<<val1<<")"<<endl;
 
}
float fonction_surcharge(float val1){
    cout<<"le parametre de la fontion Test est ("<<val1<<")"<<endl;
 
}

après compilation, le compilateur me retourne une erreur. l'erreur existe au niveau des 2 appelle de la fonction.
merci de m'aider pour en résoudre.

15/11/2010, 17h58
MacPro
Salut, regarde bien elle :
Code:

1 2 float fonction_surcharge(float val1=4.1, int val2=2);
et elle :
Code:

1 2 float fonction_surcharge(float val1=2.5);
La première tu peux l'appeler en ne précisant pas le second paramètre qui possède une valeur par défaut (int val2=2) et donc l'appeler avec un seul paramètre, du coup le compilateur ne peut faire la différence avec la seconde fonction qui ne prend qu'un seul paramètre aussi.

salut,

voila le code qui marche, pour surcharger une fonction quelconque, il ne faut surtout pas mettre des valeurs par défaut si non tu risques des ambiguïtés au niveau de chaque appel, c'est pour cela, c mieux de laisser les arguments sans initialisation et met tout ce que tu veux lors de l'appel dans le main.

Code:

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
#include <iostream>
using namespace std;
//prototypes.
float fonction_surcharge(int val1, float val2);
float fonction_surcharge(float val1, int val);
int fonction_surcharge(int val1);
int fonction_surcharge(float val1);
 
int main()
{
	int ff = 9;
    cout<<"La surcharge de la fonction fonction_surcharge"<<endl;
    float fl = fonction_surcharge(2,3.8f); //test(i,f)
    float in = fonction_surcharge(4.9f,10);//test(f,i)
    int i1   = fonction_surcharge(6);     //test(i)
    int i2 = fonction_surcharge(10.4f);     //test(f)
 
    system("pause");
}
float fonction_surcharge(int val1, float val2){
    cout<<"les 2 parametre de la fontion Test sont ("<<val1<<" , "<<val2<<")"<<endl;
       return 0.0;
}
float fonction_surcharge(float val1, int val2){
    cout<<"les 2 parametre de la fontion Test sont ("<<val1<<" , "<<val2<<")"<<endl;
return 0.0;
}
int fonction_surcharge(int val1){
    cout<<"le parametre de la fontion Test est ("<<val1<<")"<<endl;
       return 0;
}
int fonction_surcharge(float val1){
    cout<<"le parametre de la fontion Test est ("<<val1<<")"<<endl;
       return 0;
}

Cordialement

15/11/2010, 19h13
koala01
Salut,

Le problème est double:

Primo, tu ne peux surcharger une fonction qu'à partir du moment où ses signatures diffèrent par le nombre ou par le type des arguments qu'elle accepte.

Secundo, lorsque tu définis une valeur par défaut pour l'un des arguments, cela revient en réalité à autoriser une signature supplémentaire pour la fonction: celle ne nécessitant pas l'argument pour lequel tu as défini une valeur par défaut.

A titre d'exemple, une fonction proche de void foo(int i=1, int j = 2, int k =3, double d=3.1415926) va autoriser les signatures suivantes:
1. void foo()
2. void foo(int)
3. void foo(int, int)
4. void foo(int, int , int)
5. void foo(int, int, int, double)
Avec les fonctions que tu présente, tu dois donc te dire que float fonction_surcharge(int val1=0, float val2=2.5) va permettre les signatures
1. float fonction_surcharge()
2. float fonction_surcharge(int)
3. float fonction_surcharge(int, float)
et que, de son coté, float fonction_surcharge(float val1=4.5, int val2=2) va permettre les signatures
1. float fonction_surcharge()
2. float fonction_surcharge(float)
3. float fonction_surcharge(float, int)
Peut-être commence tu à repérer où se situe le problème :question: non :question: vraiment pas :question:...

Allons, réfléchis un peu...

Oui, c'est cela... lorsque l'on va invoquer la fonction en ne donnant aucun paramètre, sous la forme de
Code:

1 2 3 4 5 int main() { float result=foncton_surcharge(); }
le compilateur sera confronté à une ambigüité d'appel qu'il sera incapable de lever...:

Doit-il invoquer fonction_surcharge(float, int), en donnant 4.5 à val1 et 2 à val2 ou doit-il invoquer fonction_surcharge(int, float) en donnant 0 à val1 et 2.5 à val2 :question:

Tu dois donc veiller, lorsque tu définis des valeurs par défaut sur différentes surcharges de fonction à ce qu'il y ait toujours au moins un argument qui permette de lever cette ambigüité.

Si tu donnes une valeur par défaut aux deux arguments que nécessite une des surcharge, tu dois donc veiller à laisser au minimum le premier argument sans valeur par défaut à la deuxième.

Ainsi, ce qui fonctionnerait serait proche de
Code:

1 2 float fonction_surcharge(int val1=0, float val2=2.5) float fonction_surcharge(float val1,int val2=2)
ou, à l'inverse, proche de
Code:

1 2 float fonction_surcharge(int val1,float val2=2.5) float fonction_surcharge(float val1=4.5, int val2=2)
De cette manière, il n'y aura plus d'ambigüité lorsque tu invoquera fonction_surcharge sans donner d'argument: ce sera fonction_surcharge(int, float) dans le premier cas, et fonction_surcharge(float, int) dans le second ;)

oui Merci pour vos aides.
j'ai fait tout ce que vous avez signalé et j'ai arrivé de comprendre le problème, le PB existe au niveau des signatures.
j'ai modifié le code en enlevant l'argument par défaut que Koala01 a dis; mais toujours le compilateur n'admet pas les 2 appelles :

Code:

1
2
fonction_surcharge(6);     //test(i)
fonction_surcharge(10.4);     //test(f)

vola le code modifié :

Code:

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
#include <iostream>
using namespace std;
//prototypes.
float fonction_surcharge(int val1=0, float val2=2.5);
float fonction_surcharge(float val1, int val2=2);
int fonction_surcharge(int val1=0);
float fonction_surcharge(float val1=2.5);
 
int main(){
    float f;
    int i;
    cout<<"La surcharge de la fonction fonction_surcharge"<<endl;
    fonction_surcharge(2,3.8); //test(i,f)
    fonction_surcharge(4.9,10);//test(f,i)
    fonction_surcharge(6);     //test(i)
    fonction_surcharge(10.4);     //test(f)
 
    system("pause");
}
float fonction_surcharge(int val1, float val2){
    cout<<"les 2 parametre de la fontion Test sont ("<<val1<<" , "<<val2<<")"<<endl;
 
}
float fonction_surcharge(float val1, int val2){
    cout<<"les 2 parametre de la fontion Test sont ("<<val1<<" , "<<val2<<")"<<endl;
 
}
int fonction_surcharge(int val1){
    cout<<"le parametre de la fontion Test est ("<<val1<<")"<<endl;
 
}
float fonction_surcharge(float val1){
    cout<<"le parametre de la fontion Test est ("<<val1<<")"<<endl;
 
}

15/11/2010, 20h04
koala01
Mais tu reste confronté au même problème pour les signatures qui ne prévoient qu'un seul argument:

je n'ai parlé que des signature qui permettent un total de deux arguments, mais, si tu ajoute
Code:

1 2 int fonction_surcharge(int val1=0); float fonction_surcharge(float val1=2.5);
tu reste confronté au même problème: la valeur de retour n'intervient pas dans l'évaluation de la signature.

tu as donc pour int fonction_surcharge(int val1=0), deux signatures possibles: fonction_surcharge() et fonction_surchage(int), et de même pour float fonction_surcharge(float): tu autorise les signature fonction_surcharge() et fonction_surcharge(float).

comme fonction_surcharge(int val1=0, float val2=2.5) autorise, elle aussi, la signature fonction_surcharge(), ce n'est pas deux signatures totalement identiques que tu as, mais... trois...

Et le fait qu'une des fonctions renvoie un int n'empêchera pas l'ambigüité :aie:

Pire encore...

On se retrouve avec d'autres ambigüités...

Imagine le code suivant:
Code:

1 2 3 4 5 6 7 int main() { int i=54; float f=3.141516; fonction_surcharge(i); // (1) fonction_surcharge(f); // (2) }
quelle version de fonction_surcharge le compilateur devra-t-il invoquer :question:

Pour le (1), il hésitera entre fonction_surcharge(int) et fonction_surcharge(int, float), et pour le (2), son hésitation portera entre fonction_surcharge(float) et fonction_surcharge(float, int)

Il est donc particulièrement important, lorsque tu envisages de définir des valeurs par défaut pour les différents arguments d'une fonction que tu t'apprête à surcharger, que tu prenne le temps de réfléchir sereinement à l'ensemble des signatures que les valeurs par défaut te permettent, en gardant en mémoire que la valeur de retour n'intervient absolument pas.

Si tu te rends compte que le nom de la fonction + la liste des arguments (qui peut être vide) correspond à ce qui est autorisé par une autre surcharge pour laquelle tu as défini une ou plusieurs valeur(s) par défaut, il faut absolument que tu réfléchisse à l'opportunité de la surcharge et à celle de définir des valeurs par défaut...

C'est particulièrement vrai si les valeurs par défaut que tu envisage de définir sont incohérentes entre elles ;).

Salut,
Personnellement je n'aime pas les arguments avec des valeurs par défaut (de base) et surtout quand il y a plusieurs surcharges :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;
//prototypes.
float fonction_surcharge(int val1, float val2)
{
// effective implementation
}
float fonction_surcharge(float val1, int val2)
{
   return fonction_surcharge(val2, val1);
}
float fonction_surcharge(int val1)
{
   return fonction_surcharge(val1,2.5);
}
float fonction_surcharge(float val1);
{
   return fonction_surcharge(2,val1);
}
float fonction_surcharge();
{
   return fonction_surcharge(2,2.5);
}

15/11/2010, 20h24
alfred5
donc je garderai 2 prototype seulement qui vont rassembler toute les possibilités lorsque nous appellerons notre fonction.
il me reste une seule erreur, c'est la dernière appelle :

Code:

fonction_surcharge(10.4); //test(f)

il ne sait pas différencier entre les deux prototypes :
Code:

1 2 3 float fonction_surcharge(int val1, float val2=2.5); float fonction_surcharge(float val1=4.1, int val2=2);
15/11/2010, 20h27
dev_2007

bah wé c'est normale, le problème est causé par les valeurs par défauts que t'as attribuées lors de la déclaration.
15/11/2010, 20h37
alfred5
oui, effectivement.
j'ai arrivé a exécuter le programme sans que le compilateur me retourne un erreur; mais j'ai pas répondu totalement à l'exercice .
j'ai utilisé seulement les 2 prototypes suivants :
Code:

1 2 float fonction_surcharge(int val1, float val2); float fonction_surcharge(float val1=4.1, int val2=2);
15/11/2010, 20h39
3DArchi

Citation:

Envoyé par alfred5

mais j'ai pas répondu totalement à l'exercice.

C'est quoi l'énoncé de ton exercice précisément ?
15/11/2010, 20h49
alfred5

voila l'énoncé :
Ecrire un programme qui fait appelle une fonction "fonction_surcharge" de 4 manière. r est réel et i un entier :
fonction_surcharge(i,r): variables par défaut i=0 ; r=2.4
fonction_surcharge(r,i): variables par défaut r=2.4 ; i=2
fonction_surcharge(i): variables par défaut i=0 ; r=2.5
fonction_surcharge(r): variables par défaut i=0 ; r=2.5
la fonction doit retourner seulement les valeurs de leurs paramètres.
a titre d'exemple on fait un appelle dans le main comme suivant :
fonction_surcharge(2,3.8); //test(i,f)
fonction_surcharge(4.9,10);//test(f,i)
fonction_surcharge(6); //test(i)
fonction_surcharge(10.4); //test(f)