Discussion :

[Seabast888]

Salut!

Un sujet simple à la base, la surchage. Je ne comprend absolument pas pourquoi je reçois des erreurs. Voici le code :

Code surcharge.h :

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

1
2
3
4
5
//commentaire supprimé...
 
int addition (int x, int y);
 
float addition (float x, float y);

Code surcharge.cpp :

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
 
#include "surcharge.h"
 
int addition (int x, int y)
{
int somme = 0;
somme = x + y;
 
return somme;
}
 
float addition (float x, float y)
{
float somme = 0.0;
somme = x + y;
 
return somme;
}

Code main.cpp :

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

1
2
3
4
5
6
7
8
9
10
int main()
{

cout << "Le résultat de l'addition de deux int est : " << addition(1,2) << endl;
cout << "Le résultat de l'addition de deux float est : " << addition(10.2,3.2) << endl; //Erreur ici
  cout.flush();
  cout << "\nAppuyer sur une touche pour quitter.";
  cin.get();
}

Voici les erreurs reçu :

Code X :

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

1
2
3
error C2668: 'addition' : ambiguous call to overloaded function
could be 'float addition(float,float)'
or       'int addition(int,int)'

On dirait qu'il ne comprend pas la surcharge.... :s
Une idée ? - c'est surement tout simple et je ne vois pas...

merci !

[Seabast888]

Après test, si je change pour éliminer la surcharge et changer addition pour additionFloat, dans le deuxième addition, ça compile, crée un .exe, mais me donne un erreur de troncation entre un double et un float....

Mais je ne comprend toujours pas pourquoi la surcharge ne fonctionne pas et pourquoi il doit faire une troncation...

En espérant que ça donne plus d'info pour trouver le problème...

merci !

[JulienDuSud]

Code :

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

cout << "Le résultat de l'addition de deux float est : " << addition(10.2f,3.2f) << endl;

[Médinoc]

Explication à la réponse de JulienDuSud: Sans le f, les constantes sont considérées comme des double plutôt que des float...

[JolyLoic]

Précision de l'explication : Un double est convertible en float. Un double est convertible en int. Des deux conversions, aucune n'a la priorité, elles sont considérées équivalentes. Il y a donc ambiguïté.


Et à part ça, j'espère que tu as de bonnes raisons pour effectuer des calculs en float, plutôt qu'en double... Généralement (c'est à dire à moins d'avoir effectué une analyse numérique du code, chose que peu de gens savent faire, et surtout pas moi), on effectue les calculs dans la précision maximale de la machine, quitte à stocker les résultats dans une précision plus faible si la place mémoire importe. Si on doit faire des calculs en virgules flottantes, le type par défaut devrait être double, pas float.

[koala01]

Salut,

Ceci dit:

La "zéro initialisation" de ta variable somme ne sert finalement pas à grand chose ici, vu que tu lui affecte directement une valeur différente.

Le fait d'initialiser une variable à une valeur constante (ici 0)n'a effectivement un intérêt que lorsque tu souhaite faire intervenir ta variable dans d'autres opérations et que tu n'a pas la possibilité de lui donner directement la valeur qui lui convient

Ton code pourrait donc très facilement se simplifier en

Code :

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

1
2
3
4
5
int addition( int x, int y)
{
    int somme=x+y;
    return somme;
}

Et, comme en C++, le type du résultat d'une opération mathématique peut être déduit par le type des deux opérandes (surtout s'ils sont identiques), et que somme est de toutes manières une variable temporaire, tu pourrais même encore simplifier le code en

Code :

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

1
2
3
4
int addition(int x, int x)
{
    return x+y;
}

Enfin, il faut savoir que C++ est un langage "multi-paradigme" (pour faire simple:qui permet de travailler selon divers points de vue), et qu'il propose, entre autres, le paradigme de programmation générique.

Pour faire simple, l'idée générale de la programmation générique est de se dire que

j'ignore quel type de donnée je vais manipuler, mais je sais très bien comment je vais la manipuler

Or, tu auras remarqué que, dans le code que tu présente, tu manipule x et y d'une manière strictement identique lorsqu'ils sont des entiers (int) et des réels (float)...

Mieux encore, tu les manipulera de manière identique quelle que soit leur type pour autant que le type accepte l'opérateur "+".

Tu peux donc envisager de te simplifier énormément la vie en utilisant le paradigme de programmation générique et en créant une fonction template dont le principe revient à dire

Quel que soit le type de x et de y, je sais que je veux renvoyer le résultat obtenu par x+y, pour autant que le type en question accepte l'opérateur +

Ce sera alors le compilateur qui créera automatiquement les différentes surcharges dont il a besoin en fonction des types réellement manipulés, et, au final, tu pourrais très bien avoir un code 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
/* laissons le compilateur déterminer le type de données réellement utilisé */
template <typename T>
T addition(T x, T y)
{
    return x + y;
}
/* et admirons le résultat */
int main()
{
    cout<<"Addition de deux int :"<<addition(300000,41)<<endl
        <<"Addition de deux reels (double) : "<<addition(3.141592, 6.3)<<endl
        <<"Addition de deux reels (float) : "<<addition(2.3f,6.1f)<<endl;
    return 0;
}

(power inside )

[Seabast888]

Bonjour,

Koala1, merci, excellent exemple de template, moi qui commence tout juste à utiliser les templates et voir ce que ça fait !
Et je ne savais pas pour le return x+y; Ça simplifie bien du code "inutile". Mais en fait, mon premier but ici était d'être très clair dans mes opérations pour tester uniquement la surcharge. Mais une fois ce but accomplit, aller plus loin va de soi ! ;-)

En fait, à la base, mon erreur était une simple erreur de syntaxe... Bon, il faut bien commencer quelque part

Bref, merci à tous pour votre aide !

D'ailleurs, j'ai un autre pépin, toujours dans le même thème de la surcharge, mais avec un tableau. Ici, la surcharge semble fonctionner. Par contre, je reçois les adresses mémoires et non les valeurs contenu dans le tableau... Possiblement un erreur de manipulation de tableau ?

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
 
**Toujours considérant le code précédent..**
 
main.cpp
int tab1[] = {3,2,4};
int tab2[] = {4,3,2};
 
 
cout << "Le résultat de l'addition de deux tableaux est : " << addition(tab1,tab2) << endl;
 
surcharge.cpp
int addition (int tabX[], int tabY[])
{
int somme;
int sommeFin;
int i;
int MAX = 10;
 
	for (i=0; i<MAX; i++){
		somme = tabX[i] + tabY[i];
		sommeFin = sommeFin + somme;
	}
 
return sommeFin;
}

Je continue à chercher de mon côté aussi !

Merci !

[koala01]

Attention, un tableau "C style" (qui est ce que tu utilise ici) ne connait pas sa taille, et tu ne peux absolument pas préjuger de ce qui se trouve... après le dernier élément.

En effet, ce qui se trouve en mémoire peut être strictement tout et n'importe quoi, souvent des "crasses" laissées par des utilisation antérieures de la mémoire.

Ainsi, si on prend ton code comme exemple, lorsque tu utilise deux tableaux qui contiennent chacun trois éléments, les seules valeurs dont tu puisse être sur sont... celles qui correspondent à un indice correct du tableau (autrement dit, dans l'exemple, tab1[0], tab1[1], tab1[2], tab2[0], tab2[1] et tab2[2]), et, dés que i vaudra plus de 2, tu t'expose à des problèmes d'incohérence sans nom (voir à des problèmes bien plus graves le jour ou tu n'essaye pas, simplement, de demander la valeur qui s'y trouve).

Pour t'en convaincre, qu'il te suffise de copier le code suivant (qui n'est qu'une adaptation de ce que tu fais ):

Code :

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

1
2
3
4
5
6
7
8
9
#include <iostream> //pour cout et endl
using namespace std; //pour la facilité !!! JAMAIS dans un fichier d'en-tête
int main()
{
    int tab1[] = {3,2,4};
    for(int i=0;i<10;++i)
        cout<< "I = "<<i<<" : "<<tab1[i]<<endl;
    return 0;
}

qui donne, au moment où j'ai fait le test:

Code :

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

1
2
3
4
5
6
7
8
9
10
I = 0 : 3
I = 1 : 2
I = 2 : 4
I = 3 : 3
I = 4 : 1
I = 5 : 0
I = 6 : 8
I = 7 : 0
I = 8 : 1
I = 9 : 0

et qui pourrait tout à fait donner une sortie différente (pour I>2) chez toi...

Pour éviter ce problème, il faut veiller, non pas à placer une limite arbitraire à l'index, mais à fournir la taille de chaque tableau, et de veiller à ce que l'on ne dépasse pas les indexes possibles.

De même, bien que je sois pris d'un doute sur ce fait particulier, il est largement préférable d'initialiser les variables au moment où tu déclares, à moins que tu n'aies la certitudes que, quoi qu'il arrive, elles seront initialisées correctement avant que tu n'essaye d'en connaitre la valeur (principalement somme et sommeFin) .

De plus, contrairement au C, le C++ permet de déclarer une variable strictement à n'importe quel moment.

Une "bonne habitude" à prendre est donc de ne déclarer les variables... que lorsque l'on en a besoin.

Enfin, tu pourrais t'éviter bien du code en utilisant les opérateur +=, qui, en outre, sont me semble-t-il plus efficaces en termes de performances (bien que dans le cas présent, cela ne présente pas vraiment un intérêt primordial).

Le code corrigé pourrait, en prenant toutes ces remarques en comptes, ressembler à

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
int addition(int tab1[],int tab2[],int size1, int size2)
{
    int sommeFin = 0;
    /* il faut savoir la taille du plus grand tableau */
    int max=(size1 > size2 ? size1 : size2) /* revient au meme que
    * int max;
    * if (size1>size2)
    *    max=size1;
    * else 
    *    max=size2;
    */
    for(int i=0;i<max;++i)
    {
        /* soit, l'index est  valide pour les deux tableaux,
         * soit il ne l'est quepour tab1, 
         * soit il ne l'est que pour tab2...
         */
        int somme;
        if(i<size1 && i<size2)
            somme=tab1[i]+tab2[i];
        else if (i>=size1 && i<size2)
            somme=tab2[i];
        else if (i<size1 && i>=size2)
            somme=tab1[i];
         sommeFin+=somme;
    }
    return sommeFin;
}

Enfin, le fait que les tableaux C styles ne connaissent pas leur taille est l'une des raisons, bien que ce ne soit pas la raison principale, pour lesquelles il est largement préférable d'utiliser les classes propres aux C++ (la classe vector, disponible dans l'espace de noms std par simple inclusion du fichier d'en-tête <vector>, en l'occurrence) plutôt que des tableaux C style.

Mais cela, c'est un autre débat