Discussion :

[alfred5]

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 :

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
#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.

[MacPro]

Salut, regarde bien elle :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
 
float fonction_surcharge(float val1=4.1, int val2=2);

et elle :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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.

[dev_2007]

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 :

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
#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

[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 non vraiment pas ...

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

[alfred5]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

vola le code modifi� :

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
#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;
 
}

[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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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�

Pire encore...

On se retrouve avec d'autres ambig�it�s...

Imagine le code suivant:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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

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 .

[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 :

S�lectionner tout - Visualiser dans une fen�tre � part

fonction_surcharge(10.4);     //test(f)

il ne sait pas diff�rencier entre les deux prototypes :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
 
float fonction_surcharge(int val1, float val2=2.5);
float fonction_surcharge(float val1=4.1, int val2=2);

[3DArchi]

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 :

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
#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);
}